diff --git a/src/xml/xml_api.cc b/src/xml/xml_api.cc
index 6952836f..bde10787 100644
--- a/src/xml/xml_api.cc
+++ b/src/xml/xml_api.cc
@@ -98,9 +98,11 @@ mjModel* mj_loadXML(const char* filename, const mjVFS* vfs,
                     char* error, int error_sz) {
 
   // parse new model
-  std::unique_ptr<mjSpec, std::function<void(mjSpec*)>> spec(
-      ParseXML(filename, vfs, error, error_sz),
-      [](mjSpec* s) { mj_deleteSpec(s); });
+  std::unique_ptr<mjSpec, std::function<void(mjSpec*)> > spec(
+    ParseXML(filename, vfs, error, error_sz),
+    [](mjSpec* s) {
+      mj_deleteSpec(s);
+    });
   if (!spec) {
     return nullptr;
   }
@@ -166,7 +168,7 @@ int mj_printSchema(const char* filename, char* buffer, int buffer_sz, int flg_ht
   // print to stringstream
   mjXReader reader;
   std::stringstream str;
-  reader.PrintSchema(str, flg_html!=0, flg_pad!=0);
+  reader.PrintSchema(str, flg_html != 0, flg_pad != 0);
 
   // filename given: write to file
   if (filename) {
diff --git a/src/xml/xml_native_reader.cc b/src/xml/xml_native_reader.cc
index 104c606b..4f941c15 100644
--- a/src/xml/xml_native_reader.cc
+++ b/src/xml/xml_native_reader.cc
@@ -54,7 +54,7 @@ using mujoco::user::FilePath;
 using tinyxml2::XMLElement;
 
 void ReadPluginConfigs(tinyxml2::XMLElement* elem, mjsPlugin* p) {
-  std::map<string, string, std::less<>> config_attribs;
+  std::map<string, string, std::less<> > config_attribs;
   XMLElement* child = FirstChildElement(elem);
   while (child) {
     string_view name = child->Value();
@@ -960,31 +960,31 @@ void mjXReader::Compiler(XMLElement* section, mjSpec* spec) {
 
   // top-level attributes
   if (MapValue(section, "autolimits", &n, bool_map, 2)) {
-    spec->compiler.autolimits = (n==1);
+    spec->compiler.autolimits = (n == 1);
   }
   ReadAttr(section, "boundmass", 1, &spec->compiler.boundmass, text);
   ReadAttr(section, "boundinertia", 1, &spec->compiler.boundinertia, text);
   ReadAttr(section, "settotalmass", 1, &spec->compiler.settotalmass, text);
   if (MapValue(section, "balanceinertia", &n, bool_map, 2)) {
-    spec->compiler.balanceinertia = (n==1);
+    spec->compiler.balanceinertia = (n == 1);
   }
   if (MapValue(section, "strippath", &n, bool_map, 2)) {
-    spec->strippath = (n==1);
+    spec->strippath = (n == 1);
   }
   if (MapValue(section, "fitaabb", &n, bool_map, 2)) {
-    spec->compiler.fitaabb = (n==1);
+    spec->compiler.fitaabb = (n == 1);
   }
   if (MapValue(section, "coordinate", &n, coordinate_map, 2)) {
-    if (n==1) {
+    if (n == 1) {
       throw mjXError(section, "global coordinates no longer supported. To convert existing models, "
-                              "load and save them in MuJoCo 2.3.3 or older");
+                     "load and save them in MuJoCo 2.3.3 or older");
     }
   }
   if (MapValue(section, "angle", &n, angle_map, 2)) {
-    spec->compiler.degree = (n==1);
+    spec->compiler.degree = (n == 1);
   }
   if (ReadAttrTxt(section, "eulerseq", text)) {
-    if (text.size()!=3) {
+    if (text.size() != 3) {
       throw mjXError(section, "euler format must have length 3");
     }
     memcpy(spec->compiler.eulerseq, text.c_str(), 3);
@@ -1002,18 +1002,18 @@ void mjXReader::Compiler(XMLElement* section, mjSpec* spec) {
     mjs_setString(spec->texturedir, texturedir.c_str());
   }
   if (MapValue(section, "discardvisual", &n, bool_map, 2)) {
-    spec->compiler.discardvisual = (n==1);
+    spec->compiler.discardvisual = (n == 1);
   }
   if (MapValue(section, "usethread", &n, bool_map, 2)) {
-    spec->compiler.usethread = (n==1);
+    spec->compiler.usethread = (n == 1);
   }
   if (MapValue(section, "fusestatic", &n, bool_map, 2)) {
-    spec->compiler.fusestatic = (n==1);
+    spec->compiler.fusestatic = (n == 1);
   }
   MapValue(section, "inertiafromgeom", &spec->compiler.inertiafromgeom, TFAuto_map, 3);
   ReadAttr(section, "inertiagrouprange", 2, spec->compiler.inertiagrouprange, text);
   if (MapValue(section, "alignfree", &n, bool_map, 2)) {
-    spec->compiler.alignfree = (n==1);
+    spec->compiler.alignfree = (n == 1);
   }
 
   // lengthrange subelement
@@ -1024,10 +1024,10 @@ void mjXReader::Compiler(XMLElement* section, mjSpec* spec) {
     // flags
     MapValue(elem, "mode", &opt->mode, lrmode_map, lrmode_sz);
     if (MapValue(elem, "useexisting", &n, bool_map, 2)) {
-      opt->useexisting = (n==1);
+      opt->useexisting = (n == 1);
     }
     if (MapValue(elem, "uselimit", &n, bool_map, 2)) {
-      opt->uselimit = (n==1);
+      opt->uselimit = (n == 1);
     }
 
     // algorithm parameters
@@ -1143,8 +1143,8 @@ void mjXReader::Size(XMLElement* section, mjSpec* spec) {
   // read memory bytes
   {
     constexpr char err_msg[] =
-        "unsigned integer with an optional suffix {K,M,G,T,P,E} is expected in "
-        "attribute 'memory' (or the size specified is too big)";
+      "unsigned integer with an optional suffix {K,M,G,T,P,E} is expected in "
+      "attribute 'memory' (or the size specified is too big)";
 
     auto memory = [&]() -> std::optional<std::size_t> {
       const char* pstr = section->Attribute("memory");
@@ -1304,7 +1304,7 @@ void mjXReader::Statistic(XMLElement* section) {
   ReadAttr(section, "meanmass", 1, &spec->stat.meanmass, text);
   ReadAttr(section, "meansize", 1, &spec->stat.meansize, text);
   ReadAttr(section, "extent", 1, &spec->stat.extent, text);
-  if (mjuu_defined(spec->stat.extent) && spec->stat.extent<=0) {
+  if (mjuu_defined(spec->stat.extent) && spec->stat.extent <= 0) {
     throw mjXError(section, "extent must be strictly positive");
   }
   ReadAttr(section, "center", 3, spec->stat.center, text);
@@ -1330,7 +1330,7 @@ void mjXReader::OneFlex(XMLElement* elem, mjsFlex* flex) {
   ReadAttr(elem, "radius", 1, &flex->radius, text);
   ReadAttr(elem, "rgba", 4, flex->rgba, text);
   if (MapValue(elem, "flatskin", &n, bool_map, 2)) {
-    flex->flatskin = (n==1);
+    flex->flatskin = (n == 1);
   }
   ReadAttrInt(elem, "dim", &flex->dim);
   ReadAttrInt(elem, "group", &flex->group);
@@ -1373,7 +1373,7 @@ void mjXReader::OneFlex(XMLElement* elem, mjsFlex* flex) {
     ReadAttr(cont, "margin", 1, &flex->margin, text);
     ReadAttr(cont, "gap", 1, &flex->gap, text);
     if (MapValue(cont, "internal", &n, bool_map, 2)) {
-      flex->internal = (n==1);
+      flex->internal = (n == 1);
     }
     MapValue(cont, "selfcollide", &flex->selfcollide, flexself_map, 5);
     ReadAttrInt(cont, "activelayers", &flex->activelayers);
@@ -1430,7 +1430,7 @@ void mjXReader::OneMesh(XMLElement* elem, mjsMesh* mesh, const mjVFS* vfs) {
   }
 
   if (MapValue(elem, "smoothnormal", &n, bool_map, 2)) {
-    mesh->smoothnormal = (n==1);
+    mesh->smoothnormal = (n == 1);
   }
 
   if (ReadAttrInt(elem, "maxhullvert", &n)) {
@@ -1491,9 +1491,9 @@ void mjXReader::OneSkin(XMLElement* elem, mjsSkin* skin, const mjVFS* vfs) {
   }
   if (ReadAttrTxt(elem, "material", material)) {
     mjs_setString(skin->material, material.c_str());
-}
+  }
   ReadAttrInt(elem, "group", &skin->group);
-  if (skin->group<0 || skin->group>=mjNGROUP) {
+  if (skin->group < 0 || skin->group >= mjNGROUP) {
     throw mjXError(elem, "skin group must be between 0 and 5");
   }
   ReadAttr(elem, "rgba", 4, skin->rgba, text);
@@ -1597,7 +1597,7 @@ void mjXReader::OneMaterial(XMLElement* elem, mjsMaterial* material) {
   }
 
   if (MapValue(elem, "texuniform", &n, bool_map, 2)) {
-    material->texuniform = (n==1);
+    material->texuniform = (n == 1);
   }
   ReadAttr(elem, "texrepeat", 2, material->texrepeat, text);
   ReadAttr(elem, "emission", 1, &material->emission, text);
@@ -1647,7 +1647,7 @@ void mjXReader::OneJoint(XMLElement* elem, mjsJoint* joint) {
   ReadAttr(elem, "damping", 1, &joint->damping, text);
   ReadAttr(elem, "frictionloss", 1, &joint->frictionloss, text);
   if (MapValue(elem, "actuatorgravcomp", &n, bool_map, 2)) {
-    joint->actgravcomp = (n==1);
+    joint->actgravcomp = (n == 1);
   }
 
   // read userdata
@@ -1789,7 +1789,7 @@ void mjXReader::OneCamera(XMLElement* elem, mjsCamera* camera) {
   ReadAttr(elem, "ipd", 1, &camera->ipd, text);
 
   if (MapValue(elem, "orthographic", &n, bool_map, 2)) {
-    camera->orthographic = (n==1);
+    camera->orthographic = (n == 1);
   }
 
   bool has_principal = ReadAttr(elem, "principalpixel", 2, camera->principal_pixel, text) ||
@@ -1808,8 +1808,8 @@ void mjXReader::OneCamera(XMLElement* elem, mjsCamera* camera) {
 
   if (has_fovy && has_sensorsize) {
     throw mjXError(
-        elem,
-        "either 'fovy' or 'sensorsize' attribute can be specified, not both");
+            elem,
+            "either 'fovy' or 'sensorsize' attribute can be specified, not both");
   }
 
   // read userdata
@@ -1838,13 +1838,13 @@ void mjXReader::OneLight(XMLElement* elem, mjsLight* light) {
     light->mode = (mjtCamLight)n;
   }
   if (MapValue(elem, "directional", &n, bool_map, 2)) {
-    light->directional = (n==1);
+    light->directional = (n == 1);
   }
   if (MapValue(elem, "castshadow", &n, bool_map, 2)) {
-    light->castshadow = (n==1);
+    light->castshadow = (n == 1);
   }
   if (MapValue(elem, "active", &n, bool_map, 2)) {
-    light->active = (n==1);
+    light->active = (n == 1);
   }
   ReadAttr(elem, "pos", 3, light->pos, text);
   ReadAttr(elem, "dir", 3, light->dir, text);
@@ -1910,7 +1910,7 @@ void mjXReader::OneEquality(XMLElement* elem, mjsEquality* equality) {
     }
 
     switch (equality->type) {
-    case mjEQ_CONNECT: {
+      case mjEQ_CONNECT: {
         auto maybe_site1 = ReadAttrStr(elem, "site1");
         auto maybe_site2 = ReadAttrStr(elem, "site2");
         auto maybe_body1 = ReadAttrStr(elem, "body1");
@@ -1945,7 +1945,7 @@ void mjXReader::OneEquality(XMLElement* elem, mjsEquality* equality) {
       }
       break;
 
-    case mjEQ_WELD: {
+      case mjEQ_WELD: {
         auto maybe_site1 = ReadAttrStr(elem, "site1");
         auto maybe_site2 = ReadAttrStr(elem, "site2");
         auto maybe_body1 = ReadAttrStr(elem, "body1");
@@ -1968,9 +1968,9 @@ void mjXReader::OneEquality(XMLElement* elem, mjsEquality* equality) {
 
         if (site_semantic == body_semantic) {
           throw mjXError(
-              elem,
-              "either body1 must be defined and optionally {body2, anchor, relpose},"
-              " or site1 and site2 must be defined");
+                  elem,
+                  "either body1 must be defined and optionally {body2, anchor, relpose},"
+                  " or site1 and site2 must be defined");
         }
 
         if (body_semantic) {
@@ -1992,28 +1992,28 @@ void mjXReader::OneEquality(XMLElement* elem, mjsEquality* equality) {
       }
       break;
 
-    case mjEQ_JOINT:
-      ReadAttrTxt(elem, "joint1", name1, true);
-      ReadAttrTxt(elem, "joint2", name2);
-      ReadAttr(elem, "polycoef", 5, equality->data, text, false, false);
-      break;
+      case mjEQ_JOINT:
+        ReadAttrTxt(elem, "joint1", name1, true);
+        ReadAttrTxt(elem, "joint2", name2);
+        ReadAttr(elem, "polycoef", 5, equality->data, text, false, false);
+        break;
 
-    case mjEQ_TENDON:
-      ReadAttrTxt(elem, "tendon1", name1, true);
-      ReadAttrTxt(elem, "tendon2", name2);
-      ReadAttr(elem, "polycoef", 5, equality->data, text, false, false);
-      break;
+      case mjEQ_TENDON:
+        ReadAttrTxt(elem, "tendon1", name1, true);
+        ReadAttrTxt(elem, "tendon2", name2);
+        ReadAttr(elem, "polycoef", 5, equality->data, text, false, false);
+        break;
 
-    case mjEQ_FLEX:
-      ReadAttrTxt(elem, "flex", name1, true);
-      break;
+      case mjEQ_FLEX:
+        ReadAttrTxt(elem, "flex", name1, true);
+        break;
 
-    case mjEQ_DISTANCE:
-      throw mjXError(elem, "support for distance equality constraints was removed in MuJoCo 2.2.2");
-      break;
+      case mjEQ_DISTANCE:
+        throw mjXError(elem, "support for distance equality constraints was removed in MuJoCo 2.2.2");
+        break;
 
-    default:                    // SHOULD NOT OCCUR
-      throw mjXError(elem, "unrecognized equality constraint type");
+      default:                  // SHOULD NOT OCCUR
+        throw mjXError(elem, "unrecognized equality constraint type");
     }
 
     mjs_setString(equality->name1, name1.c_str());
@@ -2024,7 +2024,7 @@ void mjXReader::OneEquality(XMLElement* elem, mjsEquality* equality) {
 
   // read attributes
   if (MapValue(elem, "active", &n, bool_map, 2)) {
-    equality->active = (n==1);
+    equality->active = (n == 1);
   }
   ReadAttr(elem, "solref", mjNREF, equality->solref, text, false, false);
   ReadAttr(elem, "solimp", mjNIMP, equality->solimp, text, false, false);
@@ -2127,7 +2127,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
     cnt++;
   }
   // check for repeated transmission
-  if (cnt>1) {
+  if (cnt > 1) {
     throw mjXError(elem, "actuator can have at most one of transmission target");
   }
 
@@ -2137,7 +2137,9 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   if (r2) {
     mjs_setString(actuator->slidersite, slidersite.c_str());
   }
-  if ((r1 || r2) && actuator->trntype!=mjTRN_SLIDERCRANK && actuator->trntype!=mjTRN_UNDEFINED) {
+  if ((r1 || r2) &&
+      actuator->trntype != mjTRN_SLIDERCRANK &&
+      actuator->trntype != mjTRN_UNDEFINED) {
     throw mjXError(elem, "cranklength and slidersite can only be used in slidercrank transmission");
   }
 
@@ -2146,7 +2148,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   if (r3) {
     mjs_setString(actuator->refsite, refsite.c_str());
   }
-  if (r3 && actuator->trntype!=mjTRN_SITE && actuator->trntype!=mjTRN_UNDEFINED) {
+  if (r3 && actuator->trntype != mjTRN_SITE && actuator->trntype != mjTRN_UNDEFINED) {
     throw mjXError(elem, "refsite can only be used with site transmission");
   }
 
@@ -2154,7 +2156,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   type = elem->Value();
 
   // explicit attributes
-  if (type=="general") {
+  if (type == "general") {
     // explicit attributes
     int n;
     if (MapValue(elem, "dyntype", &n, dyn_map, dyn_sz)) {
@@ -2167,7 +2169,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
       actuator->biastype = (mjtBias)n;
     }
     if (MapValue(elem, "actearly", &n, bool_map, 2)) {
-      actuator->actearly = (n==1);
+      actuator->actearly = (n == 1);
     }
     ReadAttr(elem, "dynprm", mjNDYN, actuator->dynprm, text, false, false);
     ReadAttr(elem, "gainprm", mjNGAIN, actuator->gainprm, text, false, false);
@@ -2176,7 +2178,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   }
 
   // direct drive motor
-  else if (type=="motor") {
+  else if (type == "motor") {
     // unit gain
     actuator->gainprm[0] = 1;
 
@@ -2187,7 +2189,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   }
 
   // position or integrated velocity servo
-  else if (type=="position" || type=="intvelocity") {
+  else if (type == "position" || type == "intvelocity") {
     // explicit attributes
     ReadAttr(elem, "kp", 1, actuator->gainprm, text);
     actuator->biasprm[1] = -actuator->gainprm[0];
@@ -2236,14 +2238,14 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
     actuator->gaintype = mjGAIN_FIXED;
     actuator->biastype = mjBIAS_AFFINE;
 
-    if (type=="intvelocity") {
+    if (type == "intvelocity") {
       actuator->dyntype = mjDYN_INTEGRATOR;
       actuator->actlimited = 1;
     }
   }
 
   // velocity servo
-  else if (type=="velocity") {
+  else if (type == "velocity") {
     // clear bias
     mjuu_zerovec(actuator->biasprm, mjNBIAS);
 
@@ -2258,18 +2260,18 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   }
 
   // damper
-  else if (type=="damper") {
+  else if (type == "damper") {
     // clear gain
     mjuu_zerovec(actuator->gainprm, mjNGAIN);
 
     // explicit attributes
     ReadAttr(elem, "kv", 1, actuator->gainprm+2, text);
-    if (actuator->gainprm[2]<0)
+    if (actuator->gainprm[2] < 0)
       throw mjXError(elem, "damping coefficient cannot be negative");
     actuator->gainprm[2] = -actuator->gainprm[2];
 
     // require nonnegative range
-    if (actuator->ctrlrange[0]<0 || actuator->ctrlrange[1]<0) {
+    if (actuator->ctrlrange[0] < 0 || actuator->ctrlrange[1] < 0) {
       throw mjXError(elem, "damper control range cannot be negative");
     }
 
@@ -2281,7 +2283,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   }
 
   // cylinder
-  else if (type=="cylinder") {
+  else if (type == "cylinder") {
     // explicit attributes
     ReadAttr(elem, "timeconst", 1, actuator->dynprm, text);
     ReadAttr(elem, "bias", 3, actuator->biasprm, text);
@@ -2298,24 +2300,24 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   }
 
   // muscle
-  else if (type=="muscle") {
+  else if (type == "muscle") {
     // set muscle defaults if same as global defaults
-    if (actuator->dynprm[0]==1) actuator->dynprm[0] = 0.01;    // tau act
-    if (actuator->dynprm[1]==0) actuator->dynprm[1] = 0.04;    // tau deact
-    if (actuator->gainprm[0]==1) actuator->gainprm[0] = 0.75;  // range[0]
-    if (actuator->gainprm[1]==0) actuator->gainprm[1] = 1.05;  // range[1]
-    if (actuator->gainprm[2]==0) actuator->gainprm[2] = -1;    // force
-    if (actuator->gainprm[3]==0) actuator->gainprm[3] = 200;   // scale
-    if (actuator->gainprm[4]==0) actuator->gainprm[4] = 0.5;   // lmin
-    if (actuator->gainprm[5]==0) actuator->gainprm[5] = 1.6;   // lmax
-    if (actuator->gainprm[6]==0) actuator->gainprm[6] = 1.5;   // vmax
-    if (actuator->gainprm[7]==0) actuator->gainprm[7] = 1.3;   // fpmax
-    if (actuator->gainprm[8]==0) actuator->gainprm[8] = 1.2;   // fvmax
+    if (actuator->dynprm[0] == 1)actuator->dynprm[0] = 0.01;   // tau act
+    if (actuator->dynprm[1] == 0)actuator->dynprm[1] = 0.04;   // tau deact
+    if (actuator->gainprm[0] == 1)actuator->gainprm[0] = 0.75; // range[0]
+    if (actuator->gainprm[1] == 0)actuator->gainprm[1] = 1.05; // range[1]
+    if (actuator->gainprm[2] == 0)actuator->gainprm[2] = -1;   // force
+    if (actuator->gainprm[3] == 0)actuator->gainprm[3] = 200;  // scale
+    if (actuator->gainprm[4] == 0)actuator->gainprm[4] = 0.5;  // lmin
+    if (actuator->gainprm[5] == 0)actuator->gainprm[5] = 1.6;  // lmax
+    if (actuator->gainprm[6] == 0)actuator->gainprm[6] = 1.5;  // vmax
+    if (actuator->gainprm[7] == 0)actuator->gainprm[7] = 1.3;  // fpmax
+    if (actuator->gainprm[8] == 0)actuator->gainprm[8] = 1.2;  // fvmax
 
     // explicit attributes
     ReadAttr(elem, "timeconst", 2, actuator->dynprm, text);
     ReadAttr(elem, "tausmooth", 1, actuator->dynprm+2, text);
-    if (actuator->dynprm[2]<0)
+    if (actuator->dynprm[2] < 0)
       throw mjXError(elem, "muscle tausmooth cannot be negative");
     ReadAttr(elem, "range", 2, actuator->gainprm, text);
     ReadAttr(elem, "force", 1, actuator->gainprm+2, text);
@@ -2327,7 +2329,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
     ReadAttr(elem, "fvmax", 1, actuator->gainprm+8, text);
 
     // biasprm = gainprm
-    for (int n=0; n<9; n++) {
+    for (int n=0; n < 9; n++) {
       actuator->biasprm[n] = actuator->gainprm[n];
     }
 
@@ -2338,15 +2340,15 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
   }
 
   // adhesion
-  else if (type=="adhesion") {
+  else if (type == "adhesion") {
     // explicit attributes
     ReadAttr(elem, "gain", 1, actuator->gainprm, text);
-    if (actuator->gainprm[0]<0)
+    if (actuator->gainprm[0] < 0)
       throw mjXError(elem, "adhesion gain cannot be negative");
 
     // require nonnegative range
     ReadAttr(elem, "ctrlrange", 2, actuator->ctrlrange, text);
-    if (actuator->ctrlrange[0]<0 || actuator->ctrlrange[1]<0) {
+    if (actuator->ctrlrange[0] < 0 || actuator->ctrlrange[1] < 0) {
       throw mjXError(elem, "adhesion control range cannot be negative");
     }
 
@@ -2363,7 +2365,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) {
       actuator->dyntype = (mjtDyn)n;
     }
     if (MapValue(elem, "actearly", &n, bool_map, 2)) {
-      actuator->actearly = (n==1);
+      actuator->actearly = (n == 1);
     }
     ReadAttr(elem, "dynprm", mjNDYN, actuator->dynprm, text, false, false);
     ReadAttrInt(elem, "actdim", &actuator->actdim);
@@ -2425,7 +2427,7 @@ void mjXReader::OneComposite(XMLElement* elem, mjsBody* body, const mjsDefault*
       break;
     }
     iss >> text;
-    if (i>2) {
+    if (i > 2) {
       throw mjXError(elem, "The curve array must have a maximum of 3 components");
     }
     comp.curve[i++] = (mjtCompShape)FindKey(shape_map, mjNCOMPSHAPES, text);
@@ -2442,14 +2444,14 @@ void mjXReader::OneComposite(XMLElement* elem, mjsBody* body, const mjsDefault*
   if (eskin) {
     comp.skin = true;
     if (MapValue(eskin, "texcoord", &n, bool_map, 2)) {
-      comp.skintexcoord = (n==1);
+      comp.skintexcoord = (n == 1);
     }
     ReadAttrTxt(eskin, "material", comp.skinmaterial);
     ReadAttr(eskin, "rgba", 4, comp.skinrgba, text);
     ReadAttr(eskin, "inflate", 1, &comp.skininflate, text);
     ReadAttrInt(eskin, "subgrid", &comp.skinsubgrid);
     ReadAttrInt(eskin, "group", &comp.skingroup, 0);
-    if (comp.skingroup<0 || comp.skingroup>=mjNGROUP) {
+    if (comp.skingroup < 0 || comp.skingroup >= mjNGROUP) {
       throw mjXError(eskin, "skin group must be between 0 and 5");
     }
   }
@@ -2591,7 +2593,7 @@ void mjXReader::OneFlexcomp(XMLElement* elem, mjsBody* body, const mjVFS* vfs) {
   }
   ReadAttr(elem, "rgba", 4, dflex.rgba, text);
   if (MapValue(elem, "flatskin", &n, bool_map, 2)) {
-    dflex.flatskin = (n==1);
+    dflex.flatskin = (n == 1);
   }
   ReadAttrInt(elem, "dim", &dflex.dim);
   ReadAttr(elem, "radius", 1, &dflex.radius, text);
@@ -2608,7 +2610,7 @@ void mjXReader::OneFlexcomp(XMLElement* elem, mjsBody* body, const mjVFS* vfs) {
 
   // user or internal
   if (MapValue(elem, "rigid", &n, bool_map, 2)) {
-    fcomp.rigid = (n==1);
+    fcomp.rigid = (n == 1);
   }
   auto point = ReadAttrVec<double>(elem, "point");
   if (point.has_value()) {
@@ -2632,7 +2634,7 @@ void mjXReader::OneFlexcomp(XMLElement* elem, mjsBody* body, const mjVFS* vfs) {
   XMLElement* edge = FirstChildElement(elem, "edge");
   if (edge) {
     if (MapValue(edge, "equality", &n, bool_map, 2)) {
-      fcomp.equality = (n==1);
+      fcomp.equality = (n == 1);
     }
     ReadAttr(edge, "solref", mjNREF, fcomp.def.spec.equality->solref, text, false, false);
     ReadAttr(edge, "solimp", mjNIMP, fcomp.def.spec.equality->solimp, text, false, false);
@@ -2668,7 +2670,7 @@ void mjXReader::OneFlexcomp(XMLElement* elem, mjsBody* body, const mjVFS* vfs) {
     ReadAttr(cont, "margin", 1, &dflex.margin, text);
     ReadAttr(cont, "gap", 1, &dflex.gap, text);
     if (MapValue(cont, "internal", &n, bool_map, 2)) {
-      dflex.internal = (n==1);
+      dflex.internal = (n == 1);
     }
     MapValue(cont, "selfcollide", &dflex.selfcollide, flexself_map, 5);
     ReadAttrInt(cont, "activelayers", &dflex.activelayers);
@@ -2770,45 +2772,45 @@ void mjXReader::Default(XMLElement* section, const mjsDefault* def, const mjVFS*
     name = elem->Value();
 
     // read mesh
-    if (name=="mesh") OneMesh(elem, def->mesh, vfs);
+    if (name == "mesh")OneMesh(elem, def->mesh, vfs);
 
     // read material
-    else if (name=="material") OneMaterial(elem, def->material);
+    else if (name == "material")OneMaterial(elem, def->material);
 
     // read joint
-    else if (name=="joint") OneJoint(elem, def->joint);
+    else if (name == "joint")OneJoint(elem, def->joint);
 
     // read geom
-    else if (name=="geom") OneGeom(elem, def->geom);
+    else if (name == "geom")OneGeom(elem, def->geom);
 
     // read site
-    else if (name=="site") OneSite(elem, def->site);
+    else if (name == "site")OneSite(elem, def->site);
 
     // read camera
-    else if (name=="camera") OneCamera(elem, def->camera);
+    else if (name == "camera")OneCamera(elem, def->camera);
 
     // read light
-    else if (name=="light") OneLight(elem, def->light);
+    else if (name == "light")OneLight(elem, def->light);
 
     // read pair
-    else if (name=="pair") OnePair(elem, def->pair);
+    else if (name == "pair")OnePair(elem, def->pair);
 
     // read equality
-    else if (name=="equality") OneEquality(elem, def->equality);
+    else if (name == "equality")OneEquality(elem, def->equality);
 
     // read tendon
-    else if (name=="tendon") OneTendon(elem, def->tendon);
+    else if (name == "tendon")OneTendon(elem, def->tendon);
 
     // read actuator
-    else if (name=="general"     ||
-             name=="motor"       ||
-             name=="position"    ||
-             name=="velocity"    ||
-             name=="damper"      ||
-             name=="intvelocity" ||
-             name=="cylinder"    ||
-             name=="muscle"      ||
-             name=="adhesion") {
+    else if (name == "general"     ||
+             name == "motor"       ||
+             name == "position"    ||
+             name == "velocity"    ||
+             name == "damper"      ||
+             name == "intvelocity" ||
+             name == "cylinder"    ||
+             name == "muscle"      ||
+             name == "adhesion") {
       OneActuator(elem, def->actuator);
     }
 
@@ -2823,7 +2825,7 @@ void mjXReader::Default(XMLElement* section, const mjsDefault* def, const mjVFS*
     name = elem->Value();
 
     // read default
-    if (name=="default") {
+    if (name == "default") {
       Default(elem, def, vfs);
     }
 
@@ -2851,10 +2853,10 @@ void mjXReader::Extension(XMLElement* section) {
 
       XMLElement* child = FirstChildElement(elem);
       while (child) {
-        if (string(child->Value())=="instance") {
+        if (string(child->Value()) == "instance") {
           if (spec->hasImplicitPluginElem) {
             throw mjXError(
-                child, "explicit plugin instance must appear before implicit plugin elements");
+                    child, "explicit plugin instance must appear before implicit plugin elements");
           }
           string name;
           mjsPlugin* p = mjs_addPlugin(spec);
@@ -2892,7 +2894,7 @@ void mjXReader::Custom(XMLElement* section) {
     string elname;
 
     // numeric
-    if (name=="numeric") {
+    if (name == "numeric") {
       // create custom
       mjsNumeric* numeric = mjs_addNumeric(spec);
 
@@ -2904,17 +2906,17 @@ void mjXReader::Custom(XMLElement* section) {
       mjs_setString(numeric->name, elname.c_str());
       if (ReadAttrInt(elem, "size", &numeric->size)) {
         int sz = numeric->size < 500 ? numeric->size : 500;
-        for (int i=0; i<sz; i++) {
+        for (int i=0; i < sz; i++) {
           data[i] = 0;
         }
       } else {
         numeric->size = 501;
       }
       int len = ReadAttr(elem, "data", numeric->size, data, str, false, false);
-      if (numeric->size==501) {
+      if (numeric->size == 501) {
         numeric->size = len;
       }
-      if (numeric->size<1 || numeric->size>500) {
+      if (numeric->size < 1 || numeric->size > 500) {
         throw mjXError(elem, "custom field size must be between 1 and 500");
       }
 
@@ -2923,7 +2925,7 @@ void mjXReader::Custom(XMLElement* section) {
     }
 
     // text
-    else if (name=="text") {
+    else if (name == "text") {
       // create custom
       mjsText* text = mjs_addText(spec);
 
@@ -2943,7 +2945,7 @@ void mjXReader::Custom(XMLElement* section) {
     }
 
     // tuple
-    else if (name=="tuple") {
+    else if (name == "tuple") {
       // create custom
       mjsTuple* tuple = mjs_addTuple(spec);
 
@@ -2965,11 +2967,11 @@ void mjXReader::Custom(XMLElement* section) {
         name = obj->Value();
 
         // new object
-        if (name=="element") {
+        if (name == "element") {
           // read type, check and assign
           ReadAttrTxt(obj, "objtype", str, true);
           mjtObj otype = (mjtObj)mju_str2Type(str.c_str());
-          if (otype==mjOBJ_UNKNOWN) {
+          if (otype == mjOBJ_UNKNOWN) {
             throw mjXError(obj, "unknown object type");
           }
           objtype.push_back(otype);
@@ -3014,9 +3016,9 @@ void mjXReader::Visual(XMLElement* section) {
     name = elem->Value();
 
     // global sub-element
-    if (name=="global") {
+    if (name == "global") {
       if (MapValue(elem, "orthographic", &n, bool_map, 2)) {
-        vis->global.orthographic = (n==1);
+        vis->global.orthographic = (n == 1);
       }
       ReadAttr(elem,    "fovy",      1, &vis->global.fovy,      text);
       ReadAttr(elem,    "ipd",       1, &vis->global.ipd,       text);
@@ -3027,20 +3029,20 @@ void mjXReader::Visual(XMLElement* section) {
       ReadAttrInt(elem, "offwidth",     &vis->global.offwidth);
       ReadAttrInt(elem, "offheight",    &vis->global.offheight);
       if (ReadAttr(elem, "realtime", 1, &vis->global.realtime, text)) {
-        if (vis->global.realtime<=0) {
+        if (vis->global.realtime <= 0) {
           throw mjXError(elem, "realtime must be greater than 0");
         }
       }
       if (MapValue(elem, "ellipsoidinertia", &n, bool_map, 2)) {
-        vis->global.ellipsoidinertia = (n==1);
+        vis->global.ellipsoidinertia = (n == 1);
       }
       if (MapValue(elem, "bvactive", &n, bool_map, 2)) {
-        vis->global.bvactive = (n==1);
+        vis->global.bvactive = (n == 1);
       }
     }
 
     // quality sub-element
-    else if (name=="quality") {
+    else if (name == "quality") {
       ReadAttrInt(elem, "shadowsize", &vis->quality.shadowsize);
       ReadAttrInt(elem, "offsamples", &vis->quality.offsamples);
       ReadAttrInt(elem, "numslices",  &vis->quality.numslices);
@@ -3049,7 +3051,7 @@ void mjXReader::Visual(XMLElement* section) {
     }
 
     // headlight sub-element
-    else if (name=="headlight") {
+    else if (name == "headlight") {
       ReadAttr(elem, "ambient",  3, vis->headlight.ambient,  text);
       ReadAttr(elem, "diffuse",  3, vis->headlight.diffuse,  text);
       ReadAttr(elem, "specular", 3, vis->headlight.specular, text);
@@ -3057,7 +3059,7 @@ void mjXReader::Visual(XMLElement* section) {
     }
 
     // map sub-element
-    else if (name=="map") {
+    else if (name == "map") {
       ReadAttr(elem, "stiffness",      1, &vis->map.stiffness, text);
       ReadAttr(elem, "stiffnessrot",   1, &vis->map.stiffnessrot, text);
       ReadAttr(elem, "force",          1, &vis->map.force,     text);
@@ -3066,7 +3068,7 @@ void mjXReader::Visual(XMLElement* section) {
       ReadAttr(elem, "fogstart",       1, &vis->map.fogstart,  text);
       ReadAttr(elem, "fogend",         1, &vis->map.fogend,    text);
       ReadAttr(elem, "znear",          1, &vis->map.znear,     text);
-      if (vis->map.znear<=0) {
+      if (vis->map.znear <= 0) {
         throw mjXError(elem, "znear must be strictly positive");
       }
       ReadAttr(elem, "zfar",           1, &vis->map.zfar,      text);
@@ -3077,7 +3079,7 @@ void mjXReader::Visual(XMLElement* section) {
     }
 
     // scale sub-element
-    else if (name=="scale") {
+    else if (name == "scale") {
       ReadAttr(elem, "forcewidth",     1, &vis->scale.forcewidth,     text);
       ReadAttr(elem, "contactwidth",   1, &vis->scale.contactwidth,   text);
       ReadAttr(elem, "contactheight",  1, &vis->scale.contactheight,  text);
@@ -3098,7 +3100,7 @@ void mjXReader::Visual(XMLElement* section) {
     }
 
     // rgba sub-element
-    else if (name=="rgba") {
+    else if (name == "rgba") {
       ReadAttr(elem, "fog",              4, vis->rgba.fog,             text);
       ReadAttr(elem, "haze",             4, vis->rgba.haze,            text);
       ReadAttr(elem, "force",            4, vis->rgba.force,           text);
@@ -3152,7 +3154,7 @@ void mjXReader::Asset(XMLElement* section, const mjVFS* vfs) {
     }
 
     // texture sub-element
-    if (name=="texture") {
+    if (name == "texture") {
       // create texture
       mjsTexture* texture = mjs_addTexture(spec);
 
@@ -3187,20 +3189,20 @@ void mjXReader::Asset(XMLElement* section, const mjVFS* vfs) {
         texture->mark = (mjtMark)n;
       }
       if (MapValue(elem, "hflip", &n, bool_map, 2)) {
-        texture->hflip = (n!=0);
+        texture->hflip = (n != 0);
       }
       if (MapValue(elem, "vflip", &n, bool_map, 2)) {
-        texture->vflip = (n!=0);
+        texture->vflip = (n != 0);
       }
 
       // grid
       ReadAttr(elem, "gridsize", 2, texture->gridsize, text);
       if (ReadAttrTxt(elem, "gridlayout", text)) {
         // check length
-        if (text.length()>12) {
+        if (text.length() > 12) {
           throw mjXError(elem, "gridlayout length cannot exceed 12 characters");
         }
-        if (text.length()!=texture->gridsize[0]*texture->gridsize[1]) {
+        if (text.length() != texture->gridsize[0]*texture->gridsize[1]) {
           throw mjXError(elem, "gridlayout length must match gridsize");
         }
 
@@ -3210,8 +3212,8 @@ void mjXReader::Asset(XMLElement* section, const mjVFS* vfs) {
       // separate files
       std::vector<string> cubefiles(6);
       std::vector<string> cubefile_names = {"fileright", "fileleft",
-                                                 "fileup", "filedown",
-                                                 "filefront", "fileback"};
+                                            "fileup", "filedown",
+                                            "filefront", "fileback"};
       for (int i = 0; i < cubefiles.size(); i++) {
         auto maybe_file = ReadAttrFile(elem, cubefile_names[i].c_str(), vfs,
                                        TextureDir());
@@ -3225,28 +3227,28 @@ void mjXReader::Asset(XMLElement* section, const mjVFS* vfs) {
     }
 
     // material sub-element
-    else if (name=="material") {
+    else if (name == "material") {
       // create material and parse
       mjsMaterial* material = mjs_addMaterial(spec, def);
       OneMaterial(elem, material);
     }
 
     // mesh sub-element
-    else if (name=="mesh") {
+    else if (name == "mesh") {
       // create mesh and parse
       mjsMesh* mesh = mjs_addMesh(spec, def);
       OneMesh(elem, mesh, vfs);
     }
 
     // skin sub-element... deprecate ???
-    else if (name=="skin") {
+    else if (name == "skin") {
       // create skin and parse
       mjsSkin* skin = mjs_addSkin(spec);
       OneSkin(elem, skin, vfs);
     }
 
     // hfield sub-element
-    else if (name=="hfield") {
+    else if (name == "hfield") {
       // create hfield
       mjsHField* hfield = mjs_addHField(spec);
 
@@ -3270,7 +3272,7 @@ void mjXReader::Asset(XMLElement* section, const mjVFS* vfs) {
       ReadAttr(elem, "size", 4, hfield->size, text, true);
 
       // allocate buffer for dynamic hfield, copy user data if given
-      if (!file.has_value() && hfield->nrow>0 && hfield->ncol>0) {
+      if (!file.has_value() && hfield->nrow > 0 && hfield->ncol > 0) {
         int nrow = hfield->nrow;
         int ncol = hfield->ncol;
 
@@ -3304,7 +3306,7 @@ void mjXReader::Asset(XMLElement* section, const mjVFS* vfs) {
     }
 
     // model sub-element
-    else if (name=="model") {
+    else if (name == "model") {
       string content_type;
       if (!ReadAttrTxt(elem, "content_type", content_type)) {
         content_type = "text/xml";
@@ -3355,7 +3357,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
   }
 
   // no attributes allowed in world body
-  if (mjs_getId(body->element)==0 && section->FirstAttribute() && !frame) {
+  if (mjs_getId(body->element) == 0 && section->FirstAttribute() && !frame) {
     throw mjXError(section, "World body cannot have attributes");
   }
 
@@ -3372,9 +3374,9 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // inertial sub-element
-    if (name=="inertial") {
+    if (name == "inertial") {
       // no inertia allowed in world body
-      if (mjs_getId(body->element)==0) {
+      if (mjs_getId(body->element) == 0) {
         throw mjXError(elem, "World body cannot have inertia");
       }
       body->explicitinertial = true;
@@ -3390,9 +3392,9 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // joint sub-element
-    else if (name=="joint") {
+    else if (name == "joint") {
       // no joints allowed in world body
-      if (mjs_getId(body->element)==0) {
+      if (mjs_getId(body->element) == 0) {
         throw mjXError(elem, "World body cannot have joints");
       }
 
@@ -3403,9 +3405,9 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // freejoint sub-element
-    else if (name=="freejoint") {
+    else if (name == "freejoint") {
       // no joints allowed in world body
-      if (mjs_getId(body->element)==0) {
+      if (mjs_getId(body->element) == 0) {
         throw mjXError(elem, "World body cannot have joints");
       }
 
@@ -3426,7 +3428,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // geom sub-element
-    else if (name=="geom") {
+    else if (name == "geom") {
       // create geom and parse
       mjsGeom* geom = mjs_addGeom(body, def);
       OneGeom(elem, geom);
@@ -3434,7 +3436,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // site sub-element
-    else if (name=="site") {
+    else if (name == "site") {
       // create site and parse
       mjsSite* site = mjs_addSite(body,  def);
       OneSite(elem, site);
@@ -3442,7 +3444,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // camera sub-element
-    else if (name=="camera") {
+    else if (name == "camera") {
       // create camera and parse
       mjsCamera* camera = mjs_addCamera(body, def);
       OneCamera(elem, camera);
@@ -3450,7 +3452,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // light sub-element
-    else if (name=="light") {
+    else if (name == "light") {
       // create light and parse
       mjsLight* light = mjs_addLight(body, def);
       OneLight(elem, light);
@@ -3463,19 +3465,19 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // composite sub-element
-    else if (name=="composite") {
+    else if (name == "composite") {
       // parse composite
       OneComposite(elem, body, def);
     }
 
     // flexcomp sub-element
-    else if (name=="flexcomp") {
+    else if (name == "flexcomp") {
       // parse flexcomp
       OneFlexcomp(elem, body, vfs);
     }
 
     // frame sub-element
-    else if (name=="frame") {
+    else if (name == "frame") {
       // read childdef
       bool has_childclass = ReadAttrTxt(elem, "childclass", text);
       const mjsDefault* childdef = has_childclass ? mjs_findDefault(spec, text.c_str()) : nullptr;
@@ -3504,7 +3506,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // replicate sub-element
-    else if (name=="replicate") {
+    else if (name == "replicate") {
       int count;
       double offset[3] = {0, 0, 0};
       double euler[3] = {0, 0, 0};
@@ -3574,7 +3576,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // body sub-element
-    else if (name=="body") {
+    else if (name == "body") {
       // read childdef
       bool has_childclass = ReadAttrTxt(elem, "childclass", text);
       const mjsDefault* childdef = has_childclass ? mjs_findDefault(spec, text.c_str()) : nullptr;
@@ -3600,7 +3602,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
       ReadAttr(elem, "pos", 3, child->pos, text);
       ReadQuat(elem, "quat", child->quat, text);
       if (MapValue(elem, "mocap", &n, bool_map, 2)) {
-        child->mocap = (n==1);
+        child->mocap = (n == 1);
       }
       ReadAlternative(elem, child->alt);
 
@@ -3620,7 +3622,7 @@ void mjXReader::Body(XMLElement* section, mjsBody* body, mjsFrame* frame,
     }
 
     // attachment
-    else if (name=="attach") {
+    else if (name == "attach") {
       string model_name, body_name, prefix;
       ReadAttrTxt(elem, "model", model_name, /*required=*/true);
       ReadAttrTxt(elem, "body", body_name, /*required=*/true);
@@ -3677,14 +3679,14 @@ void mjXReader::Contact(XMLElement* section) {
     }
 
     // geom pair to include
-    if (name=="pair") {
+    if (name == "pair") {
       // create pair and parse
       mjsPair* pair = mjs_addPair(spec, def);
       OnePair(elem, pair);
     }
 
     // body pair to exclude
-    else if (name=="exclude") {
+    else if (name == "exclude") {
       mjsExclude* exclude = mjs_addExclude(spec);
       string exname, exbody1, exbody2;
 
@@ -3750,14 +3752,14 @@ void mjXReader::Deformable(XMLElement* section, const mjVFS* vfs) {
     }
 
     // flex sub-element
-    if (name=="flex") {
+    if (name == "flex") {
       // create flex and parse
       mjsFlex* flex = mjs_addFlex(spec);
       OneFlex(elem, flex);
     }
 
     // skin sub-element
-    else if (name=="skin") {
+    else if (name == "skin") {
       // create skin and parse
       mjsSkin* skin = mjs_addSkin(spec);
       OneSkin(elem, skin, vfs);
@@ -3797,12 +3799,12 @@ void mjXReader::Tendon(XMLElement* section) {
       mjsWrap* wrap;;
 
       // read attributes depending on type
-      if (type=="site") {
+      if (type == "site") {
         ReadAttrTxt(sub, "site", text, true);
         wrap = mjs_wrapSite(tendon, text.c_str());
       }
 
-      else if (type=="geom") {
+      else if (type == "geom") {
         ReadAttrTxt(sub, "geom", text, true);
         if (!ReadAttrTxt(sub, "sidesite", text1)) {
           text1.clear();
@@ -3810,12 +3812,12 @@ void mjXReader::Tendon(XMLElement* section) {
         wrap = mjs_wrapGeom(tendon, text.c_str(), text1.c_str());
       }
 
-      else if (type=="pulley") {
+      else if (type == "pulley") {
         ReadAttr(sub, "divisor", 1, &data, text, true);
         wrap = mjs_wrapPulley(tendon, data);
       }
 
-      else if (type=="joint") {
+      else if (type == "joint") {
         ReadAttrTxt(sub, "joint", text, true);
         ReadAttr(sub, "coef", 1, &data, text1, true);
         wrap = mjs_wrapJoint(tendon, text.c_str(), data);
@@ -3884,121 +3886,121 @@ void mjXReader::Sensor(XMLElement* section) {
     }
 
     // common robotic sensors, attached to a site
-    if (type=="touch") {
+    if (type == "touch") {
       sensor->type = mjSENS_TOUCH;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
-    } else if (type=="accelerometer") {
+    } else if (type == "accelerometer") {
       sensor->type = mjSENS_ACCELEROMETER;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
-    } else if (type=="velocimeter") {
+    } else if (type == "velocimeter") {
       sensor->type = mjSENS_VELOCIMETER;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
-    } else if (type=="gyro") {
+    } else if (type == "gyro") {
       sensor->type = mjSENS_GYRO;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
-    } else if (type=="force") {
+    } else if (type == "force") {
       sensor->type = mjSENS_FORCE;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
-    } else if (type=="torque") {
+    } else if (type == "torque") {
       sensor->type = mjSENS_TORQUE;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
-    } else if (type=="magnetometer") {
+    } else if (type == "magnetometer") {
       sensor->type = mjSENS_MAGNETOMETER;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
-    } else if (type=="camprojection") {
+    } else if (type == "camprojection") {
       sensor->type = mjSENS_CAMPROJECTION;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
       ReadAttrTxt(elem, "camera", refname, true);
       sensor->reftype = mjOBJ_CAMERA;
-    } else if (type=="rangefinder") {
+    } else if (type == "rangefinder") {
       sensor->type = mjSENS_RANGEFINDER;
       sensor->objtype = mjOBJ_SITE;
       ReadAttrTxt(elem, "site", objname, true);
     }
 
     // sensors related to scalar joints, tendons, actuators
-    else if (type=="jointpos") {
+    else if (type == "jointpos") {
       sensor->type = mjSENS_JOINTPOS;
       sensor->objtype = mjOBJ_JOINT;
       ReadAttrTxt(elem, "joint", objname, true);
-    } else if (type=="jointvel") {
+    } else if (type == "jointvel") {
       sensor->type = mjSENS_JOINTVEL;
       sensor->objtype = mjOBJ_JOINT;
       ReadAttrTxt(elem, "joint", objname, true);
-    } else if (type=="tendonpos") {
+    } else if (type == "tendonpos") {
       sensor->type = mjSENS_TENDONPOS;
       sensor->objtype = mjOBJ_TENDON;
       ReadAttrTxt(elem, "tendon", objname, true);
-    } else if (type=="tendonvel") {
+    } else if (type == "tendonvel") {
       sensor->type = mjSENS_TENDONVEL;
       sensor->objtype = mjOBJ_TENDON;
       ReadAttrTxt(elem, "tendon", objname, true);
-    } else if (type=="actuatorpos") {
+    } else if (type == "actuatorpos") {
       sensor->type = mjSENS_ACTUATORPOS;
       sensor->objtype = mjOBJ_ACTUATOR;
       ReadAttrTxt(elem, "actuator", objname, true);
-    } else if (type=="actuatorvel") {
+    } else if (type == "actuatorvel") {
       sensor->type = mjSENS_ACTUATORVEL;
       sensor->objtype = mjOBJ_ACTUATOR;
       ReadAttrTxt(elem, "actuator", objname, true);
-    } else if (type=="actuatorfrc") {
+    } else if (type == "actuatorfrc") {
       sensor->type = mjSENS_ACTUATORFRC;
       sensor->objtype = mjOBJ_ACTUATOR;
       ReadAttrTxt(elem, "actuator", objname, true);
-    } else if (type=="jointactuatorfrc") {
+    } else if (type == "jointactuatorfrc") {
       sensor->type = mjSENS_JOINTACTFRC;
       sensor->objtype = mjOBJ_JOINT;
       ReadAttrTxt(elem, "joint", objname, true);
     }
 
     // sensors related to ball joints
-    else if (type=="ballquat") {
+    else if (type == "ballquat") {
       sensor->type = mjSENS_BALLQUAT;
       sensor->objtype = mjOBJ_JOINT;
       ReadAttrTxt(elem, "joint", objname, true);
-    } else if (type=="ballangvel") {
+    } else if (type == "ballangvel") {
       sensor->type = mjSENS_BALLANGVEL;
       sensor->objtype = mjOBJ_JOINT;
       ReadAttrTxt(elem, "joint", objname, true);
     }
 
     // joint and tendon limit sensors
-    else if (type=="jointlimitpos") {
+    else if (type == "jointlimitpos") {
       sensor->type = mjSENS_JOINTLIMITPOS;
       sensor->objtype = mjOBJ_JOINT;
       ReadAttrTxt(elem, "joint", objname, true);
-    } else if (type=="jointlimitvel") {
+    } else if (type == "jointlimitvel") {
       sensor->type = mjSENS_JOINTLIMITVEL;
       sensor->objtype = mjOBJ_JOINT;
       ReadAttrTxt(elem, "joint", objname, true);
-    } else if (type=="jointlimitfrc") {
+    } else if (type == "jointlimitfrc") {
       sensor->type = mjSENS_JOINTLIMITFRC;
       sensor->objtype = mjOBJ_JOINT;
       ReadAttrTxt(elem, "joint", objname, true);
-    } else if (type=="tendonlimitpos") {
+    } else if (type == "tendonlimitpos") {
       sensor->type = mjSENS_TENDONLIMITPOS;
       sensor->objtype = mjOBJ_TENDON;
       ReadAttrTxt(elem, "tendon", objname, true);
-    } else if (type=="tendonlimitvel") {
+    } else if (type == "tendonlimitvel") {
       sensor->type = mjSENS_TENDONLIMITVEL;
       sensor->objtype = mjOBJ_TENDON;
       ReadAttrTxt(elem, "tendon", objname, true);
-    } else if (type=="tendonlimitfrc") {
+    } else if (type == "tendonlimitfrc") {
       sensor->type = mjSENS_TENDONLIMITFRC;
       sensor->objtype = mjOBJ_TENDON;
       ReadAttrTxt(elem, "tendon", objname, true);
     }
 
     // sensors attached to an object with spatial frame: (x)body, geom, site, camera
-    else if (type=="framepos") {
+    else if (type == "framepos") {
       sensor->type = mjSENS_FRAMEPOS;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
@@ -4009,7 +4011,7 @@ void mjXReader::Sensor(XMLElement* section) {
       } else if (ReadAttrTxt(elem, "refname", text)) {
         throw mjXError(elem, "refname '%s' given but reftype is missing", text.c_str());
       }
-    } else if (type=="framequat") {
+    } else if (type == "framequat") {
       sensor->type = mjSENS_FRAMEQUAT;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
@@ -4020,7 +4022,7 @@ void mjXReader::Sensor(XMLElement* section) {
       } else if (ReadAttrTxt(elem, "refname", text)) {
         throw mjXError(elem, "refname '%s' given but reftype is missing", text.c_str());
       }
-    } else if (type=="framexaxis") {
+    } else if (type == "framexaxis") {
       sensor->type = mjSENS_FRAMEXAXIS;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
@@ -4031,7 +4033,7 @@ void mjXReader::Sensor(XMLElement* section) {
       } else if (ReadAttrTxt(elem, "refname", text)) {
         throw mjXError(elem, "refname '%s' given but reftype is missing", text.c_str());
       }
-    } else if (type=="frameyaxis") {
+    } else if (type == "frameyaxis") {
       sensor->type = mjSENS_FRAMEYAXIS;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
@@ -4042,7 +4044,7 @@ void mjXReader::Sensor(XMLElement* section) {
       } else if (ReadAttrTxt(elem, "refname", text)) {
         throw mjXError(elem, "refname '%s' given but reftype is missing", text.c_str());
       }
-    } else if (type=="framezaxis") {
+    } else if (type == "framezaxis") {
       sensor->type = mjSENS_FRAMEZAXIS;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
@@ -4053,7 +4055,7 @@ void mjXReader::Sensor(XMLElement* section) {
       } else if (ReadAttrTxt(elem, "refname", text)) {
         throw mjXError(elem, "refname '%s' given but reftype is missing", text.c_str());
       }
-    } else if (type=="framelinvel") {
+    } else if (type == "framelinvel") {
       sensor->type = mjSENS_FRAMELINVEL;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
@@ -4064,7 +4066,7 @@ void mjXReader::Sensor(XMLElement* section) {
       } else if (ReadAttrTxt(elem, "refname", text)) {
         throw mjXError(elem, "refname '%s' given but reftype is missing", text.c_str());
       }
-    } else if (type=="frameangvel") {
+    } else if (type == "frameangvel") {
       sensor->type = mjSENS_FRAMEANGVEL;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
@@ -4075,12 +4077,12 @@ void mjXReader::Sensor(XMLElement* section) {
       } else if (ReadAttrTxt(elem, "refname", text)) {
         throw mjXError(elem, "refname '%s' given but reftype is missing", text.c_str());
       }
-    } else if (type=="framelinacc") {
+    } else if (type == "framelinacc") {
       sensor->type = mjSENS_FRAMELINACC;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
       ReadAttrTxt(elem, "objname", objname, true);
-    } else if (type=="frameangacc") {
+    } else if (type == "frameangacc") {
       sensor->type = mjSENS_FRAMEANGACC;
       ReadAttrTxt(elem, "objtype", text, true);
       sensor->objtype = (mjtObj)mju_str2Type(text.c_str());
@@ -4088,22 +4090,22 @@ void mjXReader::Sensor(XMLElement* section) {
     }
 
     // sensors related to kinematic subtrees; attached to a body (which is the subtree root)
-    else if (type=="subtreecom") {
+    else if (type == "subtreecom") {
       sensor->type = mjSENS_SUBTREECOM;
       sensor->objtype = mjOBJ_BODY;
       ReadAttrTxt(elem, "body", objname, true);
-    } else if (type=="subtreelinvel") {
+    } else if (type == "subtreelinvel") {
       sensor->type = mjSENS_SUBTREELINVEL;
       sensor->objtype = mjOBJ_BODY;
       ReadAttrTxt(elem, "body", objname, true);
-    } else if (type=="subtreeangmom") {
+    } else if (type == "subtreeangmom") {
       sensor->type = mjSENS_SUBTREEANGMOM;
       sensor->objtype = mjOBJ_BODY;
       ReadAttrTxt(elem, "body", objname, true);
     }
 
     // sensors for geometric distance; attached to geoms or bodies
-    else if (type=="distance" || type=="normal" || type=="fromto") {
+    else if (type == "distance" || type == "normal" || type == "fromto") {
       bool has_body1 = ReadAttrTxt(elem, "body1", objname);
       bool has_geom1 = ReadAttrTxt(elem, "geom1", objname);
       if (has_body1 == has_geom1) {
@@ -4116,9 +4118,9 @@ void mjXReader::Sensor(XMLElement* section) {
         throw mjXError(elem, "exactly one of (geom2, body2) must be specified");
       }
       sensor->reftype = has_body2 ? mjOBJ_BODY : mjOBJ_GEOM;
-      if (type=="distance") {
+      if (type == "distance") {
         sensor->type = mjSENS_GEOMDIST;
-      } else if (type=="normal") {
+      } else if (type == "normal") {
         sensor->type = mjSENS_GEOMNORMAL;
       } else {
         sensor->type = mjSENS_GEOMFROMTO;
@@ -4126,19 +4128,19 @@ void mjXReader::Sensor(XMLElement* section) {
     }
 
     // global sensors
-    else if (type=="e_potential") {
+    else if (type == "e_potential") {
       sensor->type = mjSENS_E_POTENTIAL;
       sensor->objtype = mjOBJ_UNKNOWN;
-    } else if (type=="e_kinetic") {
+    } else if (type == "e_kinetic") {
       sensor->type = mjSENS_E_KINETIC;
       sensor->objtype = mjOBJ_UNKNOWN;
-    } else if (type=="clock") {
+    } else if (type == "clock") {
       sensor->type = mjSENS_CLOCK;
       sensor->objtype = mjOBJ_UNKNOWN;
     }
 
     // user-defined sensor
-    else if (type=="user") {
+    else if (type == "user") {
       sensor->type = mjSENS_USER;
       bool objname_given = ReadAttrTxt(elem, "objname", objname);
       if (ReadAttrTxt(elem, "objtype", text)) {
@@ -4156,11 +4158,11 @@ void mjXReader::Sensor(XMLElement* section) {
         sensor->needstage = (mjtStage)n;
       }
       if (MapValue(elem, "datatype", &n, datatype_map, datatype_sz)) {
-       sensor->datatype = (mjtDataType)n;
+        sensor->datatype = (mjtDataType)n;
       }
     }
 
-    else if (type=="plugin") {
+    else if (type == "plugin") {
       sensor->type = mjSENS_PLUGIN;
       OnePlugin(elem, &sensor->plugin);
       ReadAttrTxt(elem, "objtype", text);
@@ -4273,8 +4275,8 @@ const mjsDefault* mjXReader::GetClass(XMLElement* section) {
   const mjsDefault* def = mjs_findDefault(spec, text.c_str());
   if (!def) {
     throw mjXError(
-        section,
-        string("unknown default class name '" + text + "'").c_str());
+            section,
+            string("unknown default class name '" + text + "'").c_str());
   }
   return def;
 }
diff --git a/src/xml/xml_native_writer.cc b/src/xml/xml_native_writer.cc
index 4643a925..77a7dc6a 100644
--- a/src/xml/xml_native_writer.cc
+++ b/src/xml/xml_native_writer.cc
@@ -56,8 +56,8 @@ class mj_XMLPrinter : public tinyxml2::XMLPrinter {
 
  public:
     void PrintSpace( int depth ) {
-      for (int i=0; i<depth; ++i) {
-          Write( "  " );
+      for (int i=0; i < depth; ++i) {
+        Write( "  " );
       }
     }
 };
@@ -76,10 +76,10 @@ static string WriteDoc(XMLDocument& doc, char *error, size_t error_sz) {
 
   // top level sections
   std::array<string, 17> sections = {
-      "<actuator", "<asset",      "<compiler", "<contact",   "<custom",
-      "<default>", "<deformable", "<equality", "<extension", "<keyframe",
-      "<option",   "<sensor",     "<size",     "<statistic", "<tendon",
-      "<visual",   "<worldbody"};
+    "<actuator", "<asset",      "<compiler", "<contact",   "<custom",
+    "<default>", "<deformable", "<equality", "<extension", "<keyframe",
+    "<option",   "<sensor",     "<size",     "<statistic", "<tendon",
+    "<visual",   "<worldbody"};
 
   // position of newline before first section
   size_t first_pos = string::npos;
@@ -290,7 +290,7 @@ void mjXWriter::OneSkin(XMLElement* elem, const mjCSkin* skin) {
     WriteAttrTxt(elem, "face", text);
 
     // bones
-    for (size_t i=0; i<skin->get_bodyname().size(); i++) {
+    for (size_t i=0; i < skin->get_bodyname().size(); i++) {
       // make bone
       XMLElement* bone = InsertEnd(elem, "bone");
 
@@ -325,7 +325,7 @@ void mjXWriter::OneMaterial(XMLElement* elem, const mjCMaterial* material, mjCDe
   // defaults and regular
   // check if we have non-rgb textures
   bool has_non_rgb = false;
-  for (int i=1; i<mjNTEXROLE; i++) {
+  for (int i=1; i < mjNTEXROLE; i++) {
     if (!material->textures_[i].empty()) {
       if (i != mjTEXROLE_RGB) {
         has_non_rgb = true;
@@ -335,7 +335,7 @@ void mjXWriter::OneMaterial(XMLElement* elem, const mjCMaterial* material, mjCDe
 
   // if we have non-rgb textures, write them as layers
   if (has_non_rgb) {
-    for (int i=1; i<mjNTEXROLE; i++) {
+    for (int i=1; i < mjNTEXROLE; i++) {
       if (!material->textures_[i].empty()) {
         XMLElement * child_elem = InsertEnd(elem, "layer");
         WriteAttrTxt(child_elem, "texture", material->textures_[i]);
@@ -432,7 +432,7 @@ void mjXWriter::OneGeom(XMLElement* elem, const mjCGeom* geom, mjCDef* def, stri
     }
 
     // mesh geom
-    if (geom->type==mjGEOM_MESH || geom->type==mjGEOM_SDF) {
+    if (geom->type == mjGEOM_MESH || geom->type == mjGEOM_SDF) {
       mjCMesh* mesh = geom->mesh;
 
       // write pos/quat if there is a difference
@@ -474,7 +474,8 @@ void mjXWriter::OneGeom(XMLElement* elem, const mjCGeom* geom, mjCDef* def, stri
   WriteAttr(elem, "margin", 1, &geom->margin, &def->Geom().margin);
   WriteAttr(elem, "gap", 1, &geom->gap, &def->Geom().gap);
   WriteAttr(elem, "gap", 1, &geom->gap, &def->Geom().gap);
-  WriteAttrKey(elem, "fluidshape", fluid_map, 2, geom->fluid_ellipsoid, def->Geom().fluid_ellipsoid);
+  WriteAttrKey(elem, "fluidshape",
+               fluid_map, 2, geom->fluid_ellipsoid, def->Geom().fluid_ellipsoid);
   WriteAttr(elem, "fluidcoef", 5, geom->fluid_coefs, def->Geom().fluid_coefs);
   if (geom->type != mjGEOM_MESH) {
     WriteAttrKey(elem, "shellinertia", meshtype_map, 2, geom->typeinertia,
@@ -491,10 +492,10 @@ void mjXWriter::OneGeom(XMLElement* elem, const mjCGeom* geom, mjCDef* def, stri
   WriteAttr(elem, "rgba", 4, geom->rgba, def->Geom().rgba);
 
   // hfield and mesh attributes
-  if (geom->type==mjGEOM_HFIELD) {
+  if (geom->type == mjGEOM_HFIELD) {
     WriteAttrTxt(elem, "hfield", geom->get_hfieldname());
   }
-  if (geom->type==mjGEOM_MESH || geom->type==mjGEOM_SDF) {
+  if (geom->type == mjGEOM_MESH || geom->type == mjGEOM_SDF) {
     WriteAttrTxt(elem, "mesh", geom->get_meshname());
   }
 
@@ -569,7 +570,7 @@ void mjXWriter::OneCamera(XMLElement* elem, const mjCCamera* camera, mjCDef* def
   WriteAttrKey(elem, "orthographic", bool_map, 2, camera->orthographic, def->Camera().orthographic);
 
   // camera intrinsics if specified
-  if (camera->sensor_size[0]>0 && camera->sensor_size[1]>0) {
+  if (camera->sensor_size[0] > 0 && camera->sensor_size[1] > 0) {
     WriteAttr(elem, "sensorsize", 2, camera->sensor_size);
     WriteAttr(elem, "focal", 2, camera->focal_length, def->Camera().focal_length);
     WriteAttr(elem, "focalpixel", 2, camera->focal_pixel, def->Camera().focal_pixel);
@@ -650,48 +651,48 @@ void mjXWriter::OneEquality(XMLElement* elem, const mjCEquality* equality, mjCDe
     }
 
     switch (equality->type) {
-    case mjEQ_CONNECT:
-      if (equality->objtype == mjOBJ_BODY) {
-        WriteAttrTxt(elem, "body1", mjs_getString(equality->name1));
-        WriteAttrTxt(elem, "body2", mjs_getString(equality->name2));
-        WriteAttr(elem, "anchor", 3, equality->data);
-      } else {
-        WriteAttrTxt(elem, "site1", mjs_getString(equality->name1));
-        WriteAttrTxt(elem, "site2", mjs_getString(equality->name2));
-      }
-      break;
+      case mjEQ_CONNECT:
+        if (equality->objtype == mjOBJ_BODY) {
+          WriteAttrTxt(elem, "body1", mjs_getString(equality->name1));
+          WriteAttrTxt(elem, "body2", mjs_getString(equality->name2));
+          WriteAttr(elem, "anchor", 3, equality->data);
+        } else {
+          WriteAttrTxt(elem, "site1", mjs_getString(equality->name1));
+          WriteAttrTxt(elem, "site2", mjs_getString(equality->name2));
+        }
+        break;
 
-    case mjEQ_WELD:
-      if (equality->objtype == mjOBJ_BODY) {
-        WriteAttrTxt(elem, "body1", mjs_getString(equality->name1));
-        WriteAttrTxt(elem, "body2", mjs_getString(equality->name2));
-        WriteAttr(elem, "anchor", 3, equality->data);
-        WriteAttr(elem, "relpose", 7, equality->data+3);
-      } else {
-        WriteAttrTxt(elem, "site1", mjs_getString(equality->name1));
-        WriteAttrTxt(elem, "site2", mjs_getString(equality->name2));
-      }
-      WriteAttr(elem, "torquescale", 1, equality->data+10);
-      break;
+      case mjEQ_WELD:
+        if (equality->objtype == mjOBJ_BODY) {
+          WriteAttrTxt(elem, "body1", mjs_getString(equality->name1));
+          WriteAttrTxt(elem, "body2", mjs_getString(equality->name2));
+          WriteAttr(elem, "anchor", 3, equality->data);
+          WriteAttr(elem, "relpose", 7, equality->data+3);
+        } else {
+          WriteAttrTxt(elem, "site1", mjs_getString(equality->name1));
+          WriteAttrTxt(elem, "site2", mjs_getString(equality->name2));
+        }
+        WriteAttr(elem, "torquescale", 1, equality->data+10);
+        break;
 
-    case mjEQ_JOINT:
-      WriteAttrTxt(elem, "joint1", mjs_getString(equality->name1));
-      WriteAttrTxt(elem, "joint2", mjs_getString(equality->name2));
-      WriteAttr(elem, "polycoef", 5, equality->data);
-      break;
+      case mjEQ_JOINT:
+        WriteAttrTxt(elem, "joint1", mjs_getString(equality->name1));
+        WriteAttrTxt(elem, "joint2", mjs_getString(equality->name2));
+        WriteAttr(elem, "polycoef", 5, equality->data);
+        break;
 
-    case mjEQ_TENDON:
-      WriteAttrTxt(elem, "tendon1", mjs_getString(equality->name1));
-      WriteAttrTxt(elem, "tendon2", mjs_getString(equality->name2));
-      WriteAttr(elem, "polycoef", 5, equality->data);
-      break;
+      case mjEQ_TENDON:
+        WriteAttrTxt(elem, "tendon1", mjs_getString(equality->name1));
+        WriteAttrTxt(elem, "tendon2", mjs_getString(equality->name2));
+        WriteAttr(elem, "polycoef", 5, equality->data);
+        break;
 
-    case mjEQ_FLEX:
-      WriteAttrTxt(elem, "flex", mjs_getString(equality->name1));
-      break;
+      case mjEQ_FLEX:
+        WriteAttrTxt(elem, "flex", mjs_getString(equality->name1));
+        break;
 
-    default:
-      mju_error("mjXWriter: unknown equality type.");
+      default:
+        mju_error("mjXWriter: unknown equality type.");
     }
   }
 
@@ -705,7 +706,7 @@ void mjXWriter::OneEquality(XMLElement* elem, const mjCEquality* equality, mjCDe
 
 // write tendon
 void mjXWriter::OneTendon(XMLElement* elem, const mjCTendon* tendon, mjCDef* def) {
-  bool fixed = (tendon->GetWrap(0) && tendon->GetWrap(0)->type==mjWRAP_JOINT);
+  bool fixed = (tendon->GetWrap(0) && tendon->GetWrap(0)->type == mjWRAP_JOINT);
 
   // regular
   if (!writingdefaults) {
@@ -737,7 +738,7 @@ void mjXWriter::OneTendon(XMLElement* elem, const mjCTendon* tendon, mjCDef* def
   }
   // spatial only
   if (!fixed) {
-    if (tendon->get_material()!=def->Tendon().get_material()) {
+    if (tendon->get_material() != def->Tendon().get_material()) {
       WriteAttrTxt(elem, "material", tendon->get_material());
     }
     WriteAttr(elem, "width", 1, &tendon->width, &def->Tendon().width);
@@ -765,34 +766,34 @@ void mjXWriter::OneActuator(XMLElement* elem, const mjCActuator* actuator, mjCDe
 
     // transmission target
     switch (actuator->trntype) {
-    case mjTRN_JOINT:
-      WriteAttrTxt(elem, "joint", actuator->get_target());
-      break;
+      case mjTRN_JOINT:
+        WriteAttrTxt(elem, "joint", actuator->get_target());
+        break;
 
-    case mjTRN_JOINTINPARENT:
-      WriteAttrTxt(elem, "jointinparent", actuator->get_target());
-      break;
+      case mjTRN_JOINTINPARENT:
+        WriteAttrTxt(elem, "jointinparent", actuator->get_target());
+        break;
 
-    case mjTRN_TENDON:
-      WriteAttrTxt(elem, "tendon", actuator->get_target());
-      break;
+      case mjTRN_TENDON:
+        WriteAttrTxt(elem, "tendon", actuator->get_target());
+        break;
 
-    case mjTRN_SLIDERCRANK:
-      WriteAttrTxt(elem, "cranksite", actuator->get_target());
-      WriteAttrTxt(elem, "slidersite", actuator->get_slidersite());
-      break;
+      case mjTRN_SLIDERCRANK:
+        WriteAttrTxt(elem, "cranksite", actuator->get_target());
+        WriteAttrTxt(elem, "slidersite", actuator->get_slidersite());
+        break;
 
-    case mjTRN_SITE:
-      WriteAttrTxt(elem, "site", actuator->get_target());
-      WriteAttrTxt(elem, "refsite", actuator->get_refsite());
-      break;
+      case mjTRN_SITE:
+        WriteAttrTxt(elem, "site", actuator->get_target());
+        WriteAttrTxt(elem, "refsite", actuator->get_refsite());
+        break;
 
-    case mjTRN_BODY:
-      WriteAttrTxt(elem, "body", actuator->get_target());
-      break;
+      case mjTRN_BODY:
+        WriteAttrTxt(elem, "body", actuator->get_target());
+        break;
 
-    default:        // SHOULD NOT OCCUR
-      break;
+      default:      // SHOULD NOT OCCUR
+        break;
     }
   }
 
@@ -851,7 +852,7 @@ void mjXWriter::OnePlugin(XMLElement* elem, const mjsPlugin* plugin) {
   } else {
     WriteAttrTxt(elem, "plugin", plugin_name);
     const mjpPlugin* pplugin = mjp_getPluginAtSlot(
-        static_cast<mjCPlugin*>(plugin->element)->plugin_slot);
+      static_cast<mjCPlugin*>(plugin->element)->plugin_slot);
     const char* c = &(static_cast<mjCPlugin*>(plugin->element)->flattened_attributes[0]);
     for (int i = 0; i < pplugin->nattribute; ++i) {
       string value(c);
@@ -1122,7 +1123,8 @@ void mjXWriter::Visual(XMLElement* root) {
 
   // global
   elem = InsertEnd(section, "global");
-  WriteAttrKey(elem, "orthographic", bool_map, 2, vis->global.orthographic, visdef.global.orthographic);
+  WriteAttrKey(elem, "orthographic",
+               bool_map, 2, vis->global.orthographic, visdef.global.orthographic);
   WriteAttr(elem,    "fovy",      1,   &vis->global.fovy,        &visdef.global.fovy);
   WriteAttr(elem,    "ipd",       1,   &vis->global.ipd,         &visdef.global.ipd);
   WriteAttr(elem,    "azimuth",   1,   &vis->global.azimuth,     &visdef.global.azimuth);
@@ -1132,7 +1134,8 @@ void mjXWriter::Visual(XMLElement* root) {
   WriteAttr(elem,    "realtime",  1,   &vis->global.realtime,    &visdef.global.realtime);
   WriteAttrInt(elem, "offwidth",       vis->global.offwidth,     visdef.global.offwidth);
   WriteAttrInt(elem, "offheight",      vis->global.offheight,    visdef.global.offheight);
-  WriteAttrKey(elem, "ellipsoidinertia", bool_map, 2, vis->global.ellipsoidinertia, visdef.global.ellipsoidinertia);
+  WriteAttrKey(elem, "ellipsoidinertia",
+               bool_map, 2, vis->global.ellipsoidinertia, visdef.global.ellipsoidinertia);
   WriteAttrKey(elem, "bvactive", bool_map, 2, vis->global.bvactive, visdef.global.bvactive);
   if (!elem->FirstAttribute()) {
     section->DeleteChild(elem);
@@ -1322,7 +1325,7 @@ void mjXWriter::Default(XMLElement* root, mjCDef* def) {
   }
 
   // add children recursively
-  for (int i=0; i<(int)def->child.size(); i++) {
+  for (int i=0; i < (int)def->child.size(); i++) {
     Default(section, def->child[i]);
   }
 
@@ -1407,7 +1410,7 @@ void mjXWriter::Custom(XMLElement* root) {
   int ntup = model->NumObjects(mjOBJ_TUPLE);
 
   // skip section if empty
-  if (nnum==0 && ntxt==0 && ntup==0) {
+  if (nnum == 0 && ntxt == 0 && ntup == 0) {
     return;
   }
 
@@ -1415,7 +1418,7 @@ void mjXWriter::Custom(XMLElement* root) {
   XMLElement* section = InsertEnd(root, "custom");
 
   // write all numerics
-  for (int i=0; i<nnum; i++) {
+  for (int i=0; i < nnum; i++) {
     mjCNumeric* numeric = (mjCNumeric*)model->GetObject(mjOBJ_NUMERIC, i);
     elem = InsertEnd(section, "numeric");
     WriteAttrTxt(elem, "name", numeric->name);
@@ -1424,7 +1427,7 @@ void mjXWriter::Custom(XMLElement* root) {
   }
 
   // write all texts
-  for (int i=0; i<ntxt; i++) {
+  for (int i=0; i < ntxt; i++) {
     mjCText* text = (mjCText*)model->GetObject(mjOBJ_TEXT, i);
     elem = InsertEnd(section, "text");
     WriteAttrTxt(elem, "name", text->name);
@@ -1432,18 +1435,18 @@ void mjXWriter::Custom(XMLElement* root) {
   }
 
   // write all tuples
-  for (int i=0; i<ntup; i++) {
+  for (int i=0; i < ntup; i++) {
     mjCTuple* tuple = (mjCTuple*)model->GetObject(mjOBJ_TUPLE, i);
     elem = InsertEnd(section, "tuple");
     WriteAttrTxt(elem, "name", tuple->name);
 
     // write objects in tuple
-    for (int j=0; j<(int)tuple->objtype_.size(); j++) {
+    for (int j=0; j < (int)tuple->objtype_.size(); j++) {
       XMLElement* obj = InsertEnd(elem, "element");
       WriteAttrTxt(obj, "objtype", mju_type2Str((int)tuple->objtype_[j]));
       WriteAttrTxt(obj, "objname", tuple->objname_[j].c_str());
       double oprm = tuple->objprm_[j];
-      if (oprm!=0) {
+      if (oprm != 0) {
         WriteAttr(obj, "prm", 1, &oprm);
       }
     }
@@ -1463,7 +1466,7 @@ void mjXWriter::Asset(XMLElement* root) {
   int nhfield = model->NumObjects(mjOBJ_HFIELD);
 
   // return if empty
-  if (ntex==0 && nmat==0 && nmesh==0 && nhfield==0) {
+  if (ntex == 0 && nmat == 0 && nmesh == 0 && nhfield == 0) {
     return;
   }
 
@@ -1472,7 +1475,7 @@ void mjXWriter::Asset(XMLElement* root) {
 
   // write textures
   mjCTexture deftex(0);
-  for (int i=0; i<ntex; i++) {
+  for (int i=0; i < ntex; i++) {
     // create element
     mjCTexture* texture = (mjCTexture*)model->GetObject(mjOBJ_TEXTURE, i);
     elem = InsertEnd(section, "texture");
@@ -1482,7 +1485,7 @@ void mjXWriter::Asset(XMLElement* root) {
     WriteAttrTxt(elem, "name", texture->name);
 
     // write builtin
-    if (texture->builtin!=mjBUILTIN_NONE) {
+    if (texture->builtin != mjBUILTIN_NONE) {
       WriteAttrKey(elem, "builtin", builtin_map, builtin_sz, texture->builtin);
       WriteAttrKey(elem, "mark", mark_map, mark_sz, texture->mark, deftex.mark);
       WriteAttr(elem, "rgb1", 3, texture->rgb1, deftex.rgb1);
@@ -1531,7 +1534,7 @@ void mjXWriter::Asset(XMLElement* root) {
   }
 
   // write materials
-  for (int i=0; i<nmat; i++) {
+  for (int i=0; i < nmat; i++) {
     // create element and write
     mjCMaterial* material = (mjCMaterial*)model->GetObject(mjOBJ_MATERIAL, i);
     elem = InsertEnd(section, "material");
@@ -1539,7 +1542,7 @@ void mjXWriter::Asset(XMLElement* root) {
   }
 
   // write meshes
-  for (int i=0; i<nmesh; i++) {
+  for (int i=0; i < nmesh; i++) {
     // create element and write
     mjCMesh* mesh = (mjCMesh*)model->GetObject(mjOBJ_MESH, i);
     if (mesh->Plugin().active) {
@@ -1553,7 +1556,7 @@ void mjXWriter::Asset(XMLElement* root) {
   }
 
   // write hfields
-  for (int i=0; i<nhfield; i++) {
+  for (int i=0; i < nhfield; i++) {
     // create element
     mjCHField* hfield = (mjCHField*)model->GetObject(mjOBJ_HFIELD, i);
     elem = InsertEnd(section, "hfield");
@@ -1606,7 +1609,7 @@ void mjXWriter::Body(XMLElement* elem, mjCBody* body, mjCFrame* frame, string_vi
   }
 
   // write body attributes and inertial
-  else if (!frame && body!=model->GetWorld()) {
+  else if (!frame && body != model->GetWorld()) {
     WriteAttrTxt(elem, "name", body->name);
     if (childclass != body->classname && body->classname != "main") {
       WriteAttrTxt(elem, "childclass", body->classname);
@@ -1629,7 +1632,7 @@ void mjXWriter::Body(XMLElement* elem, mjCBody* body, mjCFrame* frame, string_vi
     WriteVector(elem, "user", body->get_userdata());
 
     // write inertial
-    if (body->explicitinertial && model->compiler.inertiafromgeom!=mjINERTIAFROMGEOM_TRUE) {
+    if (body->explicitinertial && model->compiler.inertiafromgeom != mjINERTIAFROMGEOM_TRUE) {
       XMLElement* inertial = InsertEnd(elem, "inertial");
       WriteAttr(inertial, "pos", 3, body->ipos);
       WriteAttr(inertial, "quat", 4, body->iquat, unitq);
@@ -1719,7 +1722,7 @@ void mjXWriter::Body(XMLElement* elem, mjCBody* body, mjCFrame* frame, string_vi
                              ? bframe->classname
                              : body->classname;
       Body(InsertEnd(elem, "body"), body->bodies[i], nullptr,
-            classname.empty() ? childclass : classname);
+           classname.empty() ? childclass : classname);
     }
 
     i++;
@@ -1760,7 +1763,7 @@ void mjXWriter::Contact(XMLElement* root) {
   int nexclude = model->NumObjects(mjOBJ_EXCLUDE);
 
   // skip if section is empty
-  if (npair==0 && nexclude==0) {
+  if (npair == 0 && nexclude == 0) {
     return;
   }
 
@@ -1768,7 +1771,7 @@ void mjXWriter::Contact(XMLElement* root) {
   XMLElement* section = InsertEnd(root, "contact");
 
   // write all geom pairs
-  for (int i=0; i<npair; i++) {
+  for (int i=0; i < npair; i++) {
     // create element and write
     mjCPair* pair = (mjCPair*)model->GetObject(mjOBJ_PAIR, i);
     elem = InsertEnd(section, "pair");
@@ -1776,7 +1779,7 @@ void mjXWriter::Contact(XMLElement* root) {
   }
 
   // write all exclude pairs
-  for (int i=0; i<nexclude; i++) {
+  for (int i=0; i < nexclude; i++) {
     // create element
     mjCBodyPair* exclude = (mjCBodyPair*)model->GetObject(mjOBJ_EXCLUDE, i);
     elem = InsertEnd(section, "exclude");
@@ -1794,7 +1797,7 @@ void mjXWriter::Contact(XMLElement* root) {
 void mjXWriter::Equality(XMLElement* root) {
   // skip section if empty
   int num;
-  if ((num=model->NumObjects(mjOBJ_EQUALITY))==0) {
+  if ((num=model->NumObjects(mjOBJ_EQUALITY)) == 0) {
     return;
   }
 
@@ -1802,9 +1805,10 @@ void mjXWriter::Equality(XMLElement* root) {
   XMLElement* section = InsertEnd(root, "equality");
 
   // write all constraints
-  for (int i=0; i<num; i++) {
+  for (int i=0; i < num; i++) {
     mjCEquality* equality = (mjCEquality*)model->GetObject(mjOBJ_EQUALITY, i);
-    XMLElement* elem = InsertEnd(section, FindValue(equality_map, equality_sz, equality->type).c_str());
+    XMLElement* elem = InsertEnd(section,
+                                 FindValue(equality_map, equality_sz, equality->type).c_str());
     OneEquality(elem, equality, model->def_map[equality->classname]);
   }
 }
@@ -1820,7 +1824,7 @@ void mjXWriter::Deformable(XMLElement* root) {
   int nskin = model->NumObjects(mjOBJ_SKIN);
 
   // return if empty
-  if (nflex==0 && nskin==0) {
+  if (nflex == 0 && nskin == 0) {
     return;
   }
 
@@ -1828,7 +1832,7 @@ void mjXWriter::Deformable(XMLElement* root) {
   XMLElement* section = InsertEnd(root, "deformable");
 
   // write flexes
-  for (int i=0; i<nflex; i++) {
+  for (int i=0; i < nflex; i++) {
     // create element and write
     mjCFlex* flex = (mjCFlex*)model->GetObject(mjOBJ_FLEX, i);
     elem = InsertEnd(section, "flex");
@@ -1836,7 +1840,7 @@ void mjXWriter::Deformable(XMLElement* root) {
   }
 
   // write skins
-  for (int i=0; i<nskin; i++) {
+  for (int i=0; i < nskin; i++) {
     // create element and write
     mjCSkin* skin = (mjCSkin*)model->GetObject(mjOBJ_SKIN, i);
     elem = InsertEnd(section, "skin");
@@ -1850,7 +1854,7 @@ void mjXWriter::Deformable(XMLElement* root) {
 void mjXWriter::Tendon(XMLElement* root) {
   // skip section if empty
   int num;
-  if ((num=model->NumObjects(mjOBJ_TENDON))==0) {
+  if ((num=model->NumObjects(mjOBJ_TENDON)) == 0) {
     return;
   }
 
@@ -1858,48 +1862,48 @@ void mjXWriter::Tendon(XMLElement* root) {
   XMLElement* section = InsertEnd(root, "tendon");
 
   // write all tendons
-  for (int i=0; i<num; i++) {
+  for (int i=0; i < num; i++) {
     // write tendon element and attributes
     mjCTendon* tendon = (mjCTendon*)model->GetObject(mjOBJ_TENDON, i);
     if (!tendon->NumWraps()) {        // SHOULD NOT OCCUR
       continue;
     }
     XMLElement* elem = InsertEnd(section,
-                                 tendon->GetWrap(0)->type==mjWRAP_JOINT ? "fixed" : "spatial");
+                                 tendon->GetWrap(0)->type == mjWRAP_JOINT ? "fixed" : "spatial");
     OneTendon(elem, tendon, model->def_map[tendon->classname]);
 
     // write wraps
     XMLElement* wrapelem;
-    for (int j=0; j<tendon->NumWraps(); j++) {
+    for (int j=0; j < tendon->NumWraps(); j++) {
       const mjCWrap* wrap = tendon->GetWrap(j);
       switch (wrap->type) {
-      case mjWRAP_JOINT:
-        wrapelem = InsertEnd(elem, "joint");
-        WriteAttrTxt(wrapelem, "joint", wrap->obj->name);
-        WriteAttr(wrapelem, "coef", 1, &wrap->prm);
-        break;
+        case mjWRAP_JOINT:
+          wrapelem = InsertEnd(elem, "joint");
+          WriteAttrTxt(wrapelem, "joint", wrap->obj->name);
+          WriteAttr(wrapelem, "coef", 1, &wrap->prm);
+          break;
 
-      case mjWRAP_SITE:
-        wrapelem = InsertEnd(elem, "site");
-        WriteAttrTxt(wrapelem, "site", wrap->obj->name);
-        break;
+        case mjWRAP_SITE:
+          wrapelem = InsertEnd(elem, "site");
+          WriteAttrTxt(wrapelem, "site", wrap->obj->name);
+          break;
 
-      case mjWRAP_SPHERE:
-      case mjWRAP_CYLINDER:
-        wrapelem = InsertEnd(elem, "geom");
-        WriteAttrTxt(wrapelem, "geom", wrap->obj->name);
-        if (!wrap->sidesite.empty()) {
-          WriteAttrTxt(wrapelem, "sidesite", wrap->sidesite);
-        }
-        break;
+        case mjWRAP_SPHERE:
+        case mjWRAP_CYLINDER:
+          wrapelem = InsertEnd(elem, "geom");
+          WriteAttrTxt(wrapelem, "geom", wrap->obj->name);
+          if (!wrap->sidesite.empty()) {
+            WriteAttrTxt(wrapelem, "sidesite", wrap->sidesite);
+          }
+          break;
 
-      case mjWRAP_PULLEY:
-        wrapelem = InsertEnd(elem, "pulley");
-        WriteAttr(wrapelem, "divisor", 1, &wrap->prm);
-        break;
+        case mjWRAP_PULLEY:
+          wrapelem = InsertEnd(elem, "pulley");
+          WriteAttr(wrapelem, "divisor", 1, &wrap->prm);
+          break;
 
-      default:
-        break;
+        default:
+          break;
       }
     }
   }
@@ -1911,7 +1915,7 @@ void mjXWriter::Tendon(XMLElement* root) {
 void mjXWriter::Actuator(XMLElement* root) {
   // skip section if empty
   int num;
-  if ((num=model->NumObjects(mjOBJ_ACTUATOR))==0) {
+  if ((num=model->NumObjects(mjOBJ_ACTUATOR)) == 0) {
     return;
   }
 
@@ -1919,7 +1923,7 @@ void mjXWriter::Actuator(XMLElement* root) {
   XMLElement* section = InsertEnd(root, "actuator");
 
   // write all actuators
-  for (int i=0; i<num; i++) {
+  for (int i=0; i < num; i++) {
     mjCActuator* actuator = (mjCActuator*)model->GetObject(mjOBJ_ACTUATOR, i);
     XMLElement* elem;
     if (actuator->plugin.active) {
@@ -1939,7 +1943,7 @@ void mjXWriter::Sensor(XMLElement* root) {
 
   // skip section if empty
   int num;
-  if ((num=model->NumObjects(mjOBJ_SENSOR))==0) {
+  if ((num=model->NumObjects(mjOBJ_SENSOR)) == 0) {
     return;
   }
 
@@ -1947,7 +1951,7 @@ void mjXWriter::Sensor(XMLElement* root) {
   XMLElement* section = InsertEnd(root, "sensor");
 
   // write all sensors
-  for (int i=0; i<num; i++) {
+  for (int i=0; i < num; i++) {
     XMLElement* elem = 0;
     mjCSensor* sensor = model->Sensors()[i];
     string instance_name = "";
@@ -1955,261 +1959,263 @@ void mjXWriter::Sensor(XMLElement* root) {
 
     // write sensor type and type-specific attributes
     switch (sensor->type) {
-    // common robotic sensors, attached to a site
-    case mjSENS_TOUCH:
-      elem = InsertEnd(section, "touch");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      break;
-    case mjSENS_ACCELEROMETER:
-      elem = InsertEnd(section, "accelerometer");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      break;
-    case mjSENS_VELOCIMETER:
-      elem = InsertEnd(section, "velocimeter");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      break;
-    case mjSENS_GYRO:
-      elem = InsertEnd(section, "gyro");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      break;
-    case mjSENS_FORCE:
-      elem = InsertEnd(section, "force");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      break;
-    case mjSENS_TORQUE:
-      elem = InsertEnd(section, "torque");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      break;
-    case mjSENS_MAGNETOMETER:
-      elem = InsertEnd(section, "magnetometer");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      break;
-    case mjSENS_RANGEFINDER:
-      elem = InsertEnd(section, "rangefinder");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      break;
-    case mjSENS_CAMPROJECTION:
-      elem = InsertEnd(section, "camprojection");
-      WriteAttrTxt(elem, "site", sensor->get_objname());
-      WriteAttrTxt(elem, "camera", sensor->get_refname());
-      break;
+      // common robotic sensors, attached to a site
+      case mjSENS_TOUCH:
+        elem = InsertEnd(section, "touch");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        break;
+      case mjSENS_ACCELEROMETER:
+        elem = InsertEnd(section, "accelerometer");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        break;
+      case mjSENS_VELOCIMETER:
+        elem = InsertEnd(section, "velocimeter");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        break;
+      case mjSENS_GYRO:
+        elem = InsertEnd(section, "gyro");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        break;
+      case mjSENS_FORCE:
+        elem = InsertEnd(section, "force");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        break;
+      case mjSENS_TORQUE:
+        elem = InsertEnd(section, "torque");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        break;
+      case mjSENS_MAGNETOMETER:
+        elem = InsertEnd(section, "magnetometer");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        break;
+      case mjSENS_RANGEFINDER:
+        elem = InsertEnd(section, "rangefinder");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        break;
+      case mjSENS_CAMPROJECTION:
+        elem = InsertEnd(section, "camprojection");
+        WriteAttrTxt(elem, "site", sensor->get_objname());
+        WriteAttrTxt(elem, "camera", sensor->get_refname());
+        break;
 
-    // sensors related to scalar joints, tendons, actuators
-    case mjSENS_JOINTPOS:
-      elem = InsertEnd(section, "jointpos");
-      WriteAttrTxt(elem, "joint", sensor->get_objname());
-      break;
-    case mjSENS_JOINTVEL:
-      elem = InsertEnd(section, "jointvel");
-      WriteAttrTxt(elem, "joint", sensor->get_objname());
-      break;
-    case mjSENS_TENDONPOS:
-      elem = InsertEnd(section, "tendonpos");
-      WriteAttrTxt(elem, "tendon", sensor->get_objname());
-      break;
-    case mjSENS_TENDONVEL:
-      elem = InsertEnd(section, "tendonvel");
-      WriteAttrTxt(elem, "tendon", sensor->get_objname());
-      break;
-    case mjSENS_ACTUATORPOS:
-      elem = InsertEnd(section, "actuatorpos");
-      WriteAttrTxt(elem, "actuator", sensor->get_objname());
-      break;
-    case mjSENS_ACTUATORVEL:
-      elem = InsertEnd(section, "actuatorvel");
-      WriteAttrTxt(elem, "actuator", sensor->get_objname());
-      break;
-    case mjSENS_ACTUATORFRC:
-      elem = InsertEnd(section, "actuatorfrc");
-      WriteAttrTxt(elem, "actuator", sensor->get_objname());
-      break;
-    case mjSENS_JOINTACTFRC:
-      elem = InsertEnd(section, "jointactuatorfrc");
-      WriteAttrTxt(elem, "joint", sensor->get_objname());
-      break;
+      // sensors related to scalar joints, tendons, actuators
+      case mjSENS_JOINTPOS:
+        elem = InsertEnd(section, "jointpos");
+        WriteAttrTxt(elem, "joint", sensor->get_objname());
+        break;
+      case mjSENS_JOINTVEL:
+        elem = InsertEnd(section, "jointvel");
+        WriteAttrTxt(elem, "joint", sensor->get_objname());
+        break;
+      case mjSENS_TENDONPOS:
+        elem = InsertEnd(section, "tendonpos");
+        WriteAttrTxt(elem, "tendon", sensor->get_objname());
+        break;
+      case mjSENS_TENDONVEL:
+        elem = InsertEnd(section, "tendonvel");
+        WriteAttrTxt(elem, "tendon", sensor->get_objname());
+        break;
+      case mjSENS_ACTUATORPOS:
+        elem = InsertEnd(section, "actuatorpos");
+        WriteAttrTxt(elem, "actuator", sensor->get_objname());
+        break;
+      case mjSENS_ACTUATORVEL:
+        elem = InsertEnd(section, "actuatorvel");
+        WriteAttrTxt(elem, "actuator", sensor->get_objname());
+        break;
+      case mjSENS_ACTUATORFRC:
+        elem = InsertEnd(section, "actuatorfrc");
+        WriteAttrTxt(elem, "actuator", sensor->get_objname());
+        break;
+      case mjSENS_JOINTACTFRC:
+        elem = InsertEnd(section, "jointactuatorfrc");
+        WriteAttrTxt(elem, "joint", sensor->get_objname());
+        break;
 
-    // sensors related to ball joints
-    case mjSENS_BALLQUAT:
-      elem = InsertEnd(section, "ballquat");
-      WriteAttrTxt(elem, "joint", sensor->get_objname());
-      break;
-    case mjSENS_BALLANGVEL:
-      elem = InsertEnd(section, "ballangvel");
-      WriteAttrTxt(elem, "joint", sensor->get_objname());
-      break;
+      // sensors related to ball joints
+      case mjSENS_BALLQUAT:
+        elem = InsertEnd(section, "ballquat");
+        WriteAttrTxt(elem, "joint", sensor->get_objname());
+        break;
+      case mjSENS_BALLANGVEL:
+        elem = InsertEnd(section, "ballangvel");
+        WriteAttrTxt(elem, "joint", sensor->get_objname());
+        break;
 
-    // joint and tendon limit sensors
-    case mjSENS_JOINTLIMITPOS:
-      elem = InsertEnd(section, "jointlimitpos");
-      WriteAttrTxt(elem, "joint", sensor->get_objname());
-      break;
-    case mjSENS_JOINTLIMITVEL:
-      elem = InsertEnd(section, "jointlimitvel");
-      WriteAttrTxt(elem, "joint", sensor->get_objname());
-      break;
-    case mjSENS_JOINTLIMITFRC:
-      elem = InsertEnd(section, "jointlimitfrc");
-      WriteAttrTxt(elem, "joint", sensor->get_objname());
-      break;
-    case mjSENS_TENDONLIMITPOS:
-      elem = InsertEnd(section, "tendonlimitpos");
-      WriteAttrTxt(elem, "tendon", sensor->get_objname());
-      break;
-    case mjSENS_TENDONLIMITVEL:
-      elem = InsertEnd(section, "tendonlimitvel");
-      WriteAttrTxt(elem, "tendon", sensor->get_objname());
-      break;
-    case mjSENS_TENDONLIMITFRC:
-      elem = InsertEnd(section, "tendonlimitfrc");
-      WriteAttrTxt(elem, "tendon", sensor->get_objname());
-      break;
+      // joint and tendon limit sensors
+      case mjSENS_JOINTLIMITPOS:
+        elem = InsertEnd(section, "jointlimitpos");
+        WriteAttrTxt(elem, "joint", sensor->get_objname());
+        break;
+      case mjSENS_JOINTLIMITVEL:
+        elem = InsertEnd(section, "jointlimitvel");
+        WriteAttrTxt(elem, "joint", sensor->get_objname());
+        break;
+      case mjSENS_JOINTLIMITFRC:
+        elem = InsertEnd(section, "jointlimitfrc");
+        WriteAttrTxt(elem, "joint", sensor->get_objname());
+        break;
+      case mjSENS_TENDONLIMITPOS:
+        elem = InsertEnd(section, "tendonlimitpos");
+        WriteAttrTxt(elem, "tendon", sensor->get_objname());
+        break;
+      case mjSENS_TENDONLIMITVEL:
+        elem = InsertEnd(section, "tendonlimitvel");
+        WriteAttrTxt(elem, "tendon", sensor->get_objname());
+        break;
+      case mjSENS_TENDONLIMITFRC:
+        elem = InsertEnd(section, "tendonlimitfrc");
+        WriteAttrTxt(elem, "tendon", sensor->get_objname());
+        break;
 
-    // sensors attached to an object with spatial frame: (x)body, geom, site, camera
-    case mjSENS_FRAMEPOS:
-      elem = InsertEnd(section, "framepos");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-    case mjSENS_FRAMEQUAT:
-      elem = InsertEnd(section, "framequat");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-    case mjSENS_FRAMEXAXIS:
-      elem = InsertEnd(section, "framexaxis");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-    case mjSENS_FRAMEYAXIS:
-      elem = InsertEnd(section, "frameyaxis");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-    case mjSENS_FRAMEZAXIS:
-      elem = InsertEnd(section, "framezaxis");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-    case mjSENS_FRAMELINVEL:
-      elem = InsertEnd(section, "framelinvel");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-    case mjSENS_FRAMEANGVEL:
-      elem = InsertEnd(section, "frameangvel");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-    case mjSENS_FRAMELINACC:
-      elem = InsertEnd(section, "framelinacc");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-    case mjSENS_FRAMEANGACC:
-      elem = InsertEnd(section, "frameangacc");
-      WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      if (sensor->reftype != mjOBJ_UNKNOWN) {
-        WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
-        WriteAttrTxt(elem, "refname", sensor->get_refname());
-      }
-      break;
-
-    // sensors related to kinematic subtrees; attached to a body (which is the subtree root)
-    case mjSENS_SUBTREECOM:
-      elem = InsertEnd(section, "subtreecom");
-      WriteAttrTxt(elem, "body", sensor->get_objname());
-      break;
-    case mjSENS_SUBTREELINVEL:
-      elem = InsertEnd(section, "subtreelinvel");
-      WriteAttrTxt(elem, "body", sensor->get_objname());
-      break;
-    case mjSENS_SUBTREEANGMOM:
-      elem = InsertEnd(section, "subtreeangmom");
-      WriteAttrTxt(elem, "body", sensor->get_objname());
-      break;
-    case mjSENS_GEOMDIST:
-      elem = InsertEnd(section, "distance");
-      WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname());
-      WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname());
-      break;
-    case mjSENS_GEOMNORMAL:
-      elem = InsertEnd(section, "normal");
-      WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname());
-      WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname());
-      break;
-    case mjSENS_GEOMFROMTO:
-      elem = InsertEnd(section, "fromto");
-      WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname());
-      WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname());
-      break;
-
-    // global sensors
-    case mjSENS_E_POTENTIAL:
-      elem = InsertEnd(section, "potential");
-      break;
-    case mjSENS_E_KINETIC:
-      elem = InsertEnd(section, "kinetic");
-      break;
-    case mjSENS_CLOCK:
-      elem = InsertEnd(section, "clock");
-      break;
-
-
-    // plugin-controlled sensor
-    case mjSENS_PLUGIN:
-      elem = InsertEnd(section, "plugin");
-      if (sensor->objtype != mjOBJ_UNKNOWN) {
+      // sensors attached to an object with spatial frame: (x)body, geom, site, camera
+      case mjSENS_FRAMEPOS:
+        elem = InsertEnd(section, "framepos");
         WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
         WriteAttrTxt(elem, "objname", sensor->get_objname());
-      }
-      OnePlugin(elem, &sensor->plugin);
-      break;
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
+      case mjSENS_FRAMEQUAT:
+        elem = InsertEnd(section, "framequat");
+        WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
+      case mjSENS_FRAMEXAXIS:
+        elem = InsertEnd(section, "framexaxis");
+        WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
+      case mjSENS_FRAMEYAXIS:
+        elem = InsertEnd(section, "frameyaxis");
+        WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
+      case mjSENS_FRAMEZAXIS:
+        elem = InsertEnd(section, "framezaxis");
+        WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
+      case mjSENS_FRAMELINVEL:
+        elem = InsertEnd(section, "framelinvel");
+        WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
+      case mjSENS_FRAMEANGVEL:
+        elem = InsertEnd(section, "frameangvel");
+        WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
+      case mjSENS_FRAMELINACC:
+        elem = InsertEnd(section, "framelinacc");
+        WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
+      case mjSENS_FRAMEANGACC:
+        elem = InsertEnd(section, "frameangacc");
+        WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        if (sensor->reftype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype));
+          WriteAttrTxt(elem, "refname", sensor->get_refname());
+        }
+        break;
 
-    // user-defined sensor
-    case mjSENS_USER:
-      elem = InsertEnd(section, "user");
-      if (mju_type2Str(sensor->objtype)) WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
-      WriteAttrTxt(elem, "objname", sensor->get_objname());
-      WriteAttrInt(elem, "dim", sensor->dim);
-      WriteAttrKey(elem, "needstage", stage_map, stage_sz, (int)sensor->needstage);
-      WriteAttrKey(elem, "datatype", datatype_map, datatype_sz, (int)sensor->datatype);
-      break;
+      // sensors related to kinematic subtrees; attached to a body (which is the subtree root)
+      case mjSENS_SUBTREECOM:
+        elem = InsertEnd(section, "subtreecom");
+        WriteAttrTxt(elem, "body", sensor->get_objname());
+        break;
+      case mjSENS_SUBTREELINVEL:
+        elem = InsertEnd(section, "subtreelinvel");
+        WriteAttrTxt(elem, "body", sensor->get_objname());
+        break;
+      case mjSENS_SUBTREEANGMOM:
+        elem = InsertEnd(section, "subtreeangmom");
+        WriteAttrTxt(elem, "body", sensor->get_objname());
+        break;
+      case mjSENS_GEOMDIST:
+        elem = InsertEnd(section, "distance");
+        WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname());
+        WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname());
+        break;
+      case mjSENS_GEOMNORMAL:
+        elem = InsertEnd(section, "normal");
+        WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname());
+        WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname());
+        break;
+      case mjSENS_GEOMFROMTO:
+        elem = InsertEnd(section, "fromto");
+        WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname());
+        WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname());
+        break;
 
-    default:
-      mju_error("Unknown sensor type in XML write");
+      // global sensors
+      case mjSENS_E_POTENTIAL:
+        elem = InsertEnd(section, "potential");
+        break;
+      case mjSENS_E_KINETIC:
+        elem = InsertEnd(section, "kinetic");
+        break;
+      case mjSENS_CLOCK:
+        elem = InsertEnd(section, "clock");
+        break;
+
+
+      // plugin-controlled sensor
+      case mjSENS_PLUGIN:
+        elem = InsertEnd(section, "plugin");
+        if (sensor->objtype != mjOBJ_UNKNOWN) {
+          WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+          WriteAttrTxt(elem, "objname", sensor->get_objname());
+        }
+        OnePlugin(elem, &sensor->plugin);
+        break;
+
+      // user-defined sensor
+      case mjSENS_USER:
+        elem = InsertEnd(section, "user");
+        if (mju_type2Str(sensor->objtype)) {
+          WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype));
+        }
+        WriteAttrTxt(elem, "objname", sensor->get_objname());
+        WriteAttrInt(elem, "dim", sensor->dim);
+        WriteAttrKey(elem, "needstage", stage_map, stage_sz, (int)sensor->needstage);
+        WriteAttrKey(elem, "datatype", datatype_map, datatype_sz, (int)sensor->datatype);
+        break;
+
+      default:
+        mju_error("Unknown sensor type in XML write");
     }
 
     // write name, noise, userdata
@@ -2239,7 +2245,7 @@ void mjXWriter::Keyframe(XMLElement* root) {
   }
 
   // write all keyframes
-  for (int i=0; i<model->nkey; i++) {
+  for (int i=0; i < model->nkey; i++) {
     XMLElement* elem = InsertEnd(section, "key");
     bool change = false;
 
@@ -2252,14 +2258,14 @@ void mjXWriter::Keyframe(XMLElement* root) {
     }
 
     // check time and write
-    if (key->time!=0) {
+    if (key->time != 0) {
       WriteAttr(elem, "time", 1, &key->time);
       change = true;
     }
 
     // check qpos and write
-    for (int j=0; j<model->nq; j++) {
-      if (key->qpos_[j]!=model->qpos0[j]) {
+    for (int j=0; j < model->nq; j++) {
+      if (key->qpos_[j] != model->qpos0[j]) {
         WriteAttr(elem, "qpos", model->nq, key->qpos_.data());
         change = true;
         break;
@@ -2267,8 +2273,8 @@ void mjXWriter::Keyframe(XMLElement* root) {
     }
 
     // check qvel and write
-    for (int j=0; j<model->nv; j++) {
-      if (key->qvel_[j]!=0) {
+    for (int j=0; j < model->nv; j++) {
+      if (key->qvel_[j] != 0) {
         WriteAttr(elem, "qvel", model->nv, key->qvel_.data());
         change = true;
         break;
@@ -2276,8 +2282,8 @@ void mjXWriter::Keyframe(XMLElement* root) {
     }
 
     // check act and write
-    for (int j=0; j<model->na; j++) {
-      if (key->act_[j]!=0) {
+    for (int j=0; j < model->na; j++) {
+      if (key->act_[j] != 0) {
         WriteAttr(elem, "act", model->na, key->act_.data());
         change = true;
         break;
@@ -2286,7 +2292,7 @@ void mjXWriter::Keyframe(XMLElement* root) {
 
     // check mpos and write
     if (model->nmocap) {
-      for (int j=0; j<model->nbody; j++) {
+      for (int j=0; j < model->nbody; j++) {
         if (model->Bodies()[j]->mocap) {
           mjCBody* body = model->Bodies()[j];
           int id = body->mocapid;
@@ -2303,7 +2309,7 @@ void mjXWriter::Keyframe(XMLElement* root) {
 
     // check mquat and write
     if (model->nmocap) {
-      for (int j=0; j<model->nbody; j++) {
+      for (int j=0; j < model->nbody; j++) {
         if (model->Bodies()[j]->mocap) {
           mjCBody* body = model->Bodies()[j];
           int id = body->mocapid;
@@ -2320,8 +2326,8 @@ void mjXWriter::Keyframe(XMLElement* root) {
     }
 
     // check ctrl and write
-    for (int j=0; j<model->nu; j++) {
-      if (key->ctrl_[j]!=0) {
+    for (int j=0; j < model->nu; j++) {
+      if (key->ctrl_[j] != 0) {
         WriteAttr(elem, "ctrl", model->nu, key->ctrl_.data());
         change = true;
         break;
diff --git a/src/xml/xml_urdf.cc b/src/xml/xml_urdf.cc
index 301ac22a..3667cf35 100644
--- a/src/xml/xml_urdf.cc
+++ b/src/xml/xml_urdf.cc
@@ -125,7 +125,7 @@ void mjXURDF::Parse(
   while (elem) {
     // identify link elements
     name = elem->Value();
-    if (name=="link") {
+    if (name == "link") {
       ReadAttrTxt(elem, "name", text, true);
       text = GetPrefixedName(text);
       AddBody(text);
@@ -140,7 +140,7 @@ void mjXURDF::Parse(
   while (elem) {
     // identify joint elements
     name = elem->Value();
-    if (name=="joint") {
+    if (name == "joint") {
       // find parent, get name and id
       temp = FindSubElem(elem, "parent", true);
       ReadAttrTxt(temp, "link", text, true);
@@ -154,12 +154,12 @@ void mjXURDF::Parse(
       id_child = FindName(text, urName);
 
       // make sure parent and child exist
-      if (id_parent<0 || id_child<0) {
+      if (id_parent < 0 || id_child < 0) {
         throw mjXError(elem, "URDF joint parent or child missing");
       }
 
       // check for multiple parents
-      if (urParent[id_child]>=0) {
+      if (urParent[id_child] >= 0) {
         throw mjXError(elem, "URDF body has multiple parents:", urName[id_child].c_str());
       }
 
@@ -173,7 +173,7 @@ void mjXURDF::Parse(
   }
 
   // find all top-level bodies, call recursive tree constructor
-  for (int i=0; i<(int)urName.size(); i++) {
+  for (int i=0; i < (int)urName.size(); i++) {
     if (urParent[i] < 0) {
       AddToTree(i);
     }
@@ -184,7 +184,7 @@ void mjXURDF::Parse(
   while (elem) {
     // identify body/link elements
     name = elem->Value();
-    if (name=="link") {
+    if (name == "link") {
       Body(elem);
     }
 
@@ -197,7 +197,7 @@ void mjXURDF::Parse(
   while (elem) {
     // identify body/link elements
     name = elem->Value();
-    if (name=="joint") {
+    if (name == "joint") {
       Joint(elem);
     }
 
@@ -297,7 +297,7 @@ void mjXURDF::Body(XMLElement* body_elem) {
     name = elem->Value();
 
     // visual element
-    if (name=="visual") {
+    if (name == "visual") {
       // parse material
       if ((temp = FindSubElem(elem, "material"))) {
         // if color specified - use directly
@@ -310,7 +310,7 @@ void mjXURDF::Body(XMLElement* body_elem) {
           ReadAttrTxt(temp, "name", name, true);
           name = GetPrefixedName(name);
           int imat = FindName(name, urMat);
-          if (imat>=0) {
+          if (imat >= 0) {
             std::memcpy(rgba, urRGBA[imat].val, 4*sizeof(float));
           }
         }
@@ -320,7 +320,7 @@ void mjXURDF::Body(XMLElement* body_elem) {
         pgeom = Geom(elem, pbody, false);
 
         // save color
-        if (rgba[0]>=0) {
+        if (rgba[0] >= 0) {
           std::memcpy(pgeom->rgba, rgba, 4*sizeof(float));
         }
 
@@ -339,11 +339,11 @@ void mjXURDF::Body(XMLElement* body_elem) {
     }
 
     // collision element
-    else if (name=="collision") {
+    else if (name == "collision") {
       pgeom = Geom(elem, pbody, true);
 
       // use color from last visual
-      if (rgba[0]>=0) {
+      if (rgba[0] >= 0) {
         std::memcpy(pgeom->rgba, rgba, 4*sizeof(float));
       }
 
@@ -418,71 +418,71 @@ void mjXURDF::Joint(XMLElement* joint_elem) {
   // create joint (unless fixed)
   double mat[9], quat[4], tmpaxis[3];
   switch (jointtype) {
-  case 0:     // revolute
-  case 1:     // continuous
-    pjoint = mjs_addJoint(pbody, 0);
-    mjs_setString(pjoint->name, jntname.c_str());
-    pjoint->type = mjJNT_HINGE;
-    mjuu_setvec(pjoint->pos, 0, 0, 0);
-    mjuu_copyvec(pjoint->axis, axis, 3);
-    break;
+    case 0:   // revolute
+    case 1:   // continuous
+      pjoint = mjs_addJoint(pbody, 0);
+      mjs_setString(pjoint->name, jntname.c_str());
+      pjoint->type = mjJNT_HINGE;
+      mjuu_setvec(pjoint->pos, 0, 0, 0);
+      mjuu_copyvec(pjoint->axis, axis, 3);
+      break;
 
-  case 2:     // prismatic
-    pjoint = mjs_addJoint(pbody, 0);
-    mjs_setString(pjoint->name, jntname.c_str());
-    pjoint->type = mjJNT_SLIDE;
-    mjuu_setvec(pjoint->pos, 0, 0, 0);
-    mjuu_copyvec(pjoint->axis, axis, 3);
-    break;
+    case 2:   // prismatic
+      pjoint = mjs_addJoint(pbody, 0);
+      mjs_setString(pjoint->name, jntname.c_str());
+      pjoint->type = mjJNT_SLIDE;
+      mjuu_setvec(pjoint->pos, 0, 0, 0);
+      mjuu_copyvec(pjoint->axis, axis, 3);
+      break;
 
-  case 3:     // fixed- no joint, return
-    return;
+    case 3:   // fixed- no joint, return
+      return;
 
-  case 4:     // floating
-    pjoint = mjs_addJoint(pbody, 0);
-    mjs_setString(pjoint->name, jntname.c_str());
-    pjoint->type = mjJNT_FREE;
-    break;
+    case 4:   // floating
+      pjoint = mjs_addJoint(pbody, 0);
+      mjs_setString(pjoint->name, jntname.c_str());
+      pjoint->type = mjJNT_FREE;
+      break;
 
-  case 5:     // planar- construct complex joint
-    // make frame with axis = z
-    mjuu_z2quat(quat, axis);
-    mjuu_quat2mat(mat, quat);
+    case 5:   // planar- construct complex joint
+      // make frame with axis = z
+      mjuu_z2quat(quat, axis);
+      mjuu_quat2mat(mat, quat);
 
-    // construct slider along x
-    pjoint = mjs_addJoint(pbody, 0);
-    mjs_setString(pjoint->name, (jntname + "_TX").c_str());
-    pjoint->type = mjJNT_SLIDE;
-    tmpaxis[0] = mat[0];
-    tmpaxis[1] = mat[3];
-    tmpaxis[2] = mat[6];
-    mjuu_setvec(pjoint->pos, 0, 0, 0);
-    mjuu_copyvec(pjoint->axis, tmpaxis, 3);
+      // construct slider along x
+      pjoint = mjs_addJoint(pbody, 0);
+      mjs_setString(pjoint->name, (jntname + "_TX").c_str());
+      pjoint->type = mjJNT_SLIDE;
+      tmpaxis[0] = mat[0];
+      tmpaxis[1] = mat[3];
+      tmpaxis[2] = mat[6];
+      mjuu_setvec(pjoint->pos, 0, 0, 0);
+      mjuu_copyvec(pjoint->axis, tmpaxis, 3);
 
-    // construct slider along y
-    pjoint1 = mjs_addJoint(pbody, 0);
-    mjs_setString(pjoint1->name, (jntname + "_TY").c_str());
-    pjoint1->type = mjJNT_SLIDE;
-    tmpaxis[0] = mat[1];
-    tmpaxis[1] = mat[4];
-    tmpaxis[2] = mat[7];
-    mjuu_setvec(pjoint1->pos, 0, 0, 0);
-    mjuu_copyvec(pjoint1->axis, tmpaxis, 3);
+      // construct slider along y
+      pjoint1 = mjs_addJoint(pbody, 0);
+      mjs_setString(pjoint1->name, (jntname + "_TY").c_str());
+      pjoint1->type = mjJNT_SLIDE;
+      tmpaxis[0] = mat[1];
+      tmpaxis[1] = mat[4];
+      tmpaxis[2] = mat[7];
+      mjuu_setvec(pjoint1->pos, 0, 0, 0);
+      mjuu_copyvec(pjoint1->axis, tmpaxis, 3);
 
-    // construct hinge around z = locaxis
-    pjoint2 = mjs_addJoint(pbody, 0);
-    mjs_setString(pjoint2->name, (jntname + "_RZ").c_str());
-    pjoint2->type = mjJNT_HINGE;
-    mjuu_setvec(pjoint2->pos, 0, 0, 0);
-    mjuu_copyvec(pjoint2->axis, axis, 3);
-    break;
+      // construct hinge around z = locaxis
+      pjoint2 = mjs_addJoint(pbody, 0);
+      mjs_setString(pjoint2->name, (jntname + "_RZ").c_str());
+      pjoint2->type = mjJNT_HINGE;
+      mjuu_setvec(pjoint2->pos, 0, 0, 0);
+      mjuu_copyvec(pjoint2->axis, axis, 3);
+      break;
 
-  case 6:  // ball joint
-    pjoint = mjs_addJoint(pbody, 0);
-    mjs_setString(pjoint->name, jntname.c_str());
-    pjoint->type = mjJNT_BALL;
-    mjuu_setvec(pjoint->pos, 0, 0, 0);
-    mjuu_copyvec(pjoint->axis, axis, 3);
+    case 6: // ball joint
+      pjoint = mjs_addJoint(pbody, 0);
+      mjs_setString(pjoint->name, jntname.c_str());
+      pjoint->type = mjJNT_BALL;
+      mjuu_setvec(pjoint->pos, 0, 0, 0);
+      mjuu_copyvec(pjoint->axis, axis, 3);
   }
 
   // dynamics element
@@ -546,7 +546,7 @@ mjsGeom* mjXURDF::Geom(XMLElement* geom_elem, mjsBody* pbody, bool collision) {
   // box
   if ((temp = FindSubElem(elem, "box"))) {
     ReadAttr(temp, "size", 3, pgeom->size, text, true, true);
-    for (int i=0; i<3; i++) {
+    for (int i=0; i < 3; i++) {
       pgeom->size[i] /= 2;  // MuJoCo uses half-length
     }
   }
@@ -673,7 +673,7 @@ void mjXURDF::Origin(XMLElement* origin_elem, double* pos, double* quat) {
 
 // find body with given name in list, return -1 if not found
 int mjXURDF::FindName(std::string name, std::vector<std::string>& list) {
-  for (unsigned int i=0; i<list.size(); i++)
+  for (unsigned int i=0; i < list.size(); i++)
     if (list[i] == name) {
       return i;
     }
@@ -686,7 +686,7 @@ int mjXURDF::FindName(std::string name, std::vector<std::string>& list) {
 // add name to list, error if name already exists
 void mjXURDF::AddName(std::string name, std::vector<std::string>& list) {
   // make sure name is unique
-  if (FindName(name, list)>=0) {
+  if (FindName(name, list) >= 0) {
     throw mjXError(0, "repeated URDF name: ", name.c_str());
   }
 
@@ -713,7 +713,7 @@ void mjXURDF::AddBody(std::string name) {
 void mjXURDF::AddToTree(int n) {
   // get pointer to parent in mjCModel tree
   mjsBody *parent = 0, *child = 0, *world = 0;
-  if (urParent[n]>=0) {
+  if (urParent[n] >= 0) {
     world = mjs_findBody(spec, "world");
     parent = mjs_findChild(world, urName[urParent[n]].c_str());
 
@@ -731,7 +731,7 @@ void mjXURDF::AddToTree(int n) {
   }
 
   // add children recursively
-  for (int i=0; i<(int)urChildren[n].size(); i++) {
+  for (int i=0; i < (int)urChildren[n].size(); i++) {
     AddToTree(urChildren[n][i]);
   }
 }
diff --git a/src/xml/xml_util.cc b/src/xml/xml_util.cc
index cd2fe3ed..5e7f52bc 100644
--- a/src/xml/xml_util.cc
+++ b/src/xml/xml_util.cc
@@ -112,7 +112,7 @@ FilePath ResolveFilePath(XMLElement* e, const FilePath& filename,
 
 // error string copy
 void mjCopyError(char* dst, const char* src, int maxlen) {
-  if (dst && maxlen>0) {
+  if (dst && maxlen > 0) {
     strncpy(dst, src, maxlen);
     dst[maxlen-1] = 0;
   }
@@ -243,7 +243,7 @@ std::string mjXSchema::GetError() {
 
 // print spaces
 static void printspace(std::stringstream& str, int n, const char* space) {
-  for (int i=0; i<n; i++) {
+  for (int i=0; i < n; i++) {
     str << space;
   }
 }
@@ -259,14 +259,14 @@ void mjXSchema::Print(std::stringstream& str, int level) const {
   printspace(str, 3*level, " ");
   str << name1 << " (" << type_ << ")";
   int baselen = 3*level + (int)name1.size() + 4;
-  if (baselen<30) {
+  if (baselen < 30) {
     printspace(str, 30-baselen, " ");
   }
 
   // attributes
   int cnt = std::max(baselen, 30);
   for (const std::string& attr : attr_) {
-    if (cnt>60) {
+    if (cnt > 60) {
       str << "\n";
       printspace(str, (cnt = std::max(30, baselen)), " ");
     }
@@ -290,7 +290,7 @@ void mjXSchema::PrintHTML(std::stringstream& str, int level, bool pad) const {
   std::string name1 = (name_ == "body" ? "(world)body" : name_);
 
   // open table
-  if (level==0) {
+  if (level == 0) {
     str << "<table border=\"1\">\n";
   }
 
@@ -341,9 +341,9 @@ bool mjXSchema::NameMatch(XMLElement* elem, int level) {
   // special handling of body, worldbody, and frame
   if (name_ == "body" &&
       ((level == 1 && !strcmp(elem->Value(), "worldbody")) ||
-      (level != 1 && !strcmp(elem->Value(), "body")) ||
-      (level >= 1 && !strcmp(elem->Value(), "frame")) ||
-      (level >= 1 && !strcmp(elem->Value(), "replicate")))) {
+       (level != 1 && !strcmp(elem->Value(), "body")) ||
+       (level >= 1 && !strcmp(elem->Value(), "frame")) ||
+       (level >= 1 && !strcmp(elem->Value(), "replicate")))) {
     return true;
   }
 
@@ -426,23 +426,23 @@ XMLElement* mjXSchema::Check(XMLElement* elem, int level) {
   msg[0] = '\0';
   for (mjXSchema& subschema : subschema_) {
     switch (subschema.type_) {
-    case '!':
-      if (subschema.refcnt_ > 1)
-        mju::sprintf_arr(msg, "unique element '%s' found %d times",
-                         subschema.name_.c_str(), subschema.refcnt_);
-      else if (subschema.refcnt_ < 1)
-        mju::sprintf_arr(msg, "element '%s' is required",
-                         subschema.name_.c_str());
-      break;
+      case '!':
+        if (subschema.refcnt_ > 1)
+          mju::sprintf_arr(msg, "unique element '%s' found %d times",
+                           subschema.name_.c_str(), subschema.refcnt_);
+        else if (subschema.refcnt_ < 1)
+          mju::sprintf_arr(msg, "element '%s' is required",
+                           subschema.name_.c_str());
+        break;
 
-    case '?':
-      if (subschema.refcnt_ > 1)
-        mju::sprintf_arr(msg, "unique element '%s' found %d times",
-                         subschema.name_.c_str(), subschema.refcnt_);
-      break;
+      case '?':
+        if (subschema.refcnt_ > 1)
+          mju::sprintf_arr(msg, "unique element '%s' found %d times",
+                           subschema.name_.c_str(), subschema.refcnt_);
+        break;
 
-    default:
-      break;
+      default:
+        break;
     }
   }
 
@@ -539,7 +539,7 @@ template bool mjXUtil::SameVector(const unsigned char* vec1, const unsigned char
 
 // find string in map, return corresponding integer (-1: not found)
 int mjXUtil::FindKey(const mjMap* map, int mapsz, std::string key) {
-  for (int i=0; i<mapsz; i++) {
+  for (int i=0; i < mapsz; i++) {
     if (map[i].key == key) {
       return map[i].value;
     }
@@ -552,7 +552,7 @@ int mjXUtil::FindKey(const mjMap* map, int mapsz, std::string key) {
 
 // find integer in map, return corresponding string ("": not found)
 std::string mjXUtil::FindValue(const mjMap* map, int mapsz, int value) {
-  for (int i=0; i<mapsz; i++) {
+  for (int i=0; i < mapsz; i++) {
     if (map[i].value == value) {
       return map[i].key;
     }
@@ -565,8 +565,8 @@ std::string mjXUtil::FindValue(const mjMap* map, int mapsz, int value) {
 
 // if attribute is present, return vector of numerical data
 template<typename T>
-std::optional<std::vector<T>> mjXUtil::ReadAttrVec(XMLElement* elem, const char* attr,
-                                                   bool required) {
+std::optional<std::vector<T> > mjXUtil::ReadAttrVec(XMLElement* elem, const char* attr,
+                                                    bool required) {
   std::vector<T> v;
   const char* raw_cstr = elem->Attribute(attr);
   if (raw_cstr) {
@@ -593,13 +593,13 @@ std::optional<std::vector<T>> mjXUtil::ReadAttrVec(XMLElement* elem, const char*
   return v;
 }
 
-template std::optional<std::vector<double>>
+template std::optional<std::vector<double> >
 mjXUtil::ReadAttrVec(XMLElement* elem, const char* attr, bool required);
-template std::optional<std::vector<float>>
+template std::optional<std::vector<float> >
 mjXUtil::ReadAttrVec(XMLElement* elem, const char* attr, bool required);
-template std::optional<std::vector<int>>
+template std::optional<std::vector<int> >
 mjXUtil::ReadAttrVec(XMLElement* elem, const char* attr, bool required);
-template std::optional<std::vector<unsigned char>>
+template std::optional<std::vector<unsigned char> >
 mjXUtil::ReadAttrVec(XMLElement* elem, const char* attr, bool required);
 
 
@@ -751,10 +751,10 @@ bool mjXUtil::ReadAttrInt(XMLElement* elem, const char* attr, int* data, bool re
 void mjXUtil::Vector2String(std::string& txt, const std::vector<float>& vec, int ncol) {
   std::stringstream strm;
 
-  for (size_t i=0; i<vec.size(); i++) {
+  for (size_t i=0; i < vec.size(); i++) {
     if (ncol && (i % ncol) == 0) {
       strm << "\n            ";
-    } else if (i>0) {
+    } else if (i > 0) {
       strm << " ";
     }
     strm << vec[i];
@@ -839,7 +839,7 @@ void mjXUtil::WriteAttr(XMLElement* elem, std::string name, int n, const T* data
                         bool trim) {
   // make sure all are defined
   if constexpr (std::is_floating_point_v<T>) {
-    for (int i=0; i<n; i++) {
+    for (int i=0; i < n; i++) {
       if (std::isnan(data[i])) {
         return;
       }
@@ -863,9 +863,9 @@ void mjXUtil::WriteAttr(XMLElement* elem, std::string name, int n, const T* data
   stream.precision(mujoco::_mjPRIVATE__get_xml_precision());
 
   // process all numbers
-  for (int i=0; i<n; i++) {
+  for (int i=0; i < n; i++) {
     // add space between numbers
-    if (i>0) {
+    if (i > 0) {
       stream << " ";
     }
 
@@ -901,7 +901,7 @@ template void mjXUtil::WriteAttr(XMLElement* elem, std::string name, int n,
 void mjXUtil::WriteVector(XMLElement* elem, std::string name, const std::vector<double>& vec) {
   // proceed only if non-zero found
   bool ok = false;
-  for (size_t i=0; i<vec.size(); i++) {
+  for (size_t i=0; i < vec.size(); i++) {
     if (vec[i]) {
       ok = true;
       break;
@@ -921,8 +921,8 @@ void mjXUtil::WriteVector(XMLElement* elem, std::string name, const std::vector<
                           const std::vector<double>& def) {
   // proceed only if non-zero found
   bool ok = false;
-  for (size_t i=0; i<vec.size(); i++) {
-    if (vec[i]!=def[i]) {
+  for (size_t i=0; i < vec.size(); i++) {
+    if (vec[i] != def[i]) {
       ok = true;
       break;
     }
@@ -952,7 +952,7 @@ void mjXUtil::WriteAttrTxt(XMLElement* elem, std::string name, std::string value
 // write attribute- single int
 void mjXUtil::WriteAttrInt(XMLElement* elem, std::string name, int data, int def) {
   // skip default
-  if (data==def) {
+  if (data == def) {
     return;
   }
 
@@ -965,7 +965,7 @@ void mjXUtil::WriteAttrInt(XMLElement* elem, std::string name, int data, int def
 void mjXUtil::WriteAttrKey(XMLElement* elem, std::string name,
                            const mjMap* map, int mapsz, int data, int def) {
   // skip default
-  if (data==def) {
+  if (data == def) {
     return;
   }