diff --git a/doc/index.rst b/doc/index.rst
index d803f114..84852306 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -13,4 +13,5 @@
    XMLreference
    programming
    APIreference
+   unity
    changelog
diff --git a/doc/unity.rst b/doc/unity.rst
new file mode 100644
index 00000000..09c45bdb
--- /dev/null
+++ b/doc/unity.rst
@@ -0,0 +1,333 @@
+=============
+Unity Plug-in
+=============
+
+Introduction
+------------
+
+The MuJoCo `Unity plug-in <https://github.com/deepmind/mujoco/tree/main/unity>`_ allows the Unity Editor and runtime to use the MuJoCo physics engine.  Users can import MJCF
+files and edit the models in the Editor.  The plug-in relies on Unity for most aspects -- assets, game logic, simulation
+time -- but uses MuJoCo to determine how objects move, giving the designer access to MuJoCo's full API.
+
+.. _UInstallation:
+
+Installation instructions
+-------------------------
+
+The plug-in directory (available at https://github.com/deepmind/mujoco/tree/main/unity) includes a ``package.json``
+file.  Unity's package manager recognizes this file and will import the plug-in's C# codebase to your project.  In
+addition, Unity also needs the native MuJoCo library, which can be found in the specific platfomr archive at
+https://github.com/deepmind/mujoco/release.
+
+On Unity version 2020.2 and later, the Package Manager will look for the native library file and copy it to the package
+directory when the package is imported. Alternatively, you can manually copy the native library to the package directory
+and rename it, see platform-specific instructions below. The library can also be copied into any location under your
+project's Assets directory.
+
+MacOS
+_____
+
+The MuJoCo app needs to be run at least once before the native library can be used, in order to register the library as
+a trusted binary. Then, copy the dynamic library file from
+``/Applications/MuJoCo.app/Contents/Frameworks/MuJoCo.framework/Versions/Current/libmujoco.2.1.1.dylib`` (it can be
+found by browsing the contents of ``MuJoCo.app``) and rename it as ``mujoco.dylib``.
+
+Linux
+_____
+
+Expand the ``tar.gz`` archive to ``~/.mujoco``. Then copy the dynamic library from
+``~/.mujoco/mujoco-2.1.1/lib/libmujoco_nogl.so.2.1.1`` (note the ``_nogl`` suffix) and rename it as ``libmujoco.so``.
+
+Windows
+_______
+
+Expand the ``zip`` archive to a directory called ``MuJoCo`` in your user directory, and copy the file
+``MuJoCo\bin\mujoco.dll``.
+
+.. _UUsing:
+
+Using the plug-in
+-----------------
+
+.. _UImporter:
+
+Importer
+________
+
+The importer is invoked from the Editor's *Asset* menu: click on "Import MuJoCo Scene" and select the XML file with your
+model's MJCF specification.
+
+Context menus
+_____________
+
+- Right-clicking a geom component offers two options:
+
+  - "Add mesh renderer" adds components to the same game object that render the geom: a standard ``MeshRenderer`` and a
+    ``MjMeshFilter`` that creates a procedural mesh that is recreated when the geom shape properties change.
+  - "Convert to free object" adds two new game objects: a parent with an ``MjBody`` component and a sibling with an
+    ``MjFreeJoint`` component.  This allows the previously static geom to move about freely in the scene. This action
+    only applies to "world" geoms -- those that do not currently have an ``MjBody`` parent.
+
+- Right-clicking a Unity Collider offers the option to "Add a matching MuJoCo geom" to the same game object.  Note that
+  this does not comprise a complete conversion of the physics -- Rigidbody, ArticulationBody and Joint configurations
+  still need to be recreated manually.
+
+Mouse spring
+____________
+
+When the selected game object has an ``MjBody`` component, spring forces can be applied to this body towards the mouse
+cursor through a control-left-drag action in the Scene view.  The 3D position of the spring force origin is found by
+projecting the mouse position on a plane defined by the camera X direction and the world Y direction.  Adding the shift
+key changes the projection plane to be parallel to the world's X and Z axes.
+
+.. _UTips:
+
+Tips to Unity users
+___________________
+
+- If any compilation or runtime errors are encountered, the state of the system is undefined.  Therefore, we recommend
+  turning on “Error Pause” in the console window.
+- In PhysX, every `Rigidbody` is a “free body”.  In contrast, MuJoCo requires explicit specification of joints for
+  mobility. For convenience, we provide a context menu for “freeing” a world geom (i.e., an ``MjGeom`` component without
+  any ``MjBody`` ancestor) by adding a parent ``MjBody`` and a sibling ``MjFreeJoint``.
+- The plug-in doesn’t support collision detection without physical presence, so there is no built-in notion of trigger
+  colliders.  The presence or absence of a contact force can be read by adding a touch sensor and reading its
+  ``SensorReading`` value (which will correspond to the normal force, see `touch sensor documentation <sensor-touch>`).
+
+.. _UDesign:
+
+Design principles
+-----------------
+
+The plug-in design provides a one-to-one mapping between MJCF elements and Unity components.  In order to simulate a
+Unity scene (e.g., when the user hits the “play” button in the Editor) using MuJoCo, the plug-in:
+
+1. Scans the GameObject hierarchy in the scene for MuJoCo components.
+2. Creates an MJCF description and passes it to MuJoCo’s compiler.
+3. Binds every component to the MuJoCo runtime via the corresponding index in MuJoCo’s data structures. This index is
+   used for updating Unity’s transforms during simulation.
+
+This design principle has several implications:
+
+- Most fields of the Unity components correspond directly to MJCF attributes. Therefore, the user can refer to the
+  MuJoCo documentation for details on the semantics of different values.
+- The layout of MuJoCo components in the GameObject hierarchy determines the layout of the resulting MuJoCo model.
+  Therefore, we adopt a design rule that **every game object must have at most one MuJoCo component**.
+- We rely on Unity for spatial configuration, which requires vector components to be `swizzled
+  <https://en.wikipedia.org/wiki/Swizzling_(computer_graphics)>`_ since Unity uses left-handed frames with Y as the
+  vertical axis, while MuJoCo uses right-handed frames with Z as the vertical axis.
+- Unity transform scaling affects positions, orientations, and scale of the entire game object subtree.  However, MuJoCo
+  doesn’t support collision of skewed cylinders and capsules (skewed spheres are supported via the ellipsoid primitive).
+  The gizmo for geoms and sites ignores this skew (similarly to PhysX colliders), and will always show the primitive
+  shape as it will appear to the physics.
+- During runtime, changing values of component fields will not trigger scene recreation, so it will have no immediate
+  effect on the physics.  However, the new values will be loaded upon the next scene recreation.
+
+Wherever possible, we do things the Unity Way: gravity is read from Unity’s physics settings, and the simulation step is
+read from Unity’s Time Manager’s `Fixed Timestep`.  All aspects of appearance (e.g., meshes, materials, and textures)
+are handled by Unity’s Asset Manager, and RGBA specifications are done using material assets.
+
+.. _UNotes:
+
+Implementation notes
+--------------------
+
+Importer workflow
+_________________
+
+When the user selects an MJCF file, the importer first loads
+the file in MuJoCo, saves it to a temporary location, and then processes the generated saved file.  This has several
+effects:
+
+- It validates the MJCF - we are guaranteed that the saved MJCF matches the `schema <CSchema>`_.
+- It validates the assets (materials, meshes, textures) and imports these assets into Unity, as well as creating new
+  material assets for geom RGBA specification.
+- It allows the importer to handle :ref:`\<include\> <include>` elements without replicating MuJoCo’s file-system
+  workflow.
+- The current version of MuJoCo generates MJCF files with explicit :ref:`\<inertial\> <inertial>` elements, even when
+  the original model uses geoms for implicit definition of the body inertia.  If you plan to change geom properties of
+  an imported model, remove these auto-generated ``MjInertial`` components manually.  We plan to address this in a
+  future release of MuJoCo.
+
+In Unity, there is no equivalent to MJCF’s “cascading” :ref:`\<default\> <default>` clauses.  Therefore, components in
+Unity reflect the corresponding elements’ state after applying all the relevant default classes, and the class structure
+in the original MJCF is discarded.
+
+The MuJoCo Scene
+________________
+
+When a MuJoCo scene is created, the ``MjScene`` component first scans the scene for all instances of ``MjComponent``.
+Each component creates its own MJCF element using Unity scene’s spatial structure to describe the model’s initial
+reference pose (called ``qpos0`` in MuJoCo).  ``MjScene`` combines these XML elements according to the hierarchy of the
+respective game objects and creates a single MJCF description of the physics model. It then creates the runtime structs
+``mjModel`` and ``mjData``, and binds each component to the runtime by identifying its unique index.
+
+During runtime, ``MjScene.FixedUpdate()`` calls :ref:`mj_step`, and then synchronizes the state of each game object
+according to the index ``MjComponent.MujocoId`` identified at binding time.  An ``MjScene`` component is added
+automatically when the application starts (e.g., when the user hits “play”) if and only if the scene includes any MuJoCo
+components. If your application’s initialization phase involves ticking the physics while adding game objects and
+components, you can call ``MjScene.CreateScene()`` when the initialization phase is over.
+
+Scene recreation maintains continuity of physics and state in the following way:
+
+1. The position and velocity of joints is cached.
+2. MuJoCo’s state is reset (to ``qpos0``) and Unity transforms are synchronized.
+3. A new XML is generated, creating a model that has the same ``qpos0`` as the previous one for the joints that
+   persisted.
+4. The MuJoCo state (for the joints that persisted) is set from the cache, and Unity transforms are synchronized.
+
+Because the MuJoCo library doesn’t (yet) expose an API for scene editing, adding and removing MuJoCo components causes
+complete scene recreation.  This can be expensive for large models or if it happens frequently.  We expect this
+performance limitation to be lifted in future versions of MuJoCo.
+
+Global Settings
+_______________
+
+An exception to the one-element-per-one-component is the Global Settings component.  This component is responsible for
+all the configuration options that are included in the fixed-size, singleton, global elements of MJCF.  Currently it
+holds information that corresponds to the :ref:`\<option\> <option>` and :ref:`\<size\> <size>` elements, and in the
+future it will also be used for the :ref:`\<compiler\> <compiler>` element, if/when fields there will be relevant to the
+Unity plug-in.
+
+Invoking the importer at application runtime
+____________________________________________
+
+The importer is implemented by the class ``MjImporterWithAssets``, which is a subclass of ``MjcfImporter``.  This parent
+class takes an MJCF string and generates the hierarchy of components.  It can be invoked at play-time (it doesn’t
+involve Editor functionality), and it doesn’t invoke any functions of the MuJoCo library.  This is useful when MuJoCo
+models are generated procedurally (e.g., by some evolutionary process) and/or when an MJCF is imported only to be
+converted (e.g., to PhysX, or URDF).  Since it cannot interact with Unity’s ``AssetManager`` (which is a feature of the
+Editor), this class’s functionality is restricted.  Specifically:
+
+- It ignores all assets (including collision meshes).
+- It ignores visuals (including RGBA specifications).
+
+MuJoCo sensor components
+________________________
+
+MuJoCo defines many sensors, and we were concerned that creating a separate ``MjComponent`` class for each would lead to
+a lot of code duplication.  Therefore, we created classes according to the type of object (actuator / body / geom /
+joint / site) whose properties are measured, and the type (scalar / vector / quaternion) of the measured data.
+
+Here’s a table that maps types to sensors:
+
++------------------------+---------------+---------------------+
+| **Mujoco Object Type** | **Data Type** | **Sensor Name**     |
++------------------------+---------------+---------------------+
+| Actuator               | Scalar        | - ``actuatorpos``   |
+|                        |               | - ``actuatorvel``   |
+|                        |               | - ``actuatorfrc``   |
++------------------------+---------------+---------------------+
+| Body                   | Vector        | - ``subtreecom``    |
+|                        |               | - ``subtreelinvel`` |
+|                        |               | - ``subtreeangmom`` |
+|                        |               | - ``framepos``      |
+|                        |               | - ``framexaxis``    |
+|                        |               | - ``frameyaxis``    |
+|                        |               | - ``framezaxis``    |
+|                        |               | - ``framelinvel``   |
+|                        |               | - ``frameangvel``   |
+|                        |               | - ``framelinacc``   |
+|                        |               | - ``frameangacc``   |
++------------------------+---------------+---------------------+
+| Body                   | Quaternion    | - ``framequat``     |
++------------------------+---------------+---------------------+
+| Geom                   | Vector        | - ``framepos``      |
+|                        |               | - ``framexaxis``    |
+|                        |               | - ``frameyaxis``    |
+|                        |               | - ``framezaxis``    |
+|                        |               | - ``framelinvel``   |
+|                        |               | - ``frameangvel``   |
+|                        |               | - ``framelinacc``   |
+|                        |               | - ``frameangacc``   |
++------------------------+---------------+---------------------+
+| Geom                   | Quaternion    | - ``framequat``     |
++------------------------+---------------+---------------------+
+| Joint                  | Scalar        | - ``jointpos``      |
+|                        |               | - ``jointvel``      |
+|                        |               | - ``jointlimitpos`` |
+|                        |               | - ``jointlimitvel`` |
+|                        |               | - ``jointlimitfrc`` |
++------------------------+---------------+---------------------+
+| Site                   | Scalar        | - ``touch``         |
+|                        |               | - ``rangefinder``   |
++------------------------+---------------+---------------------+
+| Site                   | Vector        | - ``accelerometer`` |
+|                        |               | - ``velocimeter``   |
+|                        |               | - ``force``         |
+|                        |               | - ``torque``        |
+|                        |               | - ``gyro``          |
+|                        |               | - ``magnetometer``  |
+|                        |               | - ``framepos``      |
+|                        |               | - ``framexaxis``    |
+|                        |               | - ``frameyaxis``    |
+|                        |               | - ``framezaxis``    |
+|                        |               | - ``framelinvel``   |
+|                        |               | - ``frameangvel``   |
+|                        |               | - ``framelinacc``   |
+|                        |               | - ``frameangacc``   |
++------------------------+---------------+---------------------+
+| Site                   | Quaternion    | - ``framequat``     |
++------------------------+---------------+---------------------+
+
+Here’s the same table in reverse, mapping sensors to classes:
+
+================= ===================================
+Sensor Name       Plugin Class
+================= ===================================
+``accelerometer`` SiteVector
+``actuatorfrc``   ActuatorScalar
+``actuatorpos``   ActuatorScalar
+``actuatorvel``   ActuatorScalar
+``force``         SiteVector
+``frameangacc``   \*Vector (depends on frame type)
+``frameangvel``   \*Vector (depends on frame type)
+``framelinacc``   \*Vector (depends on frame type)
+``framelinvel``   \*Vector (depends on frame type)
+``framepos``      \*Vector (depends on frame type)
+``framequat``     \*Quaternion (depends on frame type)
+``framexaxis``    \*Vector (depends on frame type)
+``frameyaxis``    \*Vector (depends on frame type)
+``framezaxis``    \*Vector (depends on frame type)
+``gyro``          SiteVector
+``jointlimitfrc`` JointScalar
+``jointlimitpos`` JointScalar
+``jointlimitvel`` JointScalar
+``jointpos``      JointScalar
+``jointvel``      JointScalar
+``magnetometer``  SiteVector
+``subtreeangmom`` BodyVector
+``subtreecom``    BodyVector
+``subtreelinvel`` BodyVector
+``torque``        SiteVector
+``touch``         SiteScalar
+``velocimeter``   SiteVector
+================= ===================================
+
+The following sensors are not yet implemented:
+
+| ``tendonpos``
+| ``tendonvel``
+| ``ballquat``
+| ``ballangvel``
+| ``tendonlimitpos``
+| ``tendonlimitvel``
+| ``tendonlimitfrc``
+| ``user``
+
+Mesh Shapes
+___________
+
+The plug-in allows using arbitrary Unity meshes for MuJoCo collision.  At model compilation, MuJoCo calls `qhull
+<http://www.qhull.org/>`__ to create a convex hull of the mesh, and uses that for collisions.  Currently the computed
+convex hull is not visible in Unity, but we intend to expose it in future versions.
+
+Interaction with External Processes
+___________________________________
+
+Roboti’s `MuJoCo plug-in for Unity <https://roboti.us/download.html>`_ steps the simulation in an external Python
+process, and uses Unity only for rendering.  In contrast, our plug-in relies on Unity to step the simulation. It should
+be possible to use our plug-in while an external process "drives" the simulation, for example by seting ``qpos``,
+calling ``mj_kinematics``, synchronizing the transforms, and then using Unity to render or compute game logic. In order
+to establish communication with an external process, you can use Unity's `ML-Agents
+<https://github.com/Unity-Technologies/ml-agents>`_ package.
\ No newline at end of file
diff --git a/model/humanoid100/humanoid100.xml b/model/humanoid100/humanoid100.xml
index e9d58763..42be52e7 100644
--- a/model/humanoid100/humanoid100.xml
+++ b/model/humanoid100/humanoid100.xml
@@ -56,7 +56,8 @@
              rgb1="0.6 0.6 0.6" rgb2="0.6 0.6 0.6" markrgb="1 1 1"/>
     <texture name="texplane" type="2d" builtin="checker" rgb1=".4 .4 .4" rgb2=".6 .6 .6"
              width="512" height="512"/>
-    <material name='MatPlane' reflectance='0.3' texture="texplane" texrepeat="1 1" texuniform="true"/>
+    <material name='MatPlane' reflectance='0.3' texture="texplane" texrepeat="1 1" texuniform="true"
+              rgba=".7 .7 .7 1"/>
     <material name='object1' texture="texgeom" texuniform="true" rgba=".4 .9 .6 1" />
     <material name='object2' texture="texgeom" texuniform="true" rgba=".4 .6 .9 1" />
     <material name='object3' texture="texgeom" texuniform="true" rgba=".4 .9 .9 1" />
@@ -73,7 +74,7 @@
 
   <worldbody>
     <light directional="true" diffuse=".8 .8 .8" pos="0 0 10" dir="0 0 -10"/>
-    <geom pos="0 0 0" type="plane" size="3 3 .5" rgba=".7 .7 .7 1" material="MatPlane"/>
+    <geom pos="0 0 0" type="plane" size="3 3 .5" material="MatPlane"/>
     <geom class="border" fromto="-3 3 0 3 3 0"  />
     <geom class="border" fromto="-3 -3 0 3 -3 0"  />
     <geom class="border" fromto="3 3 0 3 -3 0"  />
diff --git a/unity/CHANGELOG.md b/unity/CHANGELOG.md
new file mode 100644
index 00000000..eb15814b
--- /dev/null
+++ b/unity/CHANGELOG.md
@@ -0,0 +1,5 @@
+# Changelog
+
+## [2.1.1] - 2022-02-02
+
+### Initial release
diff --git a/unity/CHANGELOG.md.meta b/unity/CHANGELOG.md.meta
new file mode 100644
index 00000000..fb2c1a48
--- /dev/null
+++ b/unity/CHANGELOG.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e0f2a83d7d240967bb5945d478c8b7f5
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor.meta b/unity/Editor.meta
new file mode 100644
index 00000000..bf7f3c68
--- /dev/null
+++ b/unity/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 19efbd5e1b0bbc43b9f6a3defa20bb80
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components.meta b/unity/Editor/Components.meta
new file mode 100644
index 00000000..79165ea8
--- /dev/null
+++ b/unity/Editor/Components.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f5a5ea2338a298b5e94d5f5653c0b85b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components/AbsoluteValuePropertyEditor.cs b/unity/Editor/Components/AbsoluteValuePropertyEditor.cs
new file mode 100644
index 00000000..f7bf0f46
--- /dev/null
+++ b/unity/Editor/Components/AbsoluteValuePropertyEditor.cs
@@ -0,0 +1,26 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [CustomPropertyDrawer(typeof(AbsoluteValueAttribute))]
+  public class AbsoluteValuePropertyDrawer : PropertyDrawer {
+    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) {
+      property.floatValue = Mathf.Abs(EditorGUI.FloatField(position, label, property.floatValue));
+    }
+  }
+}
diff --git a/unity/Editor/Components/AbsoluteValuePropertyEditor.cs.meta b/unity/Editor/Components/AbsoluteValuePropertyEditor.cs.meta
new file mode 100644
index 00000000..1c40834c
--- /dev/null
+++ b/unity/Editor/Components/AbsoluteValuePropertyEditor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ac61b66fbbd264beebb1df6cd423d122
+timeCreated: 1538126279
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components/MjActuatorEditor.cs b/unity/Editor/Components/MjActuatorEditor.cs
new file mode 100644
index 00000000..9ac963cc
--- /dev/null
+++ b/unity/Editor/Components/MjActuatorEditor.cs
@@ -0,0 +1,199 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [CustomEditor(typeof(MjActuator))]
+  [CanEditMultipleObjects]
+  public class MjActuatorEditor : Editor {
+    private bool _showCustomParams = false;
+    private bool _showDebugValues = false;
+    private bool _showDynPrm = false;
+    private bool _showGainPrm = false;
+    private bool _showBiasValues = false;
+
+    // General actuator properties.
+    private SerializedProperty _dynType;
+    private SerializedProperty _gainType;
+    private SerializedProperty _biasType;
+    private SerializedProperty _dynPrm;
+    private SerializedProperty _gainPrm;
+    private SerializedProperty _biasPrm;
+    // Position actuator properties.
+    private SerializedProperty _kp;
+    // Velocity actuator properties.
+    private SerializedProperty _kv;
+    // Cylinder actuator properties.
+    private SerializedProperty _cylinderTimeConst;
+    private SerializedProperty _area;
+    private SerializedProperty _diameter;
+    private SerializedProperty _bias;
+    // Cylinder actuator properties.
+    private SerializedProperty _muscleTimeConst;
+    private SerializedProperty _range;
+    private SerializedProperty _force;
+    private SerializedProperty _scale;
+    private SerializedProperty _lmin;
+    private SerializedProperty _lmax;
+    private SerializedProperty _vmax;
+    private SerializedProperty _fpmax;
+    private SerializedProperty _fvmax;
+
+    public void OnEnable() {
+      _showCustomParams = false;
+      _showDebugValues = false;
+      _showDynPrm = false;
+      _showGainPrm = false;
+      _showBiasValues = false;
+
+      var customParams = serializedObject.FindProperty("CustomParams");
+      // General actuator properties.
+      _dynType = customParams.FindPropertyRelative("DynType");
+      _gainType = customParams.FindPropertyRelative("GainType");
+      _biasType = customParams.FindPropertyRelative("BiasType");
+      _dynPrm = customParams.FindPropertyRelative("DynPrm");
+      _gainPrm = customParams.FindPropertyRelative("GainPrm");
+      _biasPrm = customParams.FindPropertyRelative("BiasPrm");
+      // Position actuator properties.
+      _kp = customParams.FindPropertyRelative("Kp");
+      // Velocity actuator properties.
+      _kv = customParams.FindPropertyRelative("Kv");
+      // Cylinder actuator properties.
+      _cylinderTimeConst = customParams.FindPropertyRelative("CylinderTimeConst");
+      _area = customParams.FindPropertyRelative("Area");
+      _diameter = customParams.FindPropertyRelative("Diameter");
+      _bias = customParams.FindPropertyRelative("Bias");
+      // Cylinder actuator properties.
+      _muscleTimeConst = customParams.FindPropertyRelative("MuscleTimeConst");
+      _range = customParams.FindPropertyRelative("Range");
+      _force = customParams.FindPropertyRelative("Force");
+      _scale = customParams.FindPropertyRelative("Scale");
+      _lmin = customParams.FindPropertyRelative("LMin");
+      _lmax = customParams.FindPropertyRelative("LMax");
+      _vmax = customParams.FindPropertyRelative("VMax");
+      _fpmax = customParams.FindPropertyRelative("FpMax");
+      _fvmax = customParams.FindPropertyRelative("FvMax");
+    }
+
+    public override void OnInspectorGUI() {
+      serializedObject.Update();
+      foreach (var target in serializedObject.targetObjects) {
+        EditActuator(target as MjActuator);
+      }
+      serializedObject.ApplyModifiedProperties();
+    }
+
+    private void EditActuator(MjActuator actuator) {
+      DrawDefaultInspector();
+      _showCustomParams = EditorGUILayout.Foldout(_showCustomParams, "Custom Params");
+      if (_showCustomParams) {
+        EditCustomParams(actuator.Type, actuator.CustomParams);
+      }
+      _showDebugValues = EditorGUILayout.Foldout(_showDebugValues, "Debug");
+      if (_showDebugValues) {
+        using (new EditorGUI.DisabledScope(true)) {
+          EditorGUILayout.FloatField("Length", actuator.Length);
+          EditorGUILayout.FloatField("Velocity", actuator.Velocity);
+          EditorGUILayout.FloatField("Force", actuator.Force);
+        }
+      }
+    }
+
+    private void EditCustomParams(MjActuator.ActuatorType type,
+                                  MjActuator.CustomParameters parameters) {
+      switch (type) {
+        case MjActuator.ActuatorType.General: {
+          EditGeneralParams(parameters);
+          break;
+        }
+        case MjActuator.ActuatorType.Position: {
+          EditPositionParams(parameters);
+          break;
+        }
+        case MjActuator.ActuatorType.Velocity: {
+          EditVelocityParams(parameters);
+          break;
+        }
+        case MjActuator.ActuatorType.Cylinder: {
+          EditCylinderParams(parameters);
+          break;
+        }
+        case MjActuator.ActuatorType.Muscle: {
+          EditMuscleParams(parameters);
+          break;
+        }
+      }
+    }
+
+    private void EditGeneralParams(MjActuator.CustomParameters parameters) {
+      EditorGUILayout.PropertyField(_dynType);
+      EditorGUILayout.PropertyField(_gainType);
+      EditorGUILayout.PropertyField(_biasType);
+
+      _showDynPrm = EditorGUILayout.Foldout(_showDynPrm, "DynPrm");
+      if (_showDynPrm) {
+        for (var i = 0; i < parameters.DynPrm.Count; ++i) {
+          EditorGUILayout.PropertyField(_dynPrm.GetArrayElementAtIndex(i));
+        }
+      }
+      _showGainPrm = EditorGUILayout.Foldout(_showGainPrm, "GainPrm");
+      if (_showGainPrm) {
+        for (var i = 0; i < parameters.GainPrm.Count; ++i) {
+          EditorGUILayout.PropertyField(_gainPrm.GetArrayElementAtIndex(i));
+        }
+      }
+      _showBiasValues = EditorGUILayout.Foldout(_showBiasValues, "BiasPrm");
+      if (_showBiasValues) {
+        for (var i = 0; i < parameters.BiasPrm.Count; ++i) {
+          EditorGUILayout.PropertyField(_biasPrm.GetArrayElementAtIndex(i));
+        }
+      }
+    }
+
+    private void EditPositionParams(MjActuator.CustomParameters parameters) {
+      EditorGUILayout.PropertyField(_kp);
+    }
+
+    private void EditVelocityParams(MjActuator.CustomParameters parameters) {
+      EditorGUILayout.PropertyField(_kv);
+    }
+
+    private void EditCylinderParams(MjActuator.CustomParameters parameters) {
+      EditorGUILayout.PropertyField(_cylinderTimeConst);
+      EditorGUILayout.PropertyField(_area);
+      EditorGUILayout.PropertyField(_diameter);
+      _showBiasValues = EditorGUILayout.Foldout(_showBiasValues, "Bias");
+      if (_showBiasValues) {
+        for (var i = 0; i < parameters.Bias.Length; ++i) {
+          EditorGUILayout.PropertyField(_bias.GetArrayElementAtIndex(i));
+        }
+      }
+    }
+
+    private void EditMuscleParams(MjActuator.CustomParameters parameters) {
+      EditorGUILayout.PropertyField(_muscleTimeConst, new GUIContent("TimeConst"));
+      EditorGUILayout.PropertyField(_range);
+      EditorGUILayout.PropertyField(_force);
+      EditorGUILayout.PropertyField(_scale);
+      EditorGUILayout.PropertyField(_lmin);
+      EditorGUILayout.PropertyField(_lmax);
+      EditorGUILayout.PropertyField(_vmax);
+      EditorGUILayout.PropertyField(_fpmax);
+      EditorGUILayout.PropertyField(_fvmax);
+    }
+  }
+}
diff --git a/unity/Editor/Components/MjActuatorEditor.cs.meta b/unity/Editor/Components/MjActuatorEditor.cs.meta
new file mode 100644
index 00000000..aef00262
--- /dev/null
+++ b/unity/Editor/Components/MjActuatorEditor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 76f90e10df489475490b387a53dd88da
+timeCreated: 1547050687
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components/MjGeomEditor.cs b/unity/Editor/Components/MjGeomEditor.cs
new file mode 100644
index 00000000..72695c0c
--- /dev/null
+++ b/unity/Editor/Components/MjGeomEditor.cs
@@ -0,0 +1,77 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Mujoco {
+
+[CustomEditor(typeof(MjGeom), true)]
+[CanEditMultipleObjects]
+public class MjGeomEditor : MjShapeComponentEditor {
+  public override void OnInspectorGUI() {
+    serializedObject.Update();
+    EditorGUILayout.PropertyField(serializedObject.FindProperty("Mass"));
+    EditorGUILayout.PropertyField(serializedObject.FindProperty("Density"));
+    serializedObject.ApplyModifiedProperties();
+    base.OnInspectorGUI();
+  }
+
+  [MenuItem("CONTEXT/MjGeom/Add mesh renderer")]
+  private static void AddMeshComponents(MenuCommand menuCommand) {
+    var geom = menuCommand.context as MjGeom;
+    geom.gameObject.AddComponent<MjMeshFilter>();
+    geom.gameObject.AddComponent<MeshRenderer>().material = new Material(Shader.Find("Diffuse"));
+  }
+
+  [MenuItem("CONTEXT/MjGeom/Convert to free object")]
+  private static void ConvertToFreeObject(MenuCommand menuCommand) {
+    var geom = menuCommand.context as MjGeom;
+    if (geom.GetComponentInParent<MjBody>()) {
+      Debug.LogError("This geom already has a Body parent.", geom.GetComponentInParent<MjBody>());
+      return;
+    }
+    var parent = new GameObject(geom.gameObject.name + " Body").transform;
+    var root = geom.transform.root;
+    if (root != geom.transform) {
+      parent.parent = geom.transform.parent;
+    }
+    parent.gameObject.AddComponent<MjBody>();
+    var joint = new GameObject("Free Joint").AddComponent<MjFreeJoint>();
+    joint.transform.parent = parent;
+    geom.transform.parent = parent;
+  }
+
+  [MenuItem("CONTEXT/Collider/Add a matching MuJoCo geom")]
+  private static void AddMatchingGeom(MenuCommand menuCommand) {
+    var collider = menuCommand.context as Collider;
+    collider.enabled = false;
+    var geom = collider.gameObject.AddComponent<MjGeom>();
+    if (collider as BoxCollider) {
+      geom.ShapeType = MjShapeComponent.ShapeTypes.Box;
+    } else if (collider as SphereCollider) {
+      geom.ShapeType = MjShapeComponent.ShapeTypes.Sphere;
+    } else if (collider as CapsuleCollider) {
+      geom.ShapeType = MjShapeComponent.ShapeTypes.Capsule;
+    } else if (collider as MeshCollider) {
+      geom.ShapeType = MjShapeComponent.ShapeTypes.Mesh;
+      ((MjMeshShape)geom.Shape).Mesh = ((MeshCollider)collider).sharedMesh;
+    } else {
+      Debug.LogError("Collider type not supported yet.", collider);
+      collider.enabled = true;
+      GameObject.DestroyImmediate(geom);
+    }
+  }
+}
+}
diff --git a/unity/Editor/Components/MjGeomEditor.cs.meta b/unity/Editor/Components/MjGeomEditor.cs.meta
new file mode 100644
index 00000000..980d42d0
--- /dev/null
+++ b/unity/Editor/Components/MjGeomEditor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: d5409b149ad694715a57f4dc8bb7a857
+timeCreated: 1552041114
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components/MjHandles.cs b/unity/Editor/Components/MjHandles.cs
new file mode 100644
index 00000000..79ecbc45
--- /dev/null
+++ b/unity/Editor/Components/MjHandles.cs
@@ -0,0 +1,58 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.AnimatedValues;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public static class MjHandles {
+
+    // Renders a visualization of an axis, anchored at the specified world space origin.
+    //
+    // Args:
+    //   origin: World space coordinates of the anchoring point for the visualization.
+    //   direction: Axis direction.
+    public static void Axis(Vector3 origin, Vector3 direction) {
+      var size = HandleUtility.GetHandleSize(origin) * 0.3f;
+      var axisEnd = origin + direction * size;
+      var capRotation = Quaternion.LookRotation(direction);
+      Handles.DrawLine(origin, axisEnd);
+      Handles.ConeHandleCap(0, axisEnd, capRotation, size, EventType.Repaint);
+    }
+
+    // Renders a visualization of linear (translational) limits, anchored at the specified world
+    // space origin.
+    //
+    // Args:
+    //   origin: World space coordinates of the anchoring point for the visualization.
+    //   lower: Distance from the origin below, where the limit expires.
+    //   upper: Distance from the origin above, where the limit expires.
+    //   axis: Axis along which the limit works.
+    public static void LinearLimits(Vector3 origin, float lower, float upper, Vector3 axis) {
+      if (upper > lower) {
+        var discRadius = HandleUtility.GetHandleSize(origin) * 0.7f;
+        var startPosition = origin + axis * lower;
+        var endPosition = origin + axis * upper;
+        Handles.DrawSolidDisc(startPosition, axis, discRadius);
+        Handles.DrawSolidDisc(endPosition, axis, discRadius);
+        Handles.DrawLine(origin, endPosition);
+      }
+    }
+  }
+}
diff --git a/unity/Editor/Components/MjHandles.cs.meta b/unity/Editor/Components/MjHandles.cs.meta
new file mode 100644
index 00000000..55df2552
--- /dev/null
+++ b/unity/Editor/Components/MjHandles.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 1a810c29762134ebb9bbee3903172764
+timeCreated: 1537794456
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components/MjHingeJointEditor.cs b/unity/Editor/Components/MjHingeJointEditor.cs
new file mode 100644
index 00000000..d60fc351
--- /dev/null
+++ b/unity/Editor/Components/MjHingeJointEditor.cs
@@ -0,0 +1,41 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.AnimatedValues;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [CustomEditor(typeof(MjHingeJoint))]
+  public class MjHingeJointEditor : Editor {
+    private MjHingeJoint _joint;
+
+    protected virtual void OnEnable() {
+      _joint = (MjHingeJoint)target;
+    }
+
+    protected virtual void OnSceneGUI() {
+      DrawHandles(_joint);
+    }
+
+    public static void DrawHandles(MjHingeJoint joint) {
+      Handles.color = Color.yellow;
+      MjHandles.Axis(joint.transform.position, joint.RotationAxis);
+    }
+  }
+}
diff --git a/unity/Editor/Components/MjHingeJointEditor.cs.meta b/unity/Editor/Components/MjHingeJointEditor.cs.meta
new file mode 100644
index 00000000..1211b823
--- /dev/null
+++ b/unity/Editor/Components/MjHingeJointEditor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: bdaa159fcf7064108aed2229bc39ac0d
+timeCreated: 1537794793
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components/MjMouseSpring.cs b/unity/Editor/Components/MjMouseSpring.cs
new file mode 100644
index 00000000..9bdd118b
--- /dev/null
+++ b/unity/Editor/Components/MjMouseSpring.cs
@@ -0,0 +1,176 @@
+#if UNITY_EDITOR
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mujoco {
+
+  // During play mode, in the scene view, with a MjBody component selected, holding down control
+  // and left mouse drag will apply a force on the body.  Holding shift down will change the applied
+  // force direction between World XZ plane and Y[camera-up].
+
+  [CustomEditor(typeof(MjBody))]
+  public class MjMouseSpring : Editor {
+    private bool _lastShiftKeyState = false;
+
+    private Plane _mouseDragPlane;
+    private Vector3 _mouseDragCurrentPoint = Vector3.negativeInfinity;
+
+    private Color _translucentRed = new Color(1, 0, 0, 0.1f);
+
+    public void OnDisable() {
+      // If we're still the hot control at this stage, we need to release.
+      int uniqueID = GUIUtility.GetControlID(FocusType.Passive);
+      if (GUIUtility.hotControl == uniqueID) {
+        GUIUtility.hotControl = 0;
+      }
+    }
+
+    private void SetDragOriginAndDragPlane(Vector3 planeOrigin, Vector3 normal) {
+      normal[1] = 0;
+      normal = _lastShiftKeyState ? Vector3.up : normal;
+      _mouseDragPlane.SetNormalAndPosition(normal, planeOrigin);
+    }
+
+    private void UpdatePositionOnDragPlane(Vector3 mousePosition) {
+      float rayDist;
+      Ray ray = HandleUtility.GUIPointToWorldRay(mousePosition);
+
+      if (_mouseDragPlane.Raycast(ray, out rayDist)) {
+        _mouseDragCurrentPoint = ray.GetPoint(rayDist);
+      }
+    }
+
+    private void DrawMouseSpringGui(Vector3 bodyPosition, Vector3 direction, Camera renderCamera) {
+      // Update and draw the drag indicator.
+      var rot = Quaternion.FromToRotation(Vector3.up, direction);
+
+      // Backup defaults.
+      var backupColour = Handles.color;
+
+      // Update the drag plane indicator disc and outline...
+      var discRadius = (_mouseDragCurrentPoint - bodyPosition).magnitude;
+
+      Handles.color = Color.red;
+      Handles.DrawWireDisc(bodyPosition, _mouseDragPlane.normal, discRadius);
+      Handles.color = _translucentRed;
+      Handles.DrawSolidDisc(bodyPosition, _mouseDragPlane.normal, discRadius);
+
+      // ...and give it a phat poly line to show the drag anchor origin.
+      Handles.color = Color.white;
+      Handles.DrawAAPolyLine(6, new Vector3[] { bodyPosition, _mouseDragCurrentPoint });
+
+      // Restore defaults.
+      Handles.color = backupColour;
+    }
+
+    public unsafe void OnSceneGUI() {
+      if (!Application.isPlaying) {
+        return;
+      }
+
+      var currentEvent = UnityEngine.Event.current;
+
+      // Cache the hot control to determine whether we're currently capturing mouse input.
+      int uniqueID = GUIUtility.GetControlID(FocusType.Passive);
+
+      // Mouse spring is active if the control key is held down and the user is dragging the
+      // left mouse button, or if we're already in the process of capturing mouse input.
+      bool mouseSpringActive = GUIUtility.hotControl == uniqueID;
+      bool mouseSpringStarting = currentEvent.control && currentEvent.button == 0;
+      if (!mouseSpringStarting && !mouseSpringActive) {
+        return;
+      }
+
+      var sceneCamera = SceneView.currentDrawingSceneView?.camera;
+      if (sceneCamera == null) {
+        Debug.LogError("SceneView.currentDrawingSceneView is null");
+        return;
+      }
+
+      MjBody body = target as MjBody;
+      Vector3 bodyPosition =
+          body != null ? body.transform.position : Vector3.zero;
+      var scene = MjScene.Instance;
+
+      switch (currentEvent.type) {
+        case EventType.MouseDown:
+          if (EditorWindow.mouseOverWindow == UnityEditor.EditorWindow.GetWindow<SceneView>()) {
+            // The mouse was pressed in the scene view, so start capturing all mouse input until
+            // the mouse button's released.
+            GUIUtility.hotControl = uniqueID;
+
+            _lastShiftKeyState = false;
+            SetDragOriginAndDragPlane(bodyPosition, -sceneCamera.transform.forward);
+
+            currentEvent.Use();
+          }
+          return;
+
+        case EventType.MouseDrag:
+          if (mouseSpringActive) {
+            // We're currently capturing all mouse input, so consume the event.
+            GUIUtility.hotControl = uniqueID;
+            currentEvent.Use();
+          }
+          return;
+
+        case EventType.MouseUp:
+          if (mouseSpringActive) {
+            // We're still capturing all mouse input so consume the event, but we can release our
+            // control over capturing input now as the mouse button's been released.
+            GUIUtility.hotControl = 0;
+            currentEvent.Use();
+            // as opposed to unity's addforce, xfrc_applied is persistent
+            scene.Data->xfrc_applied[6*body.MujocoId + 0] = 0;
+            scene.Data->xfrc_applied[6*body.MujocoId + 1] = 0;
+            scene.Data->xfrc_applied[6*body.MujocoId + 2] = 0;
+          }
+          return;
+
+        case EventType.Repaint: {
+          if (mouseSpringActive) {
+
+            if (currentEvent.shift != _lastShiftKeyState) {
+              _lastShiftKeyState = currentEvent.shift;
+              SetDragOriginAndDragPlane(bodyPosition, -sceneCamera.transform.forward);
+            }
+
+            // Raycast towards the drag plane to update _mouseDragCurrentPoint.
+            UpdatePositionOnDragPlane(currentEvent.mousePosition);
+
+            Vector3 bodyVel = Vector3.one;
+            double[] mjBodyVel = new double[6];
+            fixed (double* res = mjBodyVel) {
+              MujocoLib.mj_objectVelocity(
+                  scene.Model, scene.Data, (int)MujocoLib.mjtObj.mjOBJ_BODY, body.MujocoId, res, 0);
+              // linear velocity is in the last 3 entries
+              bodyVel = MjEngineTool.UnityVector3(res, 1);
+            }
+
+            float springStiffness = 100;
+            var settings = MjGlobalSettings.Instance;
+            if (settings) {
+              springStiffness = settings.MouseSpringStiffness;
+            }
+
+            Vector3 delta = _mouseDragCurrentPoint - bodyPosition;
+            float mass = 1.0f / (float)scene.Model->body_invweight0[2*body.MujocoId];
+            Vector3 unityForce = delta * springStiffness * mass;
+            unityForce -= bodyVel * Mathf.Sqrt(springStiffness) * mass;
+            Vector3 mjForce = MjEngineTool.MjVector3(unityForce);
+            scene.Data->xfrc_applied[6*body.MujocoId + 0] = mjForce.x;
+            scene.Data->xfrc_applied[6*body.MujocoId + 1] = mjForce.y;
+            scene.Data->xfrc_applied[6*body.MujocoId + 2] = mjForce.z;
+
+            // Draw and immediately force a repaint.
+            DrawMouseSpringGui(body.transform.position, delta, sceneCamera);
+            SceneView.RepaintAll();
+          }
+          return;
+        }
+      }
+    }
+  }
+}
+#endif
diff --git a/unity/Editor/Components/MjMouseSpring.cs.meta b/unity/Editor/Components/MjMouseSpring.cs.meta
new file mode 100644
index 00000000..a3262668
--- /dev/null
+++ b/unity/Editor/Components/MjMouseSpring.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6c4ae8cbdd0cac0a387364d88408d932
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components/MjShapeComponentEditor.cs b/unity/Editor/Components/MjShapeComponentEditor.cs
new file mode 100644
index 00000000..41b8ba22
--- /dev/null
+++ b/unity/Editor/Components/MjShapeComponentEditor.cs
@@ -0,0 +1,38 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mujoco {
+
+[CustomEditor(typeof(MjShapeComponent), true)]
+[CanEditMultipleObjects]
+public class MjShapeComponentEditor : Editor {
+
+  public override void OnInspectorGUI() {
+
+    serializedObject.Update();
+    var shapeType = serializedObject.FindProperty("ShapeType");
+    EditorGUILayout.PropertyField(shapeType);
+    EditorGUILayout.PropertyField(
+        serializedObject.FindProperty($"{shapeType.enumDisplayNames[shapeType.enumValueIndex]}"),
+        includeChildren: true);
+    serializedObject.ApplyModifiedProperties();
+  }
+}
+}
diff --git a/unity/Editor/Components/MjShapeComponentEditor.cs.meta b/unity/Editor/Components/MjShapeComponentEditor.cs.meta
new file mode 100644
index 00000000..e4b4f82f
--- /dev/null
+++ b/unity/Editor/Components/MjShapeComponentEditor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 21af9fef28ac0899e982e791916b5fc5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Components/MjSlideJointEditor.cs b/unity/Editor/Components/MjSlideJointEditor.cs
new file mode 100644
index 00000000..9664db66
--- /dev/null
+++ b/unity/Editor/Components/MjSlideJointEditor.cs
@@ -0,0 +1,48 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.AnimatedValues;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [CustomEditor(typeof(MjSlideJoint))]
+  public class MjSlideJointEditor : Editor {
+    private MjSlideJoint _joint;
+
+    protected virtual void OnEnable() {
+      _joint = (MjSlideJoint)target;
+    }
+
+    protected virtual void OnSceneGUI() {
+      DrawHandles(_joint);
+    }
+
+    // Draw the handles for the slide joint.
+    public static void DrawHandles(MjSlideJoint joint) {
+      // Draw the handles.
+      if (joint.Settings.Solver.Limited) {
+        Handles.color = Color.blue;
+        MjHandles.LinearLimits(joint.transform.position, joint.RangeLower, joint.RangeUpper,
+                                   joint.SlideAxis);
+      }
+      Handles.color = Color.yellow;
+      MjHandles.Axis(joint.transform.position, joint.SlideAxis);
+    }
+  }
+}
diff --git a/unity/Editor/Components/MjSlideJointEditor.cs.meta b/unity/Editor/Components/MjSlideJointEditor.cs.meta
new file mode 100644
index 00000000..5b12b185
--- /dev/null
+++ b/unity/Editor/Components/MjSlideJointEditor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: bf7c14a263938456e9393a8d0fce7b9f
+timeCreated: 1538066332
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Importer.meta b/unity/Editor/Importer.meta
new file mode 100644
index 00000000..3a0596d9
--- /dev/null
+++ b/unity/Editor/Importer.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 974c7b5fe753877ebaa54ec26e113e1c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Importer/MjImporterEditorWindow.cs b/unity/Editor/Importer/MjImporterEditorWindow.cs
new file mode 100644
index 00000000..d84b5ec5
--- /dev/null
+++ b/unity/Editor/Importer/MjImporterEditorWindow.cs
@@ -0,0 +1,32 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Mujoco scenes importer window.
+public class MjImporterEditorWindow : EditorWindow {
+  [MenuItem("Assets/Import MuJoCo Scene")]
+  public static void Apply() {
+    string path = EditorUtility.OpenFilePanel("Select an MJCF model", "", "xml");
+    if (!string.IsNullOrEmpty(path)) {
+      var importer = new MjImporterWithAssets();
+      importer.ImportFile(path);
+    }
+  }
+}
+}
diff --git a/unity/Editor/Importer/MjImporterEditorWindow.cs.meta b/unity/Editor/Importer/MjImporterEditorWindow.cs.meta
new file mode 100644
index 00000000..a84b8d96
--- /dev/null
+++ b/unity/Editor/Importer/MjImporterEditorWindow.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 85ddf6116132e4c128ed82ac6034ce4a
+timeCreated: 1538581084
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Importer/MjImporterWithAssets.cs b/unity/Editor/Importer/MjImporterWithAssets.cs
new file mode 100644
index 00000000..6f3f8c61
--- /dev/null
+++ b/unity/Editor/Importer/MjImporterWithAssets.cs
@@ -0,0 +1,287 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Xml;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mujoco {
+
+// API for importing Mujoco XML files into Unity scenes.
+public class MjImporterWithAssets : MjcfImporter {
+
+  private const string _semiTransparentMaterialName = "mujoco_semitransparent_template";
+
+  private string _sourceMeshesDir;
+  private string _targetMeshesDir;
+  private string _targetAssetDir;
+  private unsafe MujocoLib.mjModel_* _mjModel = null;
+
+  // Imports the scene from the specified file, which should be a well-formed MJCF document.
+  // The imported scene will be placed under a single node with the requested name assigned.
+  //
+  // Args:
+  //   filePath: Path to XML file.
+  //
+  // Throws:
+  //   Exception if the parsed XML is malformed or contains rough errors. If an exception is thrown,
+  //   the entire imported scene will be automatically deleted.
+  // TODO(etom) - reconsider unencouraged pattern of validation through exception side-effects.
+  public unsafe GameObject ImportFile(string filePath) {
+    // If MuJoCo can't parse the mjcfString, we abort the entire process.
+    // MjEngineTool.LoadModelFromString throws an exception when MuJoCo fails to parse the provided
+    // mjcfString.
+    var name = Path.GetFileNameWithoutExtension(filePath) + $"{UnityEngine.Random.Range(0,999)}";
+    string newPath = Path.Combine(Application.temporaryCachePath, $"{name}.xml");
+    _mjModel = MjEngineTool.LoadModelFromFile(filePath);
+    MjEngineTool.SaveModelToFile(newPath, _mjModel);
+    Debug.Log($"Imported MJCF loaded, saved to {newPath}");
+    string mjcfString = File.ReadAllText(newPath);
+    GameObject root = null;
+    try {
+      root = ImportString(mjcfString, name, filePath);
+    } finally {
+      MujocoLib.mj_deleteModel(_mjModel);
+    }
+    return root;
+  }
+
+  public GameObject ImportString(
+      string mjcfString, string name = null, string filePath = null) {
+    var mjcfXml = new XmlDocument();
+    mjcfXml.LoadXml(mjcfString);
+    // Determine the folder where the meshes are stored.
+    ConfigureMeshPath(filePath, name, mjcfXml);
+    GameObject sceneRoot = null;
+    try {
+      sceneRoot = ImportXml(mjcfXml, name);
+    } catch (Exception) {
+      // We consider any error as critical, and end the import process immediately, cleaning up
+      // any assets created.
+      AssetDatabase.DeleteAsset(_targetAssetDir);
+    }
+    return sceneRoot;
+  }
+
+  protected override void ParseRoot(GameObject parentObject, XmlElement parentNode) {
+
+    // This makes no references, and should be parsed first.
+    var assetNode = parentNode.SelectSingleNode("asset") as XmlElement;
+    if (assetNode != null) {
+      ParseAssets(assetNode);
+    }
+    base.ParseRoot(parentObject, parentNode);
+  }
+
+  protected override void ParseGeom(GameObject parentObject, XmlElement child) {
+    var gameObject = CreateGameObjectWithUniqueName<MjGeom>(parentObject, child);
+    gameObject.AddComponent<MjMeshFilter>();
+    var renderer = gameObject.AddComponent<MeshRenderer>();
+    ResolveOrCreateMaterial(renderer, child);
+  }
+
+  private void ConfigureMeshPath(string path, string projectName, XmlDocument mjcf) {
+    // Crate the mesh target directory.
+    _targetMeshesDir = Path.Combine(
+        Application.dataPath, "Local", "MjImports", projectName, "Resources");
+    _targetAssetDir = Path.Combine("Assets", "Local", "MjImports", projectName, "Resources");
+    if (!Directory.Exists(_targetMeshesDir)) {
+      Directory.CreateDirectory(_targetMeshesDir);
+    }
+    if (string.IsNullOrEmpty(path)) { // we're loading a string
+      return;
+    }
+    _sourceMeshesDir = Path.GetDirectoryName(path);
+    var compilerNode = mjcf.SelectSingleNode("/mujoco/compiler") as XmlElement;
+    if (compilerNode != null) {
+      // Parse the location of meshes
+      var relativeMeshDir = compilerNode.GetStringAttribute("meshdir", defaultValue: string.Empty);
+      _sourceMeshesDir = Path.Combine(_sourceMeshesDir, relativeMeshDir);
+    }
+    Debug.Log(
+        $"Meshes locations: source = {_sourceMeshesDir}, target = {_targetMeshesDir}");
+  }
+
+  private void ParseAssets(XmlElement parentNode) {
+    foreach (var child in parentNode.SelectNodes("descendant::mesh").OfType<XmlElement>()) {
+      _modifiers.ApplyModifiersToElement(child);
+      ParseMesh(child);
+    }
+    foreach (var child in parentNode.SelectNodes("descendant::material").OfType<XmlElement>()) {
+      _modifiers.ApplyModifiersToElement(child);
+      ParseMaterial(child);
+    }
+    AssetDatabase.SaveAssets();
+  }
+
+  private void ImportMeshFromModel(int meshIndex) {
+  }
+
+  // Using mesh assets involves:
+  // (1) Copying the asset to a Resources folder, and rescaling it during that operation.
+  // (2) Allowing Unity to parse it using a registered asset importer (STLMeshImporter).
+  // (3) Loading that asset as a Mesh resource when the referring geom is parsed.
+  //
+  // We're also using a dedicated folder to deploy the meshes that are being imported, so that the
+  // user can find all meshes loaded by importing a specific model.
+  private void ParseMesh(XmlElement parentNode) {
+    if (parentNode.HasAttribute("vertex")) {
+      throw new NotImplementedException("XML with explicit mesh info not supported yet.");
+    }
+    var fileName = parentNode.GetStringAttribute("file");
+    // If we want to use the element name as the asset name, we must sanitize it:
+    var unsanitizedAssetReferenceName =
+      parentNode.GetStringAttribute("name", defaultValue: string.Empty);
+    var assetReferenceName = MjEngineTool.Sanitize(unsanitizedAssetReferenceName);
+    var sourceFilePath = Path.Combine(_sourceMeshesDir, fileName);
+    var targetFilePath = Path.Combine(_targetMeshesDir, assetReferenceName + ".stl");
+    if (File.Exists(targetFilePath)) {
+      File.Delete(targetFilePath);
+    }
+    var scale = MjEngineTool.UnityVector3(
+        parentNode.GetVector3Attribute("scale", defaultValue: Vector3.one));
+    CopyMeshAndRescale(sourceFilePath, targetFilePath, scale);
+    var assetPath = Path.Combine(_targetAssetDir, assetReferenceName + ".stl");
+    // This asset path should be available because the MuJoCo compiler guarantees element names
+    // are unique, but check for completeness (and in case sanitizing the name broke uniqueness):
+    if (AssetDatabase.LoadMainAssetAtPath(assetPath) != null) {
+      throw new Exception(
+        $"Trying to import mesh {unsanitizedAssetReferenceName} but {assetPath} already exists.");
+    }
+    AssetDatabase.ImportAsset(assetPath);
+    var copiedMesh = AssetDatabase.LoadMainAssetAtPath(assetPath) as Mesh;
+    if (copiedMesh == null) {
+      throw new Exception($"Mesh {assetPath} was not imported.");
+    }
+    copiedMesh.RecalculateNormals();
+    copiedMesh.RecalculateTangents();
+    copiedMesh.RecalculateBounds();
+  }
+
+  private void CopyMeshAndRescale(
+      string sourceFilePath, string targetFilePath, Vector3 scale) {
+    var originalMeshBytes = File.ReadAllBytes(sourceFilePath);
+    var mesh = StlMeshParser.ParseBinary(originalMeshBytes, scale);
+    var rescaledMeshBytes = StlMeshParser.SerializeBinary(mesh);
+    File.WriteAllBytes(targetFilePath, rescaledMeshBytes);
+  }
+
+  private void ParseMaterial(XmlElement parentNode) {
+    var rgba = parentNode.GetFloatArrayAttribute(
+      "rgba", defaultValue: new float[] {1.0f, 1.0f, 1.0f, 1.0f});
+    var emission = parentNode.GetFloatAttribute("emission", defaultValue: 0.0f);
+    var reflectance = parentNode.GetFloatAttribute("reflectance", defaultValue: 0.0f);
+    var specular = parentNode.GetFloatAttribute("specular", defaultValue: 0.5f);
+    var shininess = parentNode.GetFloatAttribute("shininess", defaultValue: 0.5f);
+    var unsanitizedName = parentNode.GetStringAttribute("name", defaultValue: string.Empty);
+    var name = MjEngineTool.Sanitize(unsanitizedName);
+    var albedo = new Color(rgba[0], rgba[1], rgba[2], rgba[3]);
+
+    // Mujoco uses a Blinn/Phong shading model with the addition of reflectance. Unfortunately, at
+    // the moment of writing this comment, Unity does not come with a compatible shader. The closest
+    // results can be achieved using the Standard shader that implements the Cook-Torrence shading
+    // model.
+    Material material;
+    if (rgba[3] < 1f) {
+      material = new Material(AssetDatabase.LoadMainAssetAtPath(
+        AssetDatabase.GUIDToAssetPath(
+          AssetDatabase.FindAssets(_semiTransparentMaterialName)[0])) as Material);
+    } else {
+      material = new Material(Shader.Find("Standard"));
+    }
+    material.SetColor("_Color", albedo);
+    material.SetFloat("_Metallic", reflectance);
+
+    // In order to convert the specular/shininess parameters into glossiness/roughness,
+    // we perform a coarse approximation.
+    // In Blinn/Phong model, Shininess corresponds to the width of the specular spot, while
+    // the Specularity corresponds to its strength (how visible it is). In order to approximate it
+    // with a single parameter Glossiness, we will assume that the largest value wins. The model
+    // will break at the extremes (Spec~=1 & Shin~=0, Spec~=0 & Shin~=1), however it should be
+    // representative for the intermediate values.
+    float glossiness = Math.Max(specular, shininess);
+    // We observe that any reflective material is automatically glossy, by the property of not
+    // having rough surface that would scatter the incoming light.
+    // Instead of modifying the Shininess parameter however, we're dirrectly modifying
+    // the glossiness by bringing the value closer to the upper boundary.
+    glossiness = (1.0f - reflectance) * glossiness + reflectance;
+    material.SetFloat("_Glossiness", glossiness);
+
+    // We choose to define a simple emission model that only emits light, without scaling
+    // the brightness of the defined color. If the user requires, they should tweak the material
+    // settings manually.
+    if (emission > 0.5f) {
+      material.EnableKeyword("_EMISSION");
+      material.SetColor("_EmissionColor", albedo);
+    }
+    var assetPath = Path.Combine(_targetAssetDir, name + ".mat");
+    if (AssetDatabase.LoadMainAssetAtPath(assetPath) != null) {
+      throw new Exception(
+        $"Trying to create material {unsanitizedName} but {assetPath} already exists.");
+    }
+    AssetDatabase.CreateAsset(material, assetPath);
+  }
+
+  // Loads a named material asset, or creates an ad-hoc material asset for the specific node.
+  private void ResolveOrCreateMaterial(MeshRenderer renderer, XmlElement parentNode) {
+    // When the asset was parsed and stored its name was sanitized, so we should load it using a
+    // sanitized name:
+    var materialName =
+      MjEngineTool.Sanitize(parentNode.GetStringAttribute("material", defaultValue: string.Empty));
+    Material material = null;
+    if (!string.IsNullOrEmpty(materialName)) {
+      var assetPath = Path.Combine(_targetAssetDir, materialName + ".mat");
+      material = (Material)AssetDatabase.LoadAssetAtPath(assetPath, typeof(Material));
+    } else {
+      // Nodes may contain inlined color definitions, which override the assigned material colors.
+      if (parentNode.HasAttribute("rgba")) {
+        // We need a bespoke copy of the material from the database for this particular node.
+        var rgba = parentNode.GetFloatArrayAttribute(
+          "rgba", defaultValue: new float[] {1.0f, 1.0f, 1.0f, 1.0f});
+        if (rgba[3] < 1f) {
+          material = new Material(
+            AssetDatabase.LoadMainAssetAtPath(
+              AssetDatabase.GUIDToAssetPath(
+                AssetDatabase.FindAssets(_semiTransparentMaterialName)[0])) as Material);
+        } else {
+          material = new Material(Shader.Find("Standard"));
+        }
+        material.color = new Color(rgba[0], rgba[1], rgba[2], rgba[3]);
+        // We use the geom's name, guaranteed to be unique, as the asset name.
+        // If geom is nameless, use a random number.
+        var name =
+          MjEngineTool.Sanitize(parentNode.GetStringAttribute(
+              "name", defaultValue: $"{UnityEngine.Random.Range(0, 1000000)}"));
+        var assetPath = Path.Combine(_targetAssetDir, name + ".mat");
+        if (AssetDatabase.LoadMainAssetAtPath(assetPath) != null) {
+          throw new Exception(
+            $"Creating a material asset for the geom {name}, but {assetPath} already exists.");
+        }
+        AssetDatabase.CreateAsset(material, assetPath);
+        AssetDatabase.SaveAssets();
+        material = AssetDatabase.LoadMainAssetAtPath(assetPath) as Material;
+      } else {
+        material = DefaultMujocoMaterial;
+      }
+    }
+    renderer.sharedMaterial = material;
+  }
+}
+}
diff --git a/unity/Editor/Importer/MjImporterWithAssets.cs.meta b/unity/Editor/Importer/MjImporterWithAssets.cs.meta
new file mode 100644
index 00000000..15ee8959
--- /dev/null
+++ b/unity/Editor/Importer/MjImporterWithAssets.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0115d33f9ea9249e78644b1fa5cd7765
+timeCreated: 1538581083
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Importer/StlMeshImporter.cs b/unity/Editor/Importer/StlMeshImporter.cs
new file mode 100644
index 00000000..ca5688e1
--- /dev/null
+++ b/unity/Editor/Importer/StlMeshImporter.cs
@@ -0,0 +1,36 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.IO;
+using System.Linq;
+using UnityEditor.AssetImporters;
+using UnityEngine;
+
+namespace Mujoco {
+// Importer for STL mesh files.
+[ScriptedImporter(version: 1, ext: "stl")]
+public class StlMeshImporter : ScriptedImporter {
+
+  public override void OnImportAsset(AssetImportContext ctx) {
+    var assetName = Path.GetFileNameWithoutExtension(ctx.assetPath);
+    var modelContents = File.ReadAllBytes(ctx.assetPath);
+
+    var mesh = StlMeshParser.ParseBinary(modelContents, Vector3.one);
+
+    ctx.AddObjectToAsset(assetName, mesh);
+    ctx.SetMainObject(mesh);
+  }
+}
+}
diff --git a/unity/Editor/Importer/StlMeshImporter.cs.meta b/unity/Editor/Importer/StlMeshImporter.cs.meta
new file mode 100644
index 00000000..ff1fcc64
--- /dev/null
+++ b/unity/Editor/Importer/StlMeshImporter.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9060c43f3694e454c873753ea0cc2f49
+timeCreated: 1550070047
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Importer/StlMeshParser.cs b/unity/Editor/Importer/StlMeshParser.cs
new file mode 100644
index 00000000..24452e1b
--- /dev/null
+++ b/unity/Editor/Importer/StlMeshParser.cs
@@ -0,0 +1,127 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEngine;
+
+namespace Mujoco {
+
+public static class BinaryReaderExtensions {
+  public static Vector3 ReadVector3(this BinaryReader reader) {
+    var x = reader.ReadSingle();
+    var y = reader.ReadSingle();
+    var z = reader.ReadSingle();
+    return new Vector3(x, y, z);
+  }
+}
+
+public static class BinaryWriterExtensions {
+  public static void Write(this BinaryWriter writer, Vector3 val) {
+    writer.Write(val.x);
+    writer.Write(val.y);
+    writer.Write(val.z);
+  }
+}
+
+public class StlMeshParser {
+
+  private const int _headerLength = 80;
+  private const int _attributesSizeLength = 2;
+  private const int _verticesPerTriangle = 3;
+  private const int _unityLimitNumVerticesPerMesh = 65535;
+  private const string _asciiFileTypeId = "solid";
+
+  private static Vector3 ToXZY(Vector3 v) => new Vector3(v.x, v.z, v.y);
+
+  // The binary STL format is described here: https://en.wikipedia.org/wiki/STL_(file_format)
+  public static Mesh ParseBinary(byte[] stlFileContents, Vector3 scale) {
+    var fileTypeId = System.Text.Encoding.UTF8.GetString(
+      stlFileContents.Take(_asciiFileTypeId.Length).ToArray());
+    if (fileTypeId == _asciiFileTypeId) {
+      throw new IOException("Ascii STL file format is not supported.");
+    }
+
+    using (var stream = new MemoryStream(stlFileContents)) {
+      using (var reader = new BinaryReader(stream)) {
+        reader.ReadBytes(_headerLength);
+        var numTriangles = reader.ReadUInt32();
+        var numVertices = numTriangles * _verticesPerTriangle;
+        if (numVertices > _unityLimitNumVerticesPerMesh) {
+          throw new IndexOutOfRangeException(
+              "The mesh exceeds the number of vertices per mesh allowed by Unity. " +
+              $"({numVertices} > {_unityLimitNumVerticesPerMesh})");
+        }
+        var triangleIndices = new List<int>(capacity: (int)numVertices);
+        var vertices = new List<Vector3>(capacity: (int)numVertices);
+        var normals = new List<Vector3>(capacity: (int)numVertices);
+        for (var i = 0; i < numVertices; i += _verticesPerTriangle) {
+          var triangleNormal = ToXZY(reader.ReadVector3());
+          normals.AddRange(new[] { triangleNormal, triangleNormal, triangleNormal });
+          vertices.AddRange(new[] {
+            ToXZY(reader.ReadVector3()),
+            ToXZY(reader.ReadVector3()),
+            ToXZY(reader.ReadVector3()) });
+          triangleIndices.AddRange(new[] {i, i + 2, i + 1});
+          reader.ReadInt16();  // Read the unused attribute indices field.
+        }
+
+        var mesh = new Mesh();
+        mesh.vertices = vertices.ToArray();
+        mesh.normals = normals.ToArray();
+        mesh.triangles = triangleIndices.ToArray();
+        mesh.vertices = mesh.vertices.Select(
+            vertexPosition => Vector3.Scale(vertexPosition, scale)).ToArray();
+        mesh.RecalculateNormals();
+        mesh.RecalculateTangents();
+        mesh.RecalculateBounds();
+        return mesh;
+      }
+    }
+  }
+
+  public static byte[] SerializeBinary(Mesh mesh) {
+    using (var stream = new MemoryStream()) {
+      using (var writer = new BinaryWriter(stream)) {
+        // Write the header. We only want to write the id and then pad the rest with zeros, up to 80
+        // bytes.
+        writer.Write(_asciiFileTypeId);
+        writer.Write(new byte[_headerLength - _asciiFileTypeId.Length - 1]);
+
+        var numTriangles = mesh.triangles.Length / 3;
+        writer.Write((int)numTriangles);
+
+        for (var i = 0; i < mesh.triangles.Length; i += _verticesPerTriangle) {
+          // STL format uses face normals, while Unity Meshes use vertex normals. We need to convert
+          // one into another by calculating a mean of vertex normals.
+          var i1 = mesh.triangles[i];
+          var i2 = mesh.triangles[i + 1];
+          var i3 = mesh.triangles[i + 2];
+          var faceNormal = (mesh.normals[i1] + mesh.normals[i2] + mesh.normals[i3]).normalized;
+          writer.Write(ToXZY(faceNormal));
+
+          writer.Write(ToXZY(mesh.vertices[i1]));
+          writer.Write(ToXZY(mesh.vertices[i3]));
+          writer.Write(ToXZY(mesh.vertices[i2]));
+
+          writer.Write((short)0);
+        }
+        return stream.GetBuffer();
+      }
+    }
+  }
+}
+}
diff --git a/unity/Editor/Importer/StlMeshParser.cs.meta b/unity/Editor/Importer/StlMeshParser.cs.meta
new file mode 100644
index 00000000..ac426f9d
--- /dev/null
+++ b/unity/Editor/Importer/StlMeshParser.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0d443565163aa4ddea5d910f3517ecfb
+timeCreated: 1550063597
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Editor/Mujoco.Editor.asmdef b/unity/Editor/Mujoco.Editor.asmdef
new file mode 100644
index 00000000..6b42677d
--- /dev/null
+++ b/unity/Editor/Mujoco.Editor.asmdef
@@ -0,0 +1,16 @@
+{
+    "name": "Mujoco.Editor",
+    "rootNamespace": "",
+    "references": [
+        "Mujoco"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/unity/Editor/Mujoco.Editor.asmdef.meta b/unity/Editor/Mujoco.Editor.asmdef.meta
new file mode 100644
index 00000000..0e72b6a2
--- /dev/null
+++ b/unity/Editor/Mujoco.Editor.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7bdf927c2041ed42ba41bdbbf914db24
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/README.md b/unity/README.md
new file mode 100644
index 00000000..c6f09fbb
--- /dev/null
+++ b/unity/README.md
@@ -0,0 +1,8 @@
+# Unity Plug-in
+
+The MuJoCo Unity plug-in allows the Unity Editor and runtime to use the MuJoCo
+physics engine.  Users can import MJCF files and edit the models in the Editor.
+The plug-in relies on Unity for most aspects -- assets, game logic, simulation
+time -- but uses MuJoCo to determine how objects move, giving the designer
+access to MuJoCo's full API.  See documentation and installation instructions
+[here](https://mujoco.readthedocs.io/en/latest/unity.html).
diff --git a/unity/README.md.meta b/unity/README.md.meta
new file mode 100644
index 00000000..ececfb55
--- /dev/null
+++ b/unity/README.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: aefae1ccbed1b0597a0ac21f37888aa3
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime.meta b/unity/Runtime.meta
new file mode 100644
index 00000000..9e8f6897
--- /dev/null
+++ b/unity/Runtime.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fa19c3a835699cca3a2b4f2aabbe14b7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Bindings.meta b/unity/Runtime/Bindings.meta
new file mode 100644
index 00000000..9a89e256
--- /dev/null
+++ b/unity/Runtime/Bindings.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 21aeeb2df019248c78e85014384bd21f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Bindings/FixedSizeIListHelper.cs b/unity/Runtime/Bindings/FixedSizeIListHelper.cs
new file mode 100644
index 00000000..1a5aacda
--- /dev/null
+++ b/unity/Runtime/Bindings/FixedSizeIListHelper.cs
@@ -0,0 +1,84 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Mujoco {
+  // An implementation of IList<T>, only missing the indexer and the count.
+  public abstract class FixedSizeIListHelper<T> : IList<T> {
+    public IEnumerator<T> GetEnumerator() {
+      for (int i = 0; i < this.Count; ++i) {
+        yield return this[i];
+      }
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() {
+      return GetEnumerator();
+    }
+
+    public void Add(T item) {
+      throw new NotSupportedException();
+    }
+
+    public void Clear() {
+      throw new NotSupportedException();
+    }
+
+    public bool Contains(T item) {
+      for (int i = 0; i < Count; ++i) {
+        if (this[i].Equals(item)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public void CopyTo(T[] array, int arrayIndex) {
+      for (int i = 0; i < Count; ++i) {
+        array[arrayIndex + i] = this[i];
+      }
+    }
+
+    public bool Remove(T item) {
+      throw new NotSupportedException();
+    }
+
+    public bool IsReadOnly => false;
+
+    public int IndexOf(T item) {
+      for (int i = 0; i < Count; ++i) {
+        if (this[i].Equals(item)) {
+          return i;
+        }
+      }
+      return -1;
+    }
+
+    public void Insert(int index, T item) {
+      throw new NotSupportedException();
+    }
+
+    public void RemoveAt(int index) {
+      throw new NotSupportedException();
+    }
+
+    public abstract int Count { get; }
+    public abstract T this[int index] {
+      get;
+      set;
+    }
+  }
+}
diff --git a/unity/Runtime/Bindings/FixedSizeIListHelper.cs.meta b/unity/Runtime/Bindings/FixedSizeIListHelper.cs.meta
new file mode 100644
index 00000000..8b43378e
--- /dev/null
+++ b/unity/Runtime/Bindings/FixedSizeIListHelper.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9015a95216e0843069042f712722cca6
+timeCreated: 1538057012
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Bindings/MujocoBinaryRetriever.cs b/unity/Runtime/Bindings/MujocoBinaryRetriever.cs
new file mode 100644
index 00000000..44c86057
--- /dev/null
+++ b/unity/Runtime/Bindings/MujocoBinaryRetriever.cs
@@ -0,0 +1,47 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEngine;
+
+namespace Mujoco {
+public class MujocoBinaryRetriever {
+
+  [InitializeOnLoadMethod]
+  static void SubscribeToEvent() {
+    // This causes the method to be invoked after the Editor registers the new list of packages.
+    Events.registeredPackages += RegisteredPackagesEventHandler;
+  }
+
+  static void RegisteredPackagesEventHandler(
+      PackageRegistrationEventArgs packageRegistrationEventArgs) {
+    var mujocoPath = packageRegistrationEventArgs.added[0].assetPath;
+    if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {
+      if (AssetDatabase.LoadMainAssetAtPath(mujocoPath + "/mujoco.dylib") == null) {
+        File.Copy(
+            "/Applications/MuJoCo.app/Contents/Frameworks" +
+            "/MuJoCo.framework/Versions/Current/libmujoco.2.1.1.dylib",
+            mujocoPath + "/mujoco.dylib");
+        AssetDatabase.Refresh();
+      }
+    } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {
+      if (AssetDatabase.LoadMainAssetAtPath(mujocoPath + "/libmujoco.so") == null) {
+        File.Copy(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) +
+            "/.mujoco/mujoco-2.1.1/lib/libmujoco_nogl.so.2.1.1",
+            mujocoPath + "/libmujoco.so");
+        AssetDatabase.Refresh();
+      }
+    } else {
+      if (AssetDatabase.LoadMainAssetAtPath(mujocoPath + "/mujoco.dll") == null) {
+        File.Copy(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) +
+            "\\MuJoCo\\bin\\mujoco.dll",
+            mujocoPath + "\\mujoco.dll");
+        AssetDatabase.Refresh();
+      }
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Bindings/MujocoBinaryRetriever.cs.meta b/unity/Runtime/Bindings/MujocoBinaryRetriever.cs.meta
new file mode 100644
index 00000000..7bc50919
--- /dev/null
+++ b/unity/Runtime/Bindings/MujocoBinaryRetriever.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3328869c60ca872129794f55c2d5bd05
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Bindings/MujocoBindings.cs b/unity/Runtime/Bindings/MujocoBindings.cs
new file mode 100644
index 00000000..3f096f96
--- /dev/null
+++ b/unity/Runtime/Bindings/MujocoBindings.cs
@@ -0,0 +1,3374 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Collections.Generic;
+using SizeDict = System.Collections.Generic.Dictionary<string, string[]>;
+using NestedDictionary = System.Collections.Generic.Dictionary<string, System.Collections.Generic.Dictionary<string, string[]>>;
+namespace Mujoco {
+public static class MujocoLib {
+
+// ----------------------------------Constants----------------------------------
+
+public const bool THIRD_PARTY_MUJOCO_MJDATA_H_ = true;
+public const bool THIRD_PARTY_MUJOCO_MJMODEL_H_ = true;
+public const bool mjUSEDOUBLE = true;
+public const double mjMINVAL = 1e-15;
+public const double mjPI = 3.141592653589793;
+public const double mjMAXVAL = 10000000000.0;
+public const double mjMINMU = 1e-05;
+public const double mjMINIMP = 0.0001;
+public const double mjMAXIMP = 0.9999;
+public const int mjMAXCONPAIR = 50;
+public const int mjMAXVFS = 2000;
+public const int mjMAXVFSNAME = 1000;
+public const int mjNEQDATA = 7;
+public const int mjNDYN = 10;
+public const int mjNGAIN = 10;
+public const int mjNBIAS = 10;
+public const int mjNREF = 2;
+public const int mjNIMP = 5;
+public const int mjNSOLVER = 1000;
+public const bool THIRD_PARTY_MUJOCO_MJRENDER_H_ = true;
+public const int mjNAUX = 10;
+public const int mjMAXTEXTURE = 1000;
+public const bool THIRD_PARTY_MUJOCO_MJUI_H_ = true;
+public const int mjMAXUISECT = 10;
+public const int mjMAXUIITEM = 80;
+public const int mjMAXUITEXT = 300;
+public const int mjMAXUINAME = 40;
+public const int mjMAXUIMULTI = 35;
+public const int mjMAXUIEDIT = 7;
+public const int mjMAXUIRECT = 25;
+public const int mjSEPCLOSED = 1000;
+public const int mjKEY_ESCAPE = 256;
+public const int mjKEY_ENTER = 257;
+public const int mjKEY_TAB = 258;
+public const int mjKEY_BACKSPACE = 259;
+public const int mjKEY_INSERT = 260;
+public const int mjKEY_DELETE = 261;
+public const int mjKEY_RIGHT = 262;
+public const int mjKEY_LEFT = 263;
+public const int mjKEY_DOWN = 264;
+public const int mjKEY_UP = 265;
+public const int mjKEY_PAGE_UP = 266;
+public const int mjKEY_PAGE_DOWN = 267;
+public const int mjKEY_HOME = 268;
+public const int mjKEY_END = 269;
+public const int mjKEY_F1 = 290;
+public const int mjKEY_F2 = 291;
+public const int mjKEY_F3 = 292;
+public const int mjKEY_F4 = 293;
+public const int mjKEY_F5 = 294;
+public const int mjKEY_F6 = 295;
+public const int mjKEY_F7 = 296;
+public const int mjKEY_F8 = 297;
+public const int mjKEY_F9 = 298;
+public const int mjKEY_F10 = 299;
+public const int mjKEY_F11 = 300;
+public const int mjKEY_F12 = 301;
+public const bool THIRD_PARTY_MUJOCO_MJVISUALIZE_H_ = true;
+public const int mjNGROUP = 6;
+public const int mjMAXOVERLAY = 500;
+public const int mjMAXLINE = 100;
+public const int mjMAXLINEPNT = 1000;
+public const int mjMAXPLANEGRID = 200;
+public const bool THIRD_PARTY_MUJOCO_MJXMACRO_H_ = true;
+public const bool THIRD_PARTY_MUJOCO_MUJOCO_H_ = true;
+public const int mjVERSION_HEADER = 211;
+public const bool THIRD_PARTY_MUJOCO_MUJOCO_EXPORT_H_ = true;
+public const bool MUJOCO_HELPER_DLL_LOCAL = true;
+public const bool MUJOCO_HELPER_DLL_IMPORT = true;
+public const bool MUJOCO_HELPER_DLL_EXPORT = true;
+public const bool MJAPI = true;
+public const bool MJLOCAL = true;
+
+
+// ------------------------------------Enums------------------------------------
+public enum mjtWarning : int{
+  mjWARN_INERTIA = 0,
+  mjWARN_CONTACTFULL = 1,
+  mjWARN_CNSTRFULL = 2,
+  mjWARN_VGEOMFULL = 3,
+  mjWARN_BADQPOS = 4,
+  mjWARN_BADQVEL = 5,
+  mjWARN_BADQACC = 6,
+  mjWARN_BADCTRL = 7,
+  mjNWARNING = 8,
+}
+public enum mjtTimer : int{
+  mjTIMER_STEP = 0,
+  mjTIMER_FORWARD = 1,
+  mjTIMER_INVERSE = 2,
+  mjTIMER_POSITION = 3,
+  mjTIMER_VELOCITY = 4,
+  mjTIMER_ACTUATION = 5,
+  mjTIMER_ACCELERATION = 6,
+  mjTIMER_CONSTRAINT = 7,
+  mjTIMER_POS_KINEMATICS = 8,
+  mjTIMER_POS_INERTIA = 9,
+  mjTIMER_POS_COLLISION = 10,
+  mjTIMER_POS_MAKE = 11,
+  mjTIMER_POS_PROJECT = 12,
+  mjNTIMER = 13,
+}
+public enum mjtDisableBit : int{
+  mjDSBL_CONSTRAINT = 1,
+  mjDSBL_EQUALITY = 2,
+  mjDSBL_FRICTIONLOSS = 4,
+  mjDSBL_LIMIT = 8,
+  mjDSBL_CONTACT = 16,
+  mjDSBL_PASSIVE = 32,
+  mjDSBL_GRAVITY = 64,
+  mjDSBL_CLAMPCTRL = 128,
+  mjDSBL_WARMSTART = 256,
+  mjDSBL_FILTERPARENT = 512,
+  mjDSBL_ACTUATION = 1024,
+  mjDSBL_REFSAFE = 2048,
+  mjNDISABLE = 12,
+}
+public enum mjtEnableBit : int{
+  mjENBL_OVERRIDE = 1,
+  mjENBL_ENERGY = 2,
+  mjENBL_FWDINV = 4,
+  mjENBL_SENSORNOISE = 8,
+  mjNENABLE = 4,
+}
+public enum mjtJoint : int{
+  mjJNT_FREE = 0,
+  mjJNT_BALL = 1,
+  mjJNT_SLIDE = 2,
+  mjJNT_HINGE = 3,
+}
+public enum mjtGeom : int{
+  mjGEOM_PLANE = 0,
+  mjGEOM_HFIELD = 1,
+  mjGEOM_SPHERE = 2,
+  mjGEOM_CAPSULE = 3,
+  mjGEOM_ELLIPSOID = 4,
+  mjGEOM_CYLINDER = 5,
+  mjGEOM_BOX = 6,
+  mjGEOM_MESH = 7,
+  mjNGEOMTYPES = 8,
+  mjGEOM_ARROW = 100,
+  mjGEOM_ARROW1 = 101,
+  mjGEOM_ARROW2 = 102,
+  mjGEOM_LINE = 103,
+  mjGEOM_SKIN = 104,
+  mjGEOM_LABEL = 105,
+  mjGEOM_NONE = 1001,
+}
+public enum mjtCamLight : int{
+  mjCAMLIGHT_FIXED = 0,
+  mjCAMLIGHT_TRACK = 1,
+  mjCAMLIGHT_TRACKCOM = 2,
+  mjCAMLIGHT_TARGETBODY = 3,
+  mjCAMLIGHT_TARGETBODYCOM = 4,
+}
+public enum mjtTexture : int{
+  mjTEXTURE_2D = 0,
+  mjTEXTURE_CUBE = 1,
+  mjTEXTURE_SKYBOX = 2,
+}
+public enum mjtIntegrator : int{
+  mjINT_EULER = 0,
+  mjINT_RK4 = 1,
+}
+public enum mjtCollision : int{
+  mjCOL_ALL = 0,
+  mjCOL_PAIR = 1,
+  mjCOL_DYNAMIC = 2,
+}
+public enum mjtCone : int{
+  mjCONE_PYRAMIDAL = 0,
+  mjCONE_ELLIPTIC = 1,
+}
+public enum mjtJacobian : int{
+  mjJAC_DENSE = 0,
+  mjJAC_SPARSE = 1,
+  mjJAC_AUTO = 2,
+}
+public enum mjtSolver : int{
+  mjSOL_PGS = 0,
+  mjSOL_CG = 1,
+  mjSOL_NEWTON = 2,
+}
+public enum mjtEq : int{
+  mjEQ_CONNECT = 0,
+  mjEQ_WELD = 1,
+  mjEQ_JOINT = 2,
+  mjEQ_TENDON = 3,
+  mjEQ_DISTANCE = 4,
+}
+public enum mjtWrap : int{
+  mjWRAP_NONE = 0,
+  mjWRAP_JOINT = 1,
+  mjWRAP_PULLEY = 2,
+  mjWRAP_SITE = 3,
+  mjWRAP_SPHERE = 4,
+  mjWRAP_CYLINDER = 5,
+}
+public enum mjtTrn : int{
+  mjTRN_JOINT = 0,
+  mjTRN_JOINTINPARENT = 1,
+  mjTRN_SLIDERCRANK = 2,
+  mjTRN_TENDON = 3,
+  mjTRN_SITE = 4,
+  mjTRN_UNDEFINED = 1000,
+}
+public enum mjtDyn : int{
+  mjDYN_NONE = 0,
+  mjDYN_INTEGRATOR = 1,
+  mjDYN_FILTER = 2,
+  mjDYN_MUSCLE = 3,
+  mjDYN_USER = 4,
+}
+public enum mjtGain : int{
+  mjGAIN_FIXED = 0,
+  mjGAIN_MUSCLE = 1,
+  mjGAIN_USER = 2,
+}
+public enum mjtBias : int{
+  mjBIAS_NONE = 0,
+  mjBIAS_AFFINE = 1,
+  mjBIAS_MUSCLE = 2,
+  mjBIAS_USER = 3,
+}
+public enum mjtObj : int{
+  mjOBJ_UNKNOWN = 0,
+  mjOBJ_BODY = 1,
+  mjOBJ_XBODY = 2,
+  mjOBJ_JOINT = 3,
+  mjOBJ_DOF = 4,
+  mjOBJ_GEOM = 5,
+  mjOBJ_SITE = 6,
+  mjOBJ_CAMERA = 7,
+  mjOBJ_LIGHT = 8,
+  mjOBJ_MESH = 9,
+  mjOBJ_SKIN = 10,
+  mjOBJ_HFIELD = 11,
+  mjOBJ_TEXTURE = 12,
+  mjOBJ_MATERIAL = 13,
+  mjOBJ_PAIR = 14,
+  mjOBJ_EXCLUDE = 15,
+  mjOBJ_EQUALITY = 16,
+  mjOBJ_TENDON = 17,
+  mjOBJ_ACTUATOR = 18,
+  mjOBJ_SENSOR = 19,
+  mjOBJ_NUMERIC = 20,
+  mjOBJ_TEXT = 21,
+  mjOBJ_TUPLE = 22,
+  mjOBJ_KEY = 23,
+}
+public enum mjtConstraint : int{
+  mjCNSTR_EQUALITY = 0,
+  mjCNSTR_FRICTION_DOF = 1,
+  mjCNSTR_FRICTION_TENDON = 2,
+  mjCNSTR_LIMIT_JOINT = 3,
+  mjCNSTR_LIMIT_TENDON = 4,
+  mjCNSTR_CONTACT_FRICTIONLESS = 5,
+  mjCNSTR_CONTACT_PYRAMIDAL = 6,
+  mjCNSTR_CONTACT_ELLIPTIC = 7,
+}
+public enum mjtConstraintState : int{
+  mjCNSTRSTATE_SATISFIED = 0,
+  mjCNSTRSTATE_QUADRATIC = 1,
+  mjCNSTRSTATE_LINEARNEG = 2,
+  mjCNSTRSTATE_LINEARPOS = 3,
+  mjCNSTRSTATE_CONE = 4,
+}
+public enum mjtSensor : int{
+  mjSENS_TOUCH = 0,
+  mjSENS_ACCELEROMETER = 1,
+  mjSENS_VELOCIMETER = 2,
+  mjSENS_GYRO = 3,
+  mjSENS_FORCE = 4,
+  mjSENS_TORQUE = 5,
+  mjSENS_MAGNETOMETER = 6,
+  mjSENS_RANGEFINDER = 7,
+  mjSENS_JOINTPOS = 8,
+  mjSENS_JOINTVEL = 9,
+  mjSENS_TENDONPOS = 10,
+  mjSENS_TENDONVEL = 11,
+  mjSENS_ACTUATORPOS = 12,
+  mjSENS_ACTUATORVEL = 13,
+  mjSENS_ACTUATORFRC = 14,
+  mjSENS_BALLQUAT = 15,
+  mjSENS_BALLANGVEL = 16,
+  mjSENS_JOINTLIMITPOS = 17,
+  mjSENS_JOINTLIMITVEL = 18,
+  mjSENS_JOINTLIMITFRC = 19,
+  mjSENS_TENDONLIMITPOS = 20,
+  mjSENS_TENDONLIMITVEL = 21,
+  mjSENS_TENDONLIMITFRC = 22,
+  mjSENS_FRAMEPOS = 23,
+  mjSENS_FRAMEQUAT = 24,
+  mjSENS_FRAMEXAXIS = 25,
+  mjSENS_FRAMEYAXIS = 26,
+  mjSENS_FRAMEZAXIS = 27,
+  mjSENS_FRAMELINVEL = 28,
+  mjSENS_FRAMEANGVEL = 29,
+  mjSENS_FRAMELINACC = 30,
+  mjSENS_FRAMEANGACC = 31,
+  mjSENS_SUBTREECOM = 32,
+  mjSENS_SUBTREELINVEL = 33,
+  mjSENS_SUBTREEANGMOM = 34,
+  mjSENS_USER = 35,
+}
+public enum mjtStage : int{
+  mjSTAGE_NONE = 0,
+  mjSTAGE_POS = 1,
+  mjSTAGE_VEL = 2,
+  mjSTAGE_ACC = 3,
+}
+public enum mjtDataType : int{
+  mjDATATYPE_REAL = 0,
+  mjDATATYPE_POSITIVE = 1,
+  mjDATATYPE_AXIS = 2,
+  mjDATATYPE_QUATERNION = 3,
+}
+public enum mjtLRMode : int{
+  mjLRMODE_NONE = 0,
+  mjLRMODE_MUSCLE = 1,
+  mjLRMODE_MUSCLEUSER = 2,
+  mjLRMODE_ALL = 3,
+}
+public enum mjtGridPos : int{
+  mjGRID_TOPLEFT = 0,
+  mjGRID_TOPRIGHT = 1,
+  mjGRID_BOTTOMLEFT = 2,
+  mjGRID_BOTTOMRIGHT = 3,
+}
+public enum mjtFramebuffer : int{
+  mjFB_WINDOW = 0,
+  mjFB_OFFSCREEN = 1,
+}
+public enum mjtFontScale : int{
+  mjFONTSCALE_50 = 50,
+  mjFONTSCALE_100 = 100,
+  mjFONTSCALE_150 = 150,
+  mjFONTSCALE_200 = 200,
+  mjFONTSCALE_250 = 250,
+  mjFONTSCALE_300 = 300,
+}
+public enum mjtFont : int{
+  mjFONT_NORMAL = 0,
+  mjFONT_SHADOW = 1,
+  mjFONT_BIG = 2,
+}
+public enum mjtButton : int{
+  mjBUTTON_NONE = 0,
+  mjBUTTON_LEFT = 1,
+  mjBUTTON_RIGHT = 2,
+  mjBUTTON_MIDDLE = 3,
+}
+public enum mjtEvent : int{
+  mjEVENT_NONE = 0,
+  mjEVENT_MOVE = 1,
+  mjEVENT_PRESS = 2,
+  mjEVENT_RELEASE = 3,
+  mjEVENT_SCROLL = 4,
+  mjEVENT_KEY = 5,
+  mjEVENT_RESIZE = 6,
+}
+public enum mjtCatBit : int{
+  mjCAT_STATIC = 1,
+  mjCAT_DYNAMIC = 2,
+  mjCAT_DECOR = 4,
+  mjCAT_ALL = 7,
+}
+public enum mjtMouse : int{
+  mjMOUSE_NONE = 0,
+  mjMOUSE_ROTATE_V = 1,
+  mjMOUSE_ROTATE_H = 2,
+  mjMOUSE_MOVE_V = 3,
+  mjMOUSE_MOVE_H = 4,
+  mjMOUSE_ZOOM = 5,
+  mjMOUSE_SELECT = 6,
+}
+public enum mjtPertBit : int{
+  mjPERT_TRANSLATE = 1,
+  mjPERT_ROTATE = 2,
+}
+public enum mjtCamera : int{
+  mjCAMERA_FREE = 0,
+  mjCAMERA_TRACKING = 1,
+  mjCAMERA_FIXED = 2,
+  mjCAMERA_USER = 3,
+}
+public enum mjtLabel : int{
+  mjLABEL_NONE = 0,
+  mjLABEL_BODY = 1,
+  mjLABEL_JOINT = 2,
+  mjLABEL_GEOM = 3,
+  mjLABEL_SITE = 4,
+  mjLABEL_CAMERA = 5,
+  mjLABEL_LIGHT = 6,
+  mjLABEL_TENDON = 7,
+  mjLABEL_ACTUATOR = 8,
+  mjLABEL_CONSTRAINT = 9,
+  mjLABEL_SKIN = 10,
+  mjLABEL_SELECTION = 11,
+  mjLABEL_SELPNT = 12,
+  mjLABEL_CONTACTFORCE = 13,
+  mjNLABEL = 14,
+}
+public enum mjtFrame : int{
+  mjFRAME_NONE = 0,
+  mjFRAME_BODY = 1,
+  mjFRAME_GEOM = 2,
+  mjFRAME_SITE = 3,
+  mjFRAME_CAMERA = 4,
+  mjFRAME_LIGHT = 5,
+  mjFRAME_WORLD = 6,
+  mjNFRAME = 7,
+}
+public enum mjtVisFlag : int{
+  mjVIS_CONVEXHULL = 0,
+  mjVIS_TEXTURE = 1,
+  mjVIS_JOINT = 2,
+  mjVIS_ACTUATOR = 3,
+  mjVIS_CAMERA = 4,
+  mjVIS_LIGHT = 5,
+  mjVIS_TENDON = 6,
+  mjVIS_RANGEFINDER = 7,
+  mjVIS_CONSTRAINT = 8,
+  mjVIS_INERTIA = 9,
+  mjVIS_SCLINERTIA = 10,
+  mjVIS_PERTFORCE = 11,
+  mjVIS_PERTOBJ = 12,
+  mjVIS_CONTACTPOINT = 13,
+  mjVIS_CONTACTFORCE = 14,
+  mjVIS_CONTACTSPLIT = 15,
+  mjVIS_TRANSPARENT = 16,
+  mjVIS_AUTOCONNECT = 17,
+  mjVIS_COM = 18,
+  mjVIS_SELECT = 19,
+  mjVIS_STATIC = 20,
+  mjVIS_SKIN = 21,
+  mjNVISFLAG = 22,
+}
+public enum mjtRndFlag : int{
+  mjRND_SHADOW = 0,
+  mjRND_WIREFRAME = 1,
+  mjRND_REFLECTION = 2,
+  mjRND_ADDITIVE = 3,
+  mjRND_SKYBOX = 4,
+  mjRND_FOG = 5,
+  mjRND_HAZE = 6,
+  mjRND_SEGMENT = 7,
+  mjRND_IDCOLOR = 8,
+  mjNRNDFLAG = 9,
+}
+public enum mjtStereo : int{
+  mjSTEREO_NONE = 0,
+  mjSTEREO_QUADBUFFERED = 1,
+  mjSTEREO_SIDEBYSIDE = 2,
+}
+
+// -----------------------------struct declarations-----------------------------
+
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjContact_ {
+  public double dist;
+  public fixed double pos[3];
+  public fixed double frame[9];
+  public double includemargin;
+  public fixed double friction[5];
+  public fixed double solref[2];
+  public fixed double solimp[5];
+  public double mu;
+  public fixed double H[36];
+  public int dim;
+  public int geom1;
+  public int geom2;
+  public int exclude;
+  public int efc_address;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjWarningStat_ {
+  public int lastinfo;
+  public int number;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjTimerStat_ {
+  public double duration;
+  public int number;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjSolverStat_ {
+  public double improvement;
+  public double gradient;
+  public double lineslope;
+  public int nactive;
+  public int nchange;
+  public int neval;
+  public int nupdate;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjData_ {
+  public int nstack;
+  public int nbuffer;
+  public int pstack;
+  public int maxuse_stack;
+  public int maxuse_con;
+  public int maxuse_efc;
+  public mjWarningStat_ warning0;
+  public mjWarningStat_ warning1;
+  public mjWarningStat_ warning2;
+  public mjWarningStat_ warning3;
+  public mjWarningStat_ warning4;
+  public mjWarningStat_ warning5;
+  public mjWarningStat_ warning6;
+  public mjWarningStat_ warning7;
+  public mjTimerStat_ timer0;
+  public mjTimerStat_ timer1;
+  public mjTimerStat_ timer2;
+  public mjTimerStat_ timer3;
+  public mjTimerStat_ timer4;
+  public mjTimerStat_ timer5;
+  public mjTimerStat_ timer6;
+  public mjTimerStat_ timer7;
+  public mjTimerStat_ timer8;
+  public mjTimerStat_ timer9;
+  public mjTimerStat_ timer10;
+  public mjTimerStat_ timer11;
+  public mjTimerStat_ timer12;
+  public mjSolverStat_ solver0;
+  public mjSolverStat_ solver1;
+  public mjSolverStat_ solver2;
+  public mjSolverStat_ solver3;
+  public mjSolverStat_ solver4;
+  public mjSolverStat_ solver5;
+  public mjSolverStat_ solver6;
+  public mjSolverStat_ solver7;
+  public mjSolverStat_ solver8;
+  public mjSolverStat_ solver9;
+  public mjSolverStat_ solver10;
+  public mjSolverStat_ solver11;
+  public mjSolverStat_ solver12;
+  public mjSolverStat_ solver13;
+  public mjSolverStat_ solver14;
+  public mjSolverStat_ solver15;
+  public mjSolverStat_ solver16;
+  public mjSolverStat_ solver17;
+  public mjSolverStat_ solver18;
+  public mjSolverStat_ solver19;
+  public mjSolverStat_ solver20;
+  public mjSolverStat_ solver21;
+  public mjSolverStat_ solver22;
+  public mjSolverStat_ solver23;
+  public mjSolverStat_ solver24;
+  public mjSolverStat_ solver25;
+  public mjSolverStat_ solver26;
+  public mjSolverStat_ solver27;
+  public mjSolverStat_ solver28;
+  public mjSolverStat_ solver29;
+  public mjSolverStat_ solver30;
+  public mjSolverStat_ solver31;
+  public mjSolverStat_ solver32;
+  public mjSolverStat_ solver33;
+  public mjSolverStat_ solver34;
+  public mjSolverStat_ solver35;
+  public mjSolverStat_ solver36;
+  public mjSolverStat_ solver37;
+  public mjSolverStat_ solver38;
+  public mjSolverStat_ solver39;
+  public mjSolverStat_ solver40;
+  public mjSolverStat_ solver41;
+  public mjSolverStat_ solver42;
+  public mjSolverStat_ solver43;
+  public mjSolverStat_ solver44;
+  public mjSolverStat_ solver45;
+  public mjSolverStat_ solver46;
+  public mjSolverStat_ solver47;
+  public mjSolverStat_ solver48;
+  public mjSolverStat_ solver49;
+  public mjSolverStat_ solver50;
+  public mjSolverStat_ solver51;
+  public mjSolverStat_ solver52;
+  public mjSolverStat_ solver53;
+  public mjSolverStat_ solver54;
+  public mjSolverStat_ solver55;
+  public mjSolverStat_ solver56;
+  public mjSolverStat_ solver57;
+  public mjSolverStat_ solver58;
+  public mjSolverStat_ solver59;
+  public mjSolverStat_ solver60;
+  public mjSolverStat_ solver61;
+  public mjSolverStat_ solver62;
+  public mjSolverStat_ solver63;
+  public mjSolverStat_ solver64;
+  public mjSolverStat_ solver65;
+  public mjSolverStat_ solver66;
+  public mjSolverStat_ solver67;
+  public mjSolverStat_ solver68;
+  public mjSolverStat_ solver69;
+  public mjSolverStat_ solver70;
+  public mjSolverStat_ solver71;
+  public mjSolverStat_ solver72;
+  public mjSolverStat_ solver73;
+  public mjSolverStat_ solver74;
+  public mjSolverStat_ solver75;
+  public mjSolverStat_ solver76;
+  public mjSolverStat_ solver77;
+  public mjSolverStat_ solver78;
+  public mjSolverStat_ solver79;
+  public mjSolverStat_ solver80;
+  public mjSolverStat_ solver81;
+  public mjSolverStat_ solver82;
+  public mjSolverStat_ solver83;
+  public mjSolverStat_ solver84;
+  public mjSolverStat_ solver85;
+  public mjSolverStat_ solver86;
+  public mjSolverStat_ solver87;
+  public mjSolverStat_ solver88;
+  public mjSolverStat_ solver89;
+  public mjSolverStat_ solver90;
+  public mjSolverStat_ solver91;
+  public mjSolverStat_ solver92;
+  public mjSolverStat_ solver93;
+  public mjSolverStat_ solver94;
+  public mjSolverStat_ solver95;
+  public mjSolverStat_ solver96;
+  public mjSolverStat_ solver97;
+  public mjSolverStat_ solver98;
+  public mjSolverStat_ solver99;
+  public mjSolverStat_ solver100;
+  public mjSolverStat_ solver101;
+  public mjSolverStat_ solver102;
+  public mjSolverStat_ solver103;
+  public mjSolverStat_ solver104;
+  public mjSolverStat_ solver105;
+  public mjSolverStat_ solver106;
+  public mjSolverStat_ solver107;
+  public mjSolverStat_ solver108;
+  public mjSolverStat_ solver109;
+  public mjSolverStat_ solver110;
+  public mjSolverStat_ solver111;
+  public mjSolverStat_ solver112;
+  public mjSolverStat_ solver113;
+  public mjSolverStat_ solver114;
+  public mjSolverStat_ solver115;
+  public mjSolverStat_ solver116;
+  public mjSolverStat_ solver117;
+  public mjSolverStat_ solver118;
+  public mjSolverStat_ solver119;
+  public mjSolverStat_ solver120;
+  public mjSolverStat_ solver121;
+  public mjSolverStat_ solver122;
+  public mjSolverStat_ solver123;
+  public mjSolverStat_ solver124;
+  public mjSolverStat_ solver125;
+  public mjSolverStat_ solver126;
+  public mjSolverStat_ solver127;
+  public mjSolverStat_ solver128;
+  public mjSolverStat_ solver129;
+  public mjSolverStat_ solver130;
+  public mjSolverStat_ solver131;
+  public mjSolverStat_ solver132;
+  public mjSolverStat_ solver133;
+  public mjSolverStat_ solver134;
+  public mjSolverStat_ solver135;
+  public mjSolverStat_ solver136;
+  public mjSolverStat_ solver137;
+  public mjSolverStat_ solver138;
+  public mjSolverStat_ solver139;
+  public mjSolverStat_ solver140;
+  public mjSolverStat_ solver141;
+  public mjSolverStat_ solver142;
+  public mjSolverStat_ solver143;
+  public mjSolverStat_ solver144;
+  public mjSolverStat_ solver145;
+  public mjSolverStat_ solver146;
+  public mjSolverStat_ solver147;
+  public mjSolverStat_ solver148;
+  public mjSolverStat_ solver149;
+  public mjSolverStat_ solver150;
+  public mjSolverStat_ solver151;
+  public mjSolverStat_ solver152;
+  public mjSolverStat_ solver153;
+  public mjSolverStat_ solver154;
+  public mjSolverStat_ solver155;
+  public mjSolverStat_ solver156;
+  public mjSolverStat_ solver157;
+  public mjSolverStat_ solver158;
+  public mjSolverStat_ solver159;
+  public mjSolverStat_ solver160;
+  public mjSolverStat_ solver161;
+  public mjSolverStat_ solver162;
+  public mjSolverStat_ solver163;
+  public mjSolverStat_ solver164;
+  public mjSolverStat_ solver165;
+  public mjSolverStat_ solver166;
+  public mjSolverStat_ solver167;
+  public mjSolverStat_ solver168;
+  public mjSolverStat_ solver169;
+  public mjSolverStat_ solver170;
+  public mjSolverStat_ solver171;
+  public mjSolverStat_ solver172;
+  public mjSolverStat_ solver173;
+  public mjSolverStat_ solver174;
+  public mjSolverStat_ solver175;
+  public mjSolverStat_ solver176;
+  public mjSolverStat_ solver177;
+  public mjSolverStat_ solver178;
+  public mjSolverStat_ solver179;
+  public mjSolverStat_ solver180;
+  public mjSolverStat_ solver181;
+  public mjSolverStat_ solver182;
+  public mjSolverStat_ solver183;
+  public mjSolverStat_ solver184;
+  public mjSolverStat_ solver185;
+  public mjSolverStat_ solver186;
+  public mjSolverStat_ solver187;
+  public mjSolverStat_ solver188;
+  public mjSolverStat_ solver189;
+  public mjSolverStat_ solver190;
+  public mjSolverStat_ solver191;
+  public mjSolverStat_ solver192;
+  public mjSolverStat_ solver193;
+  public mjSolverStat_ solver194;
+  public mjSolverStat_ solver195;
+  public mjSolverStat_ solver196;
+  public mjSolverStat_ solver197;
+  public mjSolverStat_ solver198;
+  public mjSolverStat_ solver199;
+  public mjSolverStat_ solver200;
+  public mjSolverStat_ solver201;
+  public mjSolverStat_ solver202;
+  public mjSolverStat_ solver203;
+  public mjSolverStat_ solver204;
+  public mjSolverStat_ solver205;
+  public mjSolverStat_ solver206;
+  public mjSolverStat_ solver207;
+  public mjSolverStat_ solver208;
+  public mjSolverStat_ solver209;
+  public mjSolverStat_ solver210;
+  public mjSolverStat_ solver211;
+  public mjSolverStat_ solver212;
+  public mjSolverStat_ solver213;
+  public mjSolverStat_ solver214;
+  public mjSolverStat_ solver215;
+  public mjSolverStat_ solver216;
+  public mjSolverStat_ solver217;
+  public mjSolverStat_ solver218;
+  public mjSolverStat_ solver219;
+  public mjSolverStat_ solver220;
+  public mjSolverStat_ solver221;
+  public mjSolverStat_ solver222;
+  public mjSolverStat_ solver223;
+  public mjSolverStat_ solver224;
+  public mjSolverStat_ solver225;
+  public mjSolverStat_ solver226;
+  public mjSolverStat_ solver227;
+  public mjSolverStat_ solver228;
+  public mjSolverStat_ solver229;
+  public mjSolverStat_ solver230;
+  public mjSolverStat_ solver231;
+  public mjSolverStat_ solver232;
+  public mjSolverStat_ solver233;
+  public mjSolverStat_ solver234;
+  public mjSolverStat_ solver235;
+  public mjSolverStat_ solver236;
+  public mjSolverStat_ solver237;
+  public mjSolverStat_ solver238;
+  public mjSolverStat_ solver239;
+  public mjSolverStat_ solver240;
+  public mjSolverStat_ solver241;
+  public mjSolverStat_ solver242;
+  public mjSolverStat_ solver243;
+  public mjSolverStat_ solver244;
+  public mjSolverStat_ solver245;
+  public mjSolverStat_ solver246;
+  public mjSolverStat_ solver247;
+  public mjSolverStat_ solver248;
+  public mjSolverStat_ solver249;
+  public mjSolverStat_ solver250;
+  public mjSolverStat_ solver251;
+  public mjSolverStat_ solver252;
+  public mjSolverStat_ solver253;
+  public mjSolverStat_ solver254;
+  public mjSolverStat_ solver255;
+  public mjSolverStat_ solver256;
+  public mjSolverStat_ solver257;
+  public mjSolverStat_ solver258;
+  public mjSolverStat_ solver259;
+  public mjSolverStat_ solver260;
+  public mjSolverStat_ solver261;
+  public mjSolverStat_ solver262;
+  public mjSolverStat_ solver263;
+  public mjSolverStat_ solver264;
+  public mjSolverStat_ solver265;
+  public mjSolverStat_ solver266;
+  public mjSolverStat_ solver267;
+  public mjSolverStat_ solver268;
+  public mjSolverStat_ solver269;
+  public mjSolverStat_ solver270;
+  public mjSolverStat_ solver271;
+  public mjSolverStat_ solver272;
+  public mjSolverStat_ solver273;
+  public mjSolverStat_ solver274;
+  public mjSolverStat_ solver275;
+  public mjSolverStat_ solver276;
+  public mjSolverStat_ solver277;
+  public mjSolverStat_ solver278;
+  public mjSolverStat_ solver279;
+  public mjSolverStat_ solver280;
+  public mjSolverStat_ solver281;
+  public mjSolverStat_ solver282;
+  public mjSolverStat_ solver283;
+  public mjSolverStat_ solver284;
+  public mjSolverStat_ solver285;
+  public mjSolverStat_ solver286;
+  public mjSolverStat_ solver287;
+  public mjSolverStat_ solver288;
+  public mjSolverStat_ solver289;
+  public mjSolverStat_ solver290;
+  public mjSolverStat_ solver291;
+  public mjSolverStat_ solver292;
+  public mjSolverStat_ solver293;
+  public mjSolverStat_ solver294;
+  public mjSolverStat_ solver295;
+  public mjSolverStat_ solver296;
+  public mjSolverStat_ solver297;
+  public mjSolverStat_ solver298;
+  public mjSolverStat_ solver299;
+  public mjSolverStat_ solver300;
+  public mjSolverStat_ solver301;
+  public mjSolverStat_ solver302;
+  public mjSolverStat_ solver303;
+  public mjSolverStat_ solver304;
+  public mjSolverStat_ solver305;
+  public mjSolverStat_ solver306;
+  public mjSolverStat_ solver307;
+  public mjSolverStat_ solver308;
+  public mjSolverStat_ solver309;
+  public mjSolverStat_ solver310;
+  public mjSolverStat_ solver311;
+  public mjSolverStat_ solver312;
+  public mjSolverStat_ solver313;
+  public mjSolverStat_ solver314;
+  public mjSolverStat_ solver315;
+  public mjSolverStat_ solver316;
+  public mjSolverStat_ solver317;
+  public mjSolverStat_ solver318;
+  public mjSolverStat_ solver319;
+  public mjSolverStat_ solver320;
+  public mjSolverStat_ solver321;
+  public mjSolverStat_ solver322;
+  public mjSolverStat_ solver323;
+  public mjSolverStat_ solver324;
+  public mjSolverStat_ solver325;
+  public mjSolverStat_ solver326;
+  public mjSolverStat_ solver327;
+  public mjSolverStat_ solver328;
+  public mjSolverStat_ solver329;
+  public mjSolverStat_ solver330;
+  public mjSolverStat_ solver331;
+  public mjSolverStat_ solver332;
+  public mjSolverStat_ solver333;
+  public mjSolverStat_ solver334;
+  public mjSolverStat_ solver335;
+  public mjSolverStat_ solver336;
+  public mjSolverStat_ solver337;
+  public mjSolverStat_ solver338;
+  public mjSolverStat_ solver339;
+  public mjSolverStat_ solver340;
+  public mjSolverStat_ solver341;
+  public mjSolverStat_ solver342;
+  public mjSolverStat_ solver343;
+  public mjSolverStat_ solver344;
+  public mjSolverStat_ solver345;
+  public mjSolverStat_ solver346;
+  public mjSolverStat_ solver347;
+  public mjSolverStat_ solver348;
+  public mjSolverStat_ solver349;
+  public mjSolverStat_ solver350;
+  public mjSolverStat_ solver351;
+  public mjSolverStat_ solver352;
+  public mjSolverStat_ solver353;
+  public mjSolverStat_ solver354;
+  public mjSolverStat_ solver355;
+  public mjSolverStat_ solver356;
+  public mjSolverStat_ solver357;
+  public mjSolverStat_ solver358;
+  public mjSolverStat_ solver359;
+  public mjSolverStat_ solver360;
+  public mjSolverStat_ solver361;
+  public mjSolverStat_ solver362;
+  public mjSolverStat_ solver363;
+  public mjSolverStat_ solver364;
+  public mjSolverStat_ solver365;
+  public mjSolverStat_ solver366;
+  public mjSolverStat_ solver367;
+  public mjSolverStat_ solver368;
+  public mjSolverStat_ solver369;
+  public mjSolverStat_ solver370;
+  public mjSolverStat_ solver371;
+  public mjSolverStat_ solver372;
+  public mjSolverStat_ solver373;
+  public mjSolverStat_ solver374;
+  public mjSolverStat_ solver375;
+  public mjSolverStat_ solver376;
+  public mjSolverStat_ solver377;
+  public mjSolverStat_ solver378;
+  public mjSolverStat_ solver379;
+  public mjSolverStat_ solver380;
+  public mjSolverStat_ solver381;
+  public mjSolverStat_ solver382;
+  public mjSolverStat_ solver383;
+  public mjSolverStat_ solver384;
+  public mjSolverStat_ solver385;
+  public mjSolverStat_ solver386;
+  public mjSolverStat_ solver387;
+  public mjSolverStat_ solver388;
+  public mjSolverStat_ solver389;
+  public mjSolverStat_ solver390;
+  public mjSolverStat_ solver391;
+  public mjSolverStat_ solver392;
+  public mjSolverStat_ solver393;
+  public mjSolverStat_ solver394;
+  public mjSolverStat_ solver395;
+  public mjSolverStat_ solver396;
+  public mjSolverStat_ solver397;
+  public mjSolverStat_ solver398;
+  public mjSolverStat_ solver399;
+  public mjSolverStat_ solver400;
+  public mjSolverStat_ solver401;
+  public mjSolverStat_ solver402;
+  public mjSolverStat_ solver403;
+  public mjSolverStat_ solver404;
+  public mjSolverStat_ solver405;
+  public mjSolverStat_ solver406;
+  public mjSolverStat_ solver407;
+  public mjSolverStat_ solver408;
+  public mjSolverStat_ solver409;
+  public mjSolverStat_ solver410;
+  public mjSolverStat_ solver411;
+  public mjSolverStat_ solver412;
+  public mjSolverStat_ solver413;
+  public mjSolverStat_ solver414;
+  public mjSolverStat_ solver415;
+  public mjSolverStat_ solver416;
+  public mjSolverStat_ solver417;
+  public mjSolverStat_ solver418;
+  public mjSolverStat_ solver419;
+  public mjSolverStat_ solver420;
+  public mjSolverStat_ solver421;
+  public mjSolverStat_ solver422;
+  public mjSolverStat_ solver423;
+  public mjSolverStat_ solver424;
+  public mjSolverStat_ solver425;
+  public mjSolverStat_ solver426;
+  public mjSolverStat_ solver427;
+  public mjSolverStat_ solver428;
+  public mjSolverStat_ solver429;
+  public mjSolverStat_ solver430;
+  public mjSolverStat_ solver431;
+  public mjSolverStat_ solver432;
+  public mjSolverStat_ solver433;
+  public mjSolverStat_ solver434;
+  public mjSolverStat_ solver435;
+  public mjSolverStat_ solver436;
+  public mjSolverStat_ solver437;
+  public mjSolverStat_ solver438;
+  public mjSolverStat_ solver439;
+  public mjSolverStat_ solver440;
+  public mjSolverStat_ solver441;
+  public mjSolverStat_ solver442;
+  public mjSolverStat_ solver443;
+  public mjSolverStat_ solver444;
+  public mjSolverStat_ solver445;
+  public mjSolverStat_ solver446;
+  public mjSolverStat_ solver447;
+  public mjSolverStat_ solver448;
+  public mjSolverStat_ solver449;
+  public mjSolverStat_ solver450;
+  public mjSolverStat_ solver451;
+  public mjSolverStat_ solver452;
+  public mjSolverStat_ solver453;
+  public mjSolverStat_ solver454;
+  public mjSolverStat_ solver455;
+  public mjSolverStat_ solver456;
+  public mjSolverStat_ solver457;
+  public mjSolverStat_ solver458;
+  public mjSolverStat_ solver459;
+  public mjSolverStat_ solver460;
+  public mjSolverStat_ solver461;
+  public mjSolverStat_ solver462;
+  public mjSolverStat_ solver463;
+  public mjSolverStat_ solver464;
+  public mjSolverStat_ solver465;
+  public mjSolverStat_ solver466;
+  public mjSolverStat_ solver467;
+  public mjSolverStat_ solver468;
+  public mjSolverStat_ solver469;
+  public mjSolverStat_ solver470;
+  public mjSolverStat_ solver471;
+  public mjSolverStat_ solver472;
+  public mjSolverStat_ solver473;
+  public mjSolverStat_ solver474;
+  public mjSolverStat_ solver475;
+  public mjSolverStat_ solver476;
+  public mjSolverStat_ solver477;
+  public mjSolverStat_ solver478;
+  public mjSolverStat_ solver479;
+  public mjSolverStat_ solver480;
+  public mjSolverStat_ solver481;
+  public mjSolverStat_ solver482;
+  public mjSolverStat_ solver483;
+  public mjSolverStat_ solver484;
+  public mjSolverStat_ solver485;
+  public mjSolverStat_ solver486;
+  public mjSolverStat_ solver487;
+  public mjSolverStat_ solver488;
+  public mjSolverStat_ solver489;
+  public mjSolverStat_ solver490;
+  public mjSolverStat_ solver491;
+  public mjSolverStat_ solver492;
+  public mjSolverStat_ solver493;
+  public mjSolverStat_ solver494;
+  public mjSolverStat_ solver495;
+  public mjSolverStat_ solver496;
+  public mjSolverStat_ solver497;
+  public mjSolverStat_ solver498;
+  public mjSolverStat_ solver499;
+  public mjSolverStat_ solver500;
+  public mjSolverStat_ solver501;
+  public mjSolverStat_ solver502;
+  public mjSolverStat_ solver503;
+  public mjSolverStat_ solver504;
+  public mjSolverStat_ solver505;
+  public mjSolverStat_ solver506;
+  public mjSolverStat_ solver507;
+  public mjSolverStat_ solver508;
+  public mjSolverStat_ solver509;
+  public mjSolverStat_ solver510;
+  public mjSolverStat_ solver511;
+  public mjSolverStat_ solver512;
+  public mjSolverStat_ solver513;
+  public mjSolverStat_ solver514;
+  public mjSolverStat_ solver515;
+  public mjSolverStat_ solver516;
+  public mjSolverStat_ solver517;
+  public mjSolverStat_ solver518;
+  public mjSolverStat_ solver519;
+  public mjSolverStat_ solver520;
+  public mjSolverStat_ solver521;
+  public mjSolverStat_ solver522;
+  public mjSolverStat_ solver523;
+  public mjSolverStat_ solver524;
+  public mjSolverStat_ solver525;
+  public mjSolverStat_ solver526;
+  public mjSolverStat_ solver527;
+  public mjSolverStat_ solver528;
+  public mjSolverStat_ solver529;
+  public mjSolverStat_ solver530;
+  public mjSolverStat_ solver531;
+  public mjSolverStat_ solver532;
+  public mjSolverStat_ solver533;
+  public mjSolverStat_ solver534;
+  public mjSolverStat_ solver535;
+  public mjSolverStat_ solver536;
+  public mjSolverStat_ solver537;
+  public mjSolverStat_ solver538;
+  public mjSolverStat_ solver539;
+  public mjSolverStat_ solver540;
+  public mjSolverStat_ solver541;
+  public mjSolverStat_ solver542;
+  public mjSolverStat_ solver543;
+  public mjSolverStat_ solver544;
+  public mjSolverStat_ solver545;
+  public mjSolverStat_ solver546;
+  public mjSolverStat_ solver547;
+  public mjSolverStat_ solver548;
+  public mjSolverStat_ solver549;
+  public mjSolverStat_ solver550;
+  public mjSolverStat_ solver551;
+  public mjSolverStat_ solver552;
+  public mjSolverStat_ solver553;
+  public mjSolverStat_ solver554;
+  public mjSolverStat_ solver555;
+  public mjSolverStat_ solver556;
+  public mjSolverStat_ solver557;
+  public mjSolverStat_ solver558;
+  public mjSolverStat_ solver559;
+  public mjSolverStat_ solver560;
+  public mjSolverStat_ solver561;
+  public mjSolverStat_ solver562;
+  public mjSolverStat_ solver563;
+  public mjSolverStat_ solver564;
+  public mjSolverStat_ solver565;
+  public mjSolverStat_ solver566;
+  public mjSolverStat_ solver567;
+  public mjSolverStat_ solver568;
+  public mjSolverStat_ solver569;
+  public mjSolverStat_ solver570;
+  public mjSolverStat_ solver571;
+  public mjSolverStat_ solver572;
+  public mjSolverStat_ solver573;
+  public mjSolverStat_ solver574;
+  public mjSolverStat_ solver575;
+  public mjSolverStat_ solver576;
+  public mjSolverStat_ solver577;
+  public mjSolverStat_ solver578;
+  public mjSolverStat_ solver579;
+  public mjSolverStat_ solver580;
+  public mjSolverStat_ solver581;
+  public mjSolverStat_ solver582;
+  public mjSolverStat_ solver583;
+  public mjSolverStat_ solver584;
+  public mjSolverStat_ solver585;
+  public mjSolverStat_ solver586;
+  public mjSolverStat_ solver587;
+  public mjSolverStat_ solver588;
+  public mjSolverStat_ solver589;
+  public mjSolverStat_ solver590;
+  public mjSolverStat_ solver591;
+  public mjSolverStat_ solver592;
+  public mjSolverStat_ solver593;
+  public mjSolverStat_ solver594;
+  public mjSolverStat_ solver595;
+  public mjSolverStat_ solver596;
+  public mjSolverStat_ solver597;
+  public mjSolverStat_ solver598;
+  public mjSolverStat_ solver599;
+  public mjSolverStat_ solver600;
+  public mjSolverStat_ solver601;
+  public mjSolverStat_ solver602;
+  public mjSolverStat_ solver603;
+  public mjSolverStat_ solver604;
+  public mjSolverStat_ solver605;
+  public mjSolverStat_ solver606;
+  public mjSolverStat_ solver607;
+  public mjSolverStat_ solver608;
+  public mjSolverStat_ solver609;
+  public mjSolverStat_ solver610;
+  public mjSolverStat_ solver611;
+  public mjSolverStat_ solver612;
+  public mjSolverStat_ solver613;
+  public mjSolverStat_ solver614;
+  public mjSolverStat_ solver615;
+  public mjSolverStat_ solver616;
+  public mjSolverStat_ solver617;
+  public mjSolverStat_ solver618;
+  public mjSolverStat_ solver619;
+  public mjSolverStat_ solver620;
+  public mjSolverStat_ solver621;
+  public mjSolverStat_ solver622;
+  public mjSolverStat_ solver623;
+  public mjSolverStat_ solver624;
+  public mjSolverStat_ solver625;
+  public mjSolverStat_ solver626;
+  public mjSolverStat_ solver627;
+  public mjSolverStat_ solver628;
+  public mjSolverStat_ solver629;
+  public mjSolverStat_ solver630;
+  public mjSolverStat_ solver631;
+  public mjSolverStat_ solver632;
+  public mjSolverStat_ solver633;
+  public mjSolverStat_ solver634;
+  public mjSolverStat_ solver635;
+  public mjSolverStat_ solver636;
+  public mjSolverStat_ solver637;
+  public mjSolverStat_ solver638;
+  public mjSolverStat_ solver639;
+  public mjSolverStat_ solver640;
+  public mjSolverStat_ solver641;
+  public mjSolverStat_ solver642;
+  public mjSolverStat_ solver643;
+  public mjSolverStat_ solver644;
+  public mjSolverStat_ solver645;
+  public mjSolverStat_ solver646;
+  public mjSolverStat_ solver647;
+  public mjSolverStat_ solver648;
+  public mjSolverStat_ solver649;
+  public mjSolverStat_ solver650;
+  public mjSolverStat_ solver651;
+  public mjSolverStat_ solver652;
+  public mjSolverStat_ solver653;
+  public mjSolverStat_ solver654;
+  public mjSolverStat_ solver655;
+  public mjSolverStat_ solver656;
+  public mjSolverStat_ solver657;
+  public mjSolverStat_ solver658;
+  public mjSolverStat_ solver659;
+  public mjSolverStat_ solver660;
+  public mjSolverStat_ solver661;
+  public mjSolverStat_ solver662;
+  public mjSolverStat_ solver663;
+  public mjSolverStat_ solver664;
+  public mjSolverStat_ solver665;
+  public mjSolverStat_ solver666;
+  public mjSolverStat_ solver667;
+  public mjSolverStat_ solver668;
+  public mjSolverStat_ solver669;
+  public mjSolverStat_ solver670;
+  public mjSolverStat_ solver671;
+  public mjSolverStat_ solver672;
+  public mjSolverStat_ solver673;
+  public mjSolverStat_ solver674;
+  public mjSolverStat_ solver675;
+  public mjSolverStat_ solver676;
+  public mjSolverStat_ solver677;
+  public mjSolverStat_ solver678;
+  public mjSolverStat_ solver679;
+  public mjSolverStat_ solver680;
+  public mjSolverStat_ solver681;
+  public mjSolverStat_ solver682;
+  public mjSolverStat_ solver683;
+  public mjSolverStat_ solver684;
+  public mjSolverStat_ solver685;
+  public mjSolverStat_ solver686;
+  public mjSolverStat_ solver687;
+  public mjSolverStat_ solver688;
+  public mjSolverStat_ solver689;
+  public mjSolverStat_ solver690;
+  public mjSolverStat_ solver691;
+  public mjSolverStat_ solver692;
+  public mjSolverStat_ solver693;
+  public mjSolverStat_ solver694;
+  public mjSolverStat_ solver695;
+  public mjSolverStat_ solver696;
+  public mjSolverStat_ solver697;
+  public mjSolverStat_ solver698;
+  public mjSolverStat_ solver699;
+  public mjSolverStat_ solver700;
+  public mjSolverStat_ solver701;
+  public mjSolverStat_ solver702;
+  public mjSolverStat_ solver703;
+  public mjSolverStat_ solver704;
+  public mjSolverStat_ solver705;
+  public mjSolverStat_ solver706;
+  public mjSolverStat_ solver707;
+  public mjSolverStat_ solver708;
+  public mjSolverStat_ solver709;
+  public mjSolverStat_ solver710;
+  public mjSolverStat_ solver711;
+  public mjSolverStat_ solver712;
+  public mjSolverStat_ solver713;
+  public mjSolverStat_ solver714;
+  public mjSolverStat_ solver715;
+  public mjSolverStat_ solver716;
+  public mjSolverStat_ solver717;
+  public mjSolverStat_ solver718;
+  public mjSolverStat_ solver719;
+  public mjSolverStat_ solver720;
+  public mjSolverStat_ solver721;
+  public mjSolverStat_ solver722;
+  public mjSolverStat_ solver723;
+  public mjSolverStat_ solver724;
+  public mjSolverStat_ solver725;
+  public mjSolverStat_ solver726;
+  public mjSolverStat_ solver727;
+  public mjSolverStat_ solver728;
+  public mjSolverStat_ solver729;
+  public mjSolverStat_ solver730;
+  public mjSolverStat_ solver731;
+  public mjSolverStat_ solver732;
+  public mjSolverStat_ solver733;
+  public mjSolverStat_ solver734;
+  public mjSolverStat_ solver735;
+  public mjSolverStat_ solver736;
+  public mjSolverStat_ solver737;
+  public mjSolverStat_ solver738;
+  public mjSolverStat_ solver739;
+  public mjSolverStat_ solver740;
+  public mjSolverStat_ solver741;
+  public mjSolverStat_ solver742;
+  public mjSolverStat_ solver743;
+  public mjSolverStat_ solver744;
+  public mjSolverStat_ solver745;
+  public mjSolverStat_ solver746;
+  public mjSolverStat_ solver747;
+  public mjSolverStat_ solver748;
+  public mjSolverStat_ solver749;
+  public mjSolverStat_ solver750;
+  public mjSolverStat_ solver751;
+  public mjSolverStat_ solver752;
+  public mjSolverStat_ solver753;
+  public mjSolverStat_ solver754;
+  public mjSolverStat_ solver755;
+  public mjSolverStat_ solver756;
+  public mjSolverStat_ solver757;
+  public mjSolverStat_ solver758;
+  public mjSolverStat_ solver759;
+  public mjSolverStat_ solver760;
+  public mjSolverStat_ solver761;
+  public mjSolverStat_ solver762;
+  public mjSolverStat_ solver763;
+  public mjSolverStat_ solver764;
+  public mjSolverStat_ solver765;
+  public mjSolverStat_ solver766;
+  public mjSolverStat_ solver767;
+  public mjSolverStat_ solver768;
+  public mjSolverStat_ solver769;
+  public mjSolverStat_ solver770;
+  public mjSolverStat_ solver771;
+  public mjSolverStat_ solver772;
+  public mjSolverStat_ solver773;
+  public mjSolverStat_ solver774;
+  public mjSolverStat_ solver775;
+  public mjSolverStat_ solver776;
+  public mjSolverStat_ solver777;
+  public mjSolverStat_ solver778;
+  public mjSolverStat_ solver779;
+  public mjSolverStat_ solver780;
+  public mjSolverStat_ solver781;
+  public mjSolverStat_ solver782;
+  public mjSolverStat_ solver783;
+  public mjSolverStat_ solver784;
+  public mjSolverStat_ solver785;
+  public mjSolverStat_ solver786;
+  public mjSolverStat_ solver787;
+  public mjSolverStat_ solver788;
+  public mjSolverStat_ solver789;
+  public mjSolverStat_ solver790;
+  public mjSolverStat_ solver791;
+  public mjSolverStat_ solver792;
+  public mjSolverStat_ solver793;
+  public mjSolverStat_ solver794;
+  public mjSolverStat_ solver795;
+  public mjSolverStat_ solver796;
+  public mjSolverStat_ solver797;
+  public mjSolverStat_ solver798;
+  public mjSolverStat_ solver799;
+  public mjSolverStat_ solver800;
+  public mjSolverStat_ solver801;
+  public mjSolverStat_ solver802;
+  public mjSolverStat_ solver803;
+  public mjSolverStat_ solver804;
+  public mjSolverStat_ solver805;
+  public mjSolverStat_ solver806;
+  public mjSolverStat_ solver807;
+  public mjSolverStat_ solver808;
+  public mjSolverStat_ solver809;
+  public mjSolverStat_ solver810;
+  public mjSolverStat_ solver811;
+  public mjSolverStat_ solver812;
+  public mjSolverStat_ solver813;
+  public mjSolverStat_ solver814;
+  public mjSolverStat_ solver815;
+  public mjSolverStat_ solver816;
+  public mjSolverStat_ solver817;
+  public mjSolverStat_ solver818;
+  public mjSolverStat_ solver819;
+  public mjSolverStat_ solver820;
+  public mjSolverStat_ solver821;
+  public mjSolverStat_ solver822;
+  public mjSolverStat_ solver823;
+  public mjSolverStat_ solver824;
+  public mjSolverStat_ solver825;
+  public mjSolverStat_ solver826;
+  public mjSolverStat_ solver827;
+  public mjSolverStat_ solver828;
+  public mjSolverStat_ solver829;
+  public mjSolverStat_ solver830;
+  public mjSolverStat_ solver831;
+  public mjSolverStat_ solver832;
+  public mjSolverStat_ solver833;
+  public mjSolverStat_ solver834;
+  public mjSolverStat_ solver835;
+  public mjSolverStat_ solver836;
+  public mjSolverStat_ solver837;
+  public mjSolverStat_ solver838;
+  public mjSolverStat_ solver839;
+  public mjSolverStat_ solver840;
+  public mjSolverStat_ solver841;
+  public mjSolverStat_ solver842;
+  public mjSolverStat_ solver843;
+  public mjSolverStat_ solver844;
+  public mjSolverStat_ solver845;
+  public mjSolverStat_ solver846;
+  public mjSolverStat_ solver847;
+  public mjSolverStat_ solver848;
+  public mjSolverStat_ solver849;
+  public mjSolverStat_ solver850;
+  public mjSolverStat_ solver851;
+  public mjSolverStat_ solver852;
+  public mjSolverStat_ solver853;
+  public mjSolverStat_ solver854;
+  public mjSolverStat_ solver855;
+  public mjSolverStat_ solver856;
+  public mjSolverStat_ solver857;
+  public mjSolverStat_ solver858;
+  public mjSolverStat_ solver859;
+  public mjSolverStat_ solver860;
+  public mjSolverStat_ solver861;
+  public mjSolverStat_ solver862;
+  public mjSolverStat_ solver863;
+  public mjSolverStat_ solver864;
+  public mjSolverStat_ solver865;
+  public mjSolverStat_ solver866;
+  public mjSolverStat_ solver867;
+  public mjSolverStat_ solver868;
+  public mjSolverStat_ solver869;
+  public mjSolverStat_ solver870;
+  public mjSolverStat_ solver871;
+  public mjSolverStat_ solver872;
+  public mjSolverStat_ solver873;
+  public mjSolverStat_ solver874;
+  public mjSolverStat_ solver875;
+  public mjSolverStat_ solver876;
+  public mjSolverStat_ solver877;
+  public mjSolverStat_ solver878;
+  public mjSolverStat_ solver879;
+  public mjSolverStat_ solver880;
+  public mjSolverStat_ solver881;
+  public mjSolverStat_ solver882;
+  public mjSolverStat_ solver883;
+  public mjSolverStat_ solver884;
+  public mjSolverStat_ solver885;
+  public mjSolverStat_ solver886;
+  public mjSolverStat_ solver887;
+  public mjSolverStat_ solver888;
+  public mjSolverStat_ solver889;
+  public mjSolverStat_ solver890;
+  public mjSolverStat_ solver891;
+  public mjSolverStat_ solver892;
+  public mjSolverStat_ solver893;
+  public mjSolverStat_ solver894;
+  public mjSolverStat_ solver895;
+  public mjSolverStat_ solver896;
+  public mjSolverStat_ solver897;
+  public mjSolverStat_ solver898;
+  public mjSolverStat_ solver899;
+  public mjSolverStat_ solver900;
+  public mjSolverStat_ solver901;
+  public mjSolverStat_ solver902;
+  public mjSolverStat_ solver903;
+  public mjSolverStat_ solver904;
+  public mjSolverStat_ solver905;
+  public mjSolverStat_ solver906;
+  public mjSolverStat_ solver907;
+  public mjSolverStat_ solver908;
+  public mjSolverStat_ solver909;
+  public mjSolverStat_ solver910;
+  public mjSolverStat_ solver911;
+  public mjSolverStat_ solver912;
+  public mjSolverStat_ solver913;
+  public mjSolverStat_ solver914;
+  public mjSolverStat_ solver915;
+  public mjSolverStat_ solver916;
+  public mjSolverStat_ solver917;
+  public mjSolverStat_ solver918;
+  public mjSolverStat_ solver919;
+  public mjSolverStat_ solver920;
+  public mjSolverStat_ solver921;
+  public mjSolverStat_ solver922;
+  public mjSolverStat_ solver923;
+  public mjSolverStat_ solver924;
+  public mjSolverStat_ solver925;
+  public mjSolverStat_ solver926;
+  public mjSolverStat_ solver927;
+  public mjSolverStat_ solver928;
+  public mjSolverStat_ solver929;
+  public mjSolverStat_ solver930;
+  public mjSolverStat_ solver931;
+  public mjSolverStat_ solver932;
+  public mjSolverStat_ solver933;
+  public mjSolverStat_ solver934;
+  public mjSolverStat_ solver935;
+  public mjSolverStat_ solver936;
+  public mjSolverStat_ solver937;
+  public mjSolverStat_ solver938;
+  public mjSolverStat_ solver939;
+  public mjSolverStat_ solver940;
+  public mjSolverStat_ solver941;
+  public mjSolverStat_ solver942;
+  public mjSolverStat_ solver943;
+  public mjSolverStat_ solver944;
+  public mjSolverStat_ solver945;
+  public mjSolverStat_ solver946;
+  public mjSolverStat_ solver947;
+  public mjSolverStat_ solver948;
+  public mjSolverStat_ solver949;
+  public mjSolverStat_ solver950;
+  public mjSolverStat_ solver951;
+  public mjSolverStat_ solver952;
+  public mjSolverStat_ solver953;
+  public mjSolverStat_ solver954;
+  public mjSolverStat_ solver955;
+  public mjSolverStat_ solver956;
+  public mjSolverStat_ solver957;
+  public mjSolverStat_ solver958;
+  public mjSolverStat_ solver959;
+  public mjSolverStat_ solver960;
+  public mjSolverStat_ solver961;
+  public mjSolverStat_ solver962;
+  public mjSolverStat_ solver963;
+  public mjSolverStat_ solver964;
+  public mjSolverStat_ solver965;
+  public mjSolverStat_ solver966;
+  public mjSolverStat_ solver967;
+  public mjSolverStat_ solver968;
+  public mjSolverStat_ solver969;
+  public mjSolverStat_ solver970;
+  public mjSolverStat_ solver971;
+  public mjSolverStat_ solver972;
+  public mjSolverStat_ solver973;
+  public mjSolverStat_ solver974;
+  public mjSolverStat_ solver975;
+  public mjSolverStat_ solver976;
+  public mjSolverStat_ solver977;
+  public mjSolverStat_ solver978;
+  public mjSolverStat_ solver979;
+  public mjSolverStat_ solver980;
+  public mjSolverStat_ solver981;
+  public mjSolverStat_ solver982;
+  public mjSolverStat_ solver983;
+  public mjSolverStat_ solver984;
+  public mjSolverStat_ solver985;
+  public mjSolverStat_ solver986;
+  public mjSolverStat_ solver987;
+  public mjSolverStat_ solver988;
+  public mjSolverStat_ solver989;
+  public mjSolverStat_ solver990;
+  public mjSolverStat_ solver991;
+  public mjSolverStat_ solver992;
+  public mjSolverStat_ solver993;
+  public mjSolverStat_ solver994;
+  public mjSolverStat_ solver995;
+  public mjSolverStat_ solver996;
+  public mjSolverStat_ solver997;
+  public mjSolverStat_ solver998;
+  public mjSolverStat_ solver999;
+  public int solver_iter;
+  public int solver_nnz;
+  public fixed double solver_fwdinv[2];
+  public int ne;
+  public int nf;
+  public int nefc;
+  public int ncon;
+  public double time;
+  public fixed double energy[2];
+  public void* buffer;
+  public double* stack;
+  public double* qpos;
+  public double* qvel;
+  public double* act;
+  public double* qacc_warmstart;
+  public double* ctrl;
+  public double* qfrc_applied;
+  public double* xfrc_applied;
+  public double* mocap_pos;
+  public double* mocap_quat;
+  public double* qacc;
+  public double* act_dot;
+  public double* userdata;
+  public double* sensordata;
+  public double* xpos;
+  public double* xquat;
+  public double* xmat;
+  public double* xipos;
+  public double* ximat;
+  public double* xanchor;
+  public double* xaxis;
+  public double* geom_xpos;
+  public double* geom_xmat;
+  public double* site_xpos;
+  public double* site_xmat;
+  public double* cam_xpos;
+  public double* cam_xmat;
+  public double* light_xpos;
+  public double* light_xdir;
+  public double* subtree_com;
+  public double* cdof;
+  public double* cinert;
+  public int* ten_wrapadr;
+  public int* ten_wrapnum;
+  public int* ten_J_rownnz;
+  public int* ten_J_rowadr;
+  public int* ten_J_colind;
+  public double* ten_length;
+  public double* ten_J;
+  public int* wrap_obj;
+  public double* wrap_xpos;
+  public double* actuator_length;
+  public double* actuator_moment;
+  public double* crb;
+  public double* qM;
+  public double* qLD;
+  public double* qLDiagInv;
+  public double* qLDiagSqrtInv;
+  public mjContact_* contact;
+  public int* efc_type;
+  public int* efc_id;
+  public int* efc_J_rownnz;
+  public int* efc_J_rowadr;
+  public int* efc_J_rowsuper;
+  public int* efc_J_colind;
+  public int* efc_JT_rownnz;
+  public int* efc_JT_rowadr;
+  public int* efc_JT_rowsuper;
+  public int* efc_JT_colind;
+  public double* efc_J;
+  public double* efc_JT;
+  public double* efc_pos;
+  public double* efc_margin;
+  public double* efc_frictionloss;
+  public double* efc_diagApprox;
+  public double* efc_KBIP;
+  public double* efc_D;
+  public double* efc_R;
+  public int* efc_AR_rownnz;
+  public int* efc_AR_rowadr;
+  public int* efc_AR_colind;
+  public double* efc_AR;
+  public double* ten_velocity;
+  public double* actuator_velocity;
+  public double* cvel;
+  public double* cdof_dot;
+  public double* qfrc_bias;
+  public double* qfrc_passive;
+  public double* efc_vel;
+  public double* efc_aref;
+  public double* subtree_linvel;
+  public double* subtree_angmom;
+  public double* actuator_force;
+  public double* qfrc_actuator;
+  public double* qfrc_unc;
+  public double* qacc_unc;
+  public double* efc_b;
+  public double* efc_force;
+  public int* efc_state;
+  public double* qfrc_constraint;
+  public double* qfrc_inverse;
+  public double* cacc;
+  public double* cfrc_int;
+  public double* cfrc_ext;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjLROpt_ {
+  public int mode;
+  public int useexisting;
+  public int uselimit;
+  public double accel;
+  public double maxforce;
+  public double timeconst;
+  public double timestep;
+  public double inttotal;
+  public double inteval;
+  public double tolrange;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct _mjVFS
+{
+  public int nfile;
+  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2000 * 1000)] public char[] filename;
+  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2000)] public int[] filesize;
+  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2000)] public IntPtr[] filedata;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjOption_ {
+  public double timestep;
+  public double apirate;
+  public double impratio;
+  public double tolerance;
+  public double noslip_tolerance;
+  public double mpr_tolerance;
+  public fixed double gravity[3];
+  public fixed double wind[3];
+  public fixed double magnetic[3];
+  public double density;
+  public double viscosity;
+  public double o_margin;
+  public fixed double o_solref[2];
+  public fixed double o_solimp[5];
+  public int integrator;
+  public int collision;
+  public int cone;
+  public int jacobian;
+  public int solver;
+  public int iterations;
+  public int noslip_iterations;
+  public int mpr_iterations;
+  public int disableflags;
+  public int enableflags;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct global {
+  public float fovy;
+  public float ipd;
+  public float linewidth;
+  public float glow;
+  public int offwidth;
+  public int offheight;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct quality {
+  public int shadowsize;
+  public int offsamples;
+  public int numslices;
+  public int numstacks;
+  public int numquads;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct headlight {
+  public fixed float ambient[3];
+  public fixed float diffuse[3];
+  public fixed float specular[3];
+  public int active;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct map {
+  public float stiffness;
+  public float stiffnessrot;
+  public float force;
+  public float torque;
+  public float alpha;
+  public float fogstart;
+  public float fogend;
+  public float znear;
+  public float zfar;
+  public float haze;
+  public float shadowclip;
+  public float shadowscale;
+  public float actuatortendon;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct scale {
+  public float forcewidth;
+  public float contactwidth;
+  public float contactheight;
+  public float connect;
+  public float com;
+  public float camera;
+  public float light;
+  public float selectpoint;
+  public float jointlength;
+  public float jointwidth;
+  public float actuatorlength;
+  public float actuatorwidth;
+  public float framelength;
+  public float framewidth;
+  public float constraint;
+  public float slidercrank;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct rgba {
+  public fixed float fog[4];
+  public fixed float haze[4];
+  public fixed float force[4];
+  public fixed float inertia[4];
+  public fixed float joint[4];
+  public fixed float actuator[4];
+  public fixed float actuatornegative[4];
+  public fixed float actuatorpositive[4];
+  public fixed float com[4];
+  public fixed float camera[4];
+  public fixed float light[4];
+  public fixed float selectpoint[4];
+  public fixed float connect[4];
+  public fixed float contactpoint[4];
+  public fixed float contactforce[4];
+  public fixed float contactfriction[4];
+  public fixed float contacttorque[4];
+  public fixed float contactgap[4];
+  public fixed float rangefinder[4];
+  public fixed float constraint[4];
+  public fixed float slidercrank[4];
+  public fixed float crankbroken[4];
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjVisual_ {
+  public global global;
+  public quality quality;
+  public headlight headlight;
+  public map map;
+  public scale scale;
+  public rgba rgba;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjStatistic_ {
+  public double meaninertia;
+  public double meanmass;
+  public double meansize;
+  public double extent;
+  public fixed double center[3];
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjModel_ {
+  public int nq;
+  public int nv;
+  public int nu;
+  public int na;
+  public int nbody;
+  public int njnt;
+  public int ngeom;
+  public int nsite;
+  public int ncam;
+  public int nlight;
+  public int nmesh;
+  public int nmeshvert;
+  public int nmeshtexvert;
+  public int nmeshface;
+  public int nmeshgraph;
+  public int nskin;
+  public int nskinvert;
+  public int nskintexvert;
+  public int nskinface;
+  public int nskinbone;
+  public int nskinbonevert;
+  public int nhfield;
+  public int nhfielddata;
+  public int ntex;
+  public int ntexdata;
+  public int nmat;
+  public int npair;
+  public int nexclude;
+  public int neq;
+  public int ntendon;
+  public int nwrap;
+  public int nsensor;
+  public int nnumeric;
+  public int nnumericdata;
+  public int ntext;
+  public int ntextdata;
+  public int ntuple;
+  public int ntupledata;
+  public int nkey;
+  public int nmocap;
+  public int nuser_body;
+  public int nuser_jnt;
+  public int nuser_geom;
+  public int nuser_site;
+  public int nuser_cam;
+  public int nuser_tendon;
+  public int nuser_actuator;
+  public int nuser_sensor;
+  public int nnames;
+  public int nM;
+  public int nemax;
+  public int njmax;
+  public int nconmax;
+  public int nstack;
+  public int nuserdata;
+  public int nsensordata;
+  public int nbuffer;
+  public mjOption_ opt;
+  public mjVisual_ vis;
+  public mjStatistic_ stat;
+  public void* buffer;
+  public double* qpos0;
+  public double* qpos_spring;
+  public int* body_parentid;
+  public int* body_rootid;
+  public int* body_weldid;
+  public int* body_mocapid;
+  public int* body_jntnum;
+  public int* body_jntadr;
+  public int* body_dofnum;
+  public int* body_dofadr;
+  public int* body_geomnum;
+  public int* body_geomadr;
+  public byte* body_simple;
+  public byte* body_sameframe;
+  public double* body_pos;
+  public double* body_quat;
+  public double* body_ipos;
+  public double* body_iquat;
+  public double* body_mass;
+  public double* body_subtreemass;
+  public double* body_inertia;
+  public double* body_invweight0;
+  public double* body_user;
+  public int* jnt_type;
+  public int* jnt_qposadr;
+  public int* jnt_dofadr;
+  public int* jnt_bodyid;
+  public int* jnt_group;
+  public byte* jnt_limited;
+  public double* jnt_solref;
+  public double* jnt_solimp;
+  public double* jnt_pos;
+  public double* jnt_axis;
+  public double* jnt_stiffness;
+  public double* jnt_range;
+  public double* jnt_margin;
+  public double* jnt_user;
+  public int* dof_bodyid;
+  public int* dof_jntid;
+  public int* dof_parentid;
+  public int* dof_Madr;
+  public int* dof_simplenum;
+  public double* dof_solref;
+  public double* dof_solimp;
+  public double* dof_frictionloss;
+  public double* dof_armature;
+  public double* dof_damping;
+  public double* dof_invweight0;
+  public double* dof_M0;
+  public int* geom_type;
+  public int* geom_contype;
+  public int* geom_conaffinity;
+  public int* geom_condim;
+  public int* geom_bodyid;
+  public int* geom_dataid;
+  public int* geom_matid;
+  public int* geom_group;
+  public int* geom_priority;
+  public byte* geom_sameframe;
+  public double* geom_solmix;
+  public double* geom_solref;
+  public double* geom_solimp;
+  public double* geom_size;
+  public double* geom_rbound;
+  public double* geom_pos;
+  public double* geom_quat;
+  public double* geom_friction;
+  public double* geom_margin;
+  public double* geom_gap;
+  public double* geom_user;
+  public float* geom_rgba;
+  public int* site_type;
+  public int* site_bodyid;
+  public int* site_matid;
+  public int* site_group;
+  public byte* site_sameframe;
+  public double* site_size;
+  public double* site_pos;
+  public double* site_quat;
+  public double* site_user;
+  public float* site_rgba;
+  public int* cam_mode;
+  public int* cam_bodyid;
+  public int* cam_targetbodyid;
+  public double* cam_pos;
+  public double* cam_quat;
+  public double* cam_poscom0;
+  public double* cam_pos0;
+  public double* cam_mat0;
+  public double* cam_fovy;
+  public double* cam_ipd;
+  public double* cam_user;
+  public int* light_mode;
+  public int* light_bodyid;
+  public int* light_targetbodyid;
+  public byte* light_directional;
+  public byte* light_castshadow;
+  public byte* light_active;
+  public double* light_pos;
+  public double* light_dir;
+  public double* light_poscom0;
+  public double* light_pos0;
+  public double* light_dir0;
+  public float* light_attenuation;
+  public float* light_cutoff;
+  public float* light_exponent;
+  public float* light_ambient;
+  public float* light_diffuse;
+  public float* light_specular;
+  public int* mesh_vertadr;
+  public int* mesh_vertnum;
+  public int* mesh_texcoordadr;
+  public int* mesh_faceadr;
+  public int* mesh_facenum;
+  public int* mesh_graphadr;
+  public float* mesh_vert;
+  public float* mesh_normal;
+  public float* mesh_texcoord;
+  public int* mesh_face;
+  public int* mesh_graph;
+  public int* skin_matid;
+  public float* skin_rgba;
+  public float* skin_inflate;
+  public int* skin_vertadr;
+  public int* skin_vertnum;
+  public int* skin_texcoordadr;
+  public int* skin_faceadr;
+  public int* skin_facenum;
+  public int* skin_boneadr;
+  public int* skin_bonenum;
+  public float* skin_vert;
+  public float* skin_texcoord;
+  public int* skin_face;
+  public int* skin_bonevertadr;
+  public int* skin_bonevertnum;
+  public float* skin_bonebindpos;
+  public float* skin_bonebindquat;
+  public int* skin_bonebodyid;
+  public int* skin_bonevertid;
+  public float* skin_bonevertweight;
+  public double* hfield_size;
+  public int* hfield_nrow;
+  public int* hfield_ncol;
+  public int* hfield_adr;
+  public float* hfield_data;
+  public int* tex_type;
+  public int* tex_height;
+  public int* tex_width;
+  public int* tex_adr;
+  public byte* tex_rgb;
+  public int* mat_texid;
+  public byte* mat_texuniform;
+  public float* mat_texrepeat;
+  public float* mat_emission;
+  public float* mat_specular;
+  public float* mat_shininess;
+  public float* mat_reflectance;
+  public float* mat_rgba;
+  public int* pair_dim;
+  public int* pair_geom1;
+  public int* pair_geom2;
+  public int* pair_signature;
+  public double* pair_solref;
+  public double* pair_solimp;
+  public double* pair_margin;
+  public double* pair_gap;
+  public double* pair_friction;
+  public int* exclude_signature;
+  public int* eq_type;
+  public int* eq_obj1id;
+  public int* eq_obj2id;
+  public byte* eq_active;
+  public double* eq_solref;
+  public double* eq_solimp;
+  public double* eq_data;
+  public int* tendon_adr;
+  public int* tendon_num;
+  public int* tendon_matid;
+  public int* tendon_group;
+  public byte* tendon_limited;
+  public double* tendon_width;
+  public double* tendon_solref_lim;
+  public double* tendon_solimp_lim;
+  public double* tendon_solref_fri;
+  public double* tendon_solimp_fri;
+  public double* tendon_range;
+  public double* tendon_margin;
+  public double* tendon_stiffness;
+  public double* tendon_damping;
+  public double* tendon_frictionloss;
+  public double* tendon_lengthspring;
+  public double* tendon_length0;
+  public double* tendon_invweight0;
+  public double* tendon_user;
+  public float* tendon_rgba;
+  public int* wrap_type;
+  public int* wrap_objid;
+  public double* wrap_prm;
+  public int* actuator_trntype;
+  public int* actuator_dyntype;
+  public int* actuator_gaintype;
+  public int* actuator_biastype;
+  public int* actuator_trnid;
+  public int* actuator_group;
+  public byte* actuator_ctrllimited;
+  public byte* actuator_forcelimited;
+  public double* actuator_dynprm;
+  public double* actuator_gainprm;
+  public double* actuator_biasprm;
+  public double* actuator_ctrlrange;
+  public double* actuator_forcerange;
+  public double* actuator_gear;
+  public double* actuator_cranklength;
+  public double* actuator_acc0;
+  public double* actuator_length0;
+  public double* actuator_lengthrange;
+  public double* actuator_user;
+  public int* sensor_type;
+  public int* sensor_datatype;
+  public int* sensor_needstage;
+  public int* sensor_objtype;
+  public int* sensor_objid;
+  public int* sensor_dim;
+  public int* sensor_adr;
+  public double* sensor_cutoff;
+  public double* sensor_noise;
+  public double* sensor_user;
+  public int* numeric_adr;
+  public int* numeric_size;
+  public double* numeric_data;
+  public int* text_adr;
+  public int* text_size;
+  public char* text_data;
+  public int* tuple_adr;
+  public int* tuple_size;
+  public int* tuple_objtype;
+  public int* tuple_objid;
+  public double* tuple_objprm;
+  public double* key_time;
+  public double* key_qpos;
+  public double* key_qvel;
+  public double* key_act;
+  public double* key_mpos;
+  public double* key_mquat;
+  public int* name_bodyadr;
+  public int* name_jntadr;
+  public int* name_geomadr;
+  public int* name_siteadr;
+  public int* name_camadr;
+  public int* name_lightadr;
+  public int* name_meshadr;
+  public int* name_skinadr;
+  public int* name_hfieldadr;
+  public int* name_texadr;
+  public int* name_matadr;
+  public int* name_pairadr;
+  public int* name_excludeadr;
+  public int* name_eqadr;
+  public int* name_tendonadr;
+  public int* name_actuatoradr;
+  public int* name_sensoradr;
+  public int* name_numericadr;
+  public int* name_textadr;
+  public int* name_tupleadr;
+  public int* name_keyadr;
+  public char* names;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjrRect_ {
+  public int left;
+  public int bottom;
+  public int width;
+  public int height;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjrContext_ {
+  public float lineWidth;
+  public float shadowClip;
+  public float shadowScale;
+  public float fogStart;
+  public float fogEnd;
+  public fixed float fogRGBA[4];
+  public int shadowSize;
+  public int offWidth;
+  public int offHeight;
+  public int offSamples;
+  public int fontScale;
+  public fixed int auxWidth[10];
+  public fixed int auxHeight[10];
+  public fixed int auxSamples[10];
+  public uint offFBO;
+  public uint offFBO_r;
+  public uint offColor;
+  public uint offColor_r;
+  public uint offDepthStencil;
+  public uint offDepthStencil_r;
+  public uint shadowFBO;
+  public uint shadowTex;
+  public fixed uint auxFBO[10];
+  public fixed uint auxFBO_r[10];
+  public fixed uint auxColor[10];
+  public fixed uint auxColor_r[10];
+  public int ntexture;
+  public fixed int textureType[100];
+  public fixed uint texture[100];
+  public uint basePlane;
+  public uint baseMesh;
+  public uint baseHField;
+  public uint baseBuiltin;
+  public uint baseFontNormal;
+  public uint baseFontShadow;
+  public uint baseFontBig;
+  public int rangePlane;
+  public int rangeMesh;
+  public int rangeHField;
+  public int rangeBuiltin;
+  public int rangeFont;
+  public int nskin;
+  public uint* skinvertVBO;
+  public uint* skinnormalVBO;
+  public uint* skintexcoordVBO;
+  public uint* skinfaceVBO;
+  public fixed int charWidth[127];
+  public fixed int charWidthBig[127];
+  public int charHeight;
+  public int charHeightBig;
+  public int glewInitialized;
+  public int windowAvailable;
+  public int windowSamples;
+  public int windowStereo;
+  public int windowDoublebuffer;
+  public int currentBuffer;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiState_ {
+  public int nrect;
+  public mjrRect_ rect0;
+  public mjrRect_ rect1;
+  public mjrRect_ rect2;
+  public mjrRect_ rect3;
+  public mjrRect_ rect4;
+  public mjrRect_ rect5;
+  public mjrRect_ rect6;
+  public mjrRect_ rect7;
+  public mjrRect_ rect8;
+  public mjrRect_ rect9;
+  public mjrRect_ rect10;
+  public mjrRect_ rect11;
+  public mjrRect_ rect12;
+  public mjrRect_ rect13;
+  public mjrRect_ rect14;
+  public mjrRect_ rect15;
+  public mjrRect_ rect16;
+  public mjrRect_ rect17;
+  public mjrRect_ rect18;
+  public mjrRect_ rect19;
+  public mjrRect_ rect20;
+  public mjrRect_ rect21;
+  public mjrRect_ rect22;
+  public mjrRect_ rect23;
+  public mjrRect_ rect24;
+  public void* userdata;
+  public int type;
+  public int left;
+  public int right;
+  public int middle;
+  public int doubleclick;
+  public int button;
+  public double buttontime;
+  public double x;
+  public double y;
+  public double dx;
+  public double dy;
+  public double sx;
+  public double sy;
+  public int control;
+  public int shift;
+  public int alt;
+  public int key;
+  public double keytime;
+  public int mouserect;
+  public int dragrect;
+  public int dragbutton;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiThemeSpacing_ {
+  public int total;
+  public int scroll;
+  public int label;
+  public int section;
+  public int itemside;
+  public int itemmid;
+  public int itemver;
+  public int texthor;
+  public int textver;
+  public int linescroll;
+  public int samples;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiThemeColor_ {
+  public fixed float master[3];
+  public fixed float thumb[3];
+  public fixed float secttitle[3];
+  public fixed float sectfont[3];
+  public fixed float sectsymbol[3];
+  public fixed float sectpane[3];
+  public fixed float shortcut[3];
+  public fixed float fontactive[3];
+  public fixed float fontinactive[3];
+  public fixed float decorinactive[3];
+  public fixed float decorinactive2[3];
+  public fixed float button[3];
+  public fixed float check[3];
+  public fixed float radio[3];
+  public fixed float select[3];
+  public fixed float select2[3];
+  public fixed float slider[3];
+  public fixed float slider2[3];
+  public fixed float edit[3];
+  public fixed float edit2[3];
+  public fixed float cursor[3];
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiItemSingle_ {
+  public int modifier;
+  public int shortcut;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiItemMulti_ {
+  public int nelem;
+  public fixed sbyte name[35 * 40];
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiItemSlider_ {
+  public fixed double range[2];
+  public double divisions;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiItemEdit_ {
+  public int nelem;
+  public fixed double range[7 * 2];
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiSection_ {
+  public fixed sbyte name[40];
+  public int state;
+  public int modifier;
+  public int shortcut;
+  public int nitem;
+  public mjrRect_ rtitle;
+  public mjrRect_ rcontent;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjUI_ {
+  public mjuiThemeSpacing_ spacing;
+  public mjuiThemeColor_ color;
+  public mjfItemEnable predicate;
+  public void* userdata;
+  public int rectid;
+  public int auxid;
+  public int radiocol;
+  public int width;
+  public int height;
+  public int maxheight;
+  public int scroll;
+  public int mousesect;
+  public int mouseitem;
+  public int mousehelp;
+  public int editsect;
+  public int edititem;
+  public int editcursor;
+  public int editscroll;
+  public fixed sbyte edittext[300];
+  public mjuiItem_* editchanged;
+  public int nsect;
+  public mjuiSection_ sect0;
+  public mjuiSection_ sect1;
+  public mjuiSection_ sect2;
+  public mjuiSection_ sect3;
+  public mjuiSection_ sect4;
+  public mjuiSection_ sect5;
+  public mjuiSection_ sect6;
+  public mjuiSection_ sect7;
+  public mjuiSection_ sect8;
+  public mjuiSection_ sect9;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjuiDef_ {
+  public int type;
+  public fixed sbyte name[40];
+  public int state;
+  public void* pdata;
+  public fixed sbyte other[300];
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjvPerturb_ {
+  public int select;
+  public int skinselect;
+  public int active;
+  public int active2;
+  public fixed double refpos[3];
+  public fixed double refquat[4];
+  public fixed double localpos[3];
+  public double scale;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjvCamera_ {
+  public int type;
+  public int fixedcamid;
+  public int trackbodyid;
+  public fixed double lookat[3];
+  public double distance;
+  public double azimuth;
+  public double elevation;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjvGLCamera_ {
+  public fixed float pos[3];
+  public fixed float forward[3];
+  public fixed float up[3];
+  public float frustum_center;
+  public float frustum_bottom;
+  public float frustum_top;
+  public float frustum_near;
+  public float frustum_far;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjvGeom_ {
+  public int type;
+  public int dataid;
+  public int objtype;
+  public int objid;
+  public int category;
+  public int texid;
+  public int texuniform;
+  public int texcoord;
+  public int segid;
+  public fixed float texrepeat[2];
+  public fixed float size[3];
+  public fixed float pos[3];
+  public fixed float mat[9];
+  public fixed float rgba[4];
+  public float emission;
+  public float specular;
+  public float shininess;
+  public float reflectance;
+  public fixed sbyte label[100];
+  public float camdist;
+  public float modelrbound;
+  public byte transparent;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjvLight_ {
+  public fixed float pos[3];
+  public fixed float dir[3];
+  public fixed float attenuation[3];
+  public float cutoff;
+  public float exponent;
+  public fixed float ambient[3];
+  public fixed float diffuse[3];
+  public fixed float specular[3];
+  public byte headlight;
+  public byte directional;
+  public byte castshadow;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjvOption_ {
+  public int label;
+  public int frame;
+  public fixed byte geomgroup[6];
+  public fixed byte sitegroup[6];
+  public fixed byte jointgroup[6];
+  public fixed byte tendongroup[6];
+  public fixed byte actuatorgroup[6];
+  public fixed byte flags[22];
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjvScene_ {
+  public int maxgeom;
+  public int ngeom;
+  public mjvGeom_* geoms;
+  public int* geomorder;
+  public int nskin;
+  public int* skinfacenum;
+  public int* skinvertadr;
+  public int* skinvertnum;
+  public float* skinvert;
+  public float* skinnormal;
+  public int nlight;
+  public mjvLight_ lights0;
+  public mjvLight_ lights1;
+  public mjvLight_ lights2;
+  public mjvLight_ lights3;
+  public mjvLight_ lights4;
+  public mjvLight_ lights5;
+  public mjvLight_ lights6;
+  public mjvLight_ lights7;
+  public mjvGLCamera_ camera0;
+  public mjvGLCamera_ camera1;
+  public byte enabletransform;
+  public fixed float translate[3];
+  public fixed float rotate[4];
+  public float scale;
+  public int stereo;
+  public fixed byte flags[9];
+  public int framewidth;
+  public fixed float framergb[3];
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct mjvFigure_ {
+  public int flg_legend;
+  public fixed int flg_ticklabel[2];
+  public int flg_extend;
+  public int flg_barplot;
+  public int flg_selection;
+  public int flg_symmetric;
+  public float linewidth;
+  public float gridwidth;
+  public fixed int gridsize[2];
+  public fixed float gridrgb[3];
+  public fixed float figurergba[4];
+  public fixed float panergba[4];
+  public fixed float legendrgba[4];
+  public fixed float textrgb[3];
+  public fixed float linergb[100 * 3];
+  public fixed float range[2 * 2];
+  public fixed sbyte xformat[20];
+  public fixed sbyte yformat[20];
+  public fixed sbyte minwidth[20];
+  public fixed sbyte title[1000];
+  public fixed sbyte xlabel[100];
+  public fixed sbyte linename[100 * 100];
+  public int legendoffset;
+  public int subplot;
+  public fixed int highlight[2];
+  public int highlightid;
+  public float selection;
+  public fixed int linepnt[100];
+  public fixed float linedata[100 * 2000];
+  public fixed int xaxispixel[2];
+  public fixed int yaxispixel[2];
+  public fixed float xaxisdata[2];
+  public fixed float yaxisdata[2];
+}public struct mjuiItem_ {}public struct mjfItemEnable {}
+
+// ----------------------------Function declarations----------------------------
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_activate([MarshalAs(UnmanagedType.LPStr)]string filename);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_deactivate();
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_defaultVFS(void* vfs);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_addFileVFS(void* vfs, [MarshalAs(UnmanagedType.LPStr)]string directory, [MarshalAs(UnmanagedType.LPStr)]string filename);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_makeEmptyFileVFS(void* vfs, [MarshalAs(UnmanagedType.LPStr)]string filename, int filesize);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_findFileVFS(void* vfs, [MarshalAs(UnmanagedType.LPStr)]string filename);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_deleteFileVFS(void* vfs, [MarshalAs(UnmanagedType.LPStr)]string filename);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_deleteVFS(void* vfs);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjModel_* mj_loadXML([MarshalAs(UnmanagedType.LPStr)]string filename, void* vfs, StringBuilder error, int error_sz);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_saveLastXML([MarshalAs(UnmanagedType.LPStr)]string filename, mjModel_* m, StringBuilder error, int error_sz);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_freeLastXML();
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_printSchema([MarshalAs(UnmanagedType.LPStr)]string filename, StringBuilder buffer, int buffer_sz, int flg_html, int flg_pad);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_step(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_step1(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_step2(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_forward(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_inverse(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_forwardSkip(mjModel_* m, mjData_* d, int skipstage, int skipsensor);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_inverseSkip(mjModel_* m, mjData_* d, int skipstage, int skipsensor);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_defaultLROpt(mjLROpt_* opt);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_defaultSolRefImp(double* solref, double* solimp);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_defaultOption(mjOption_* opt);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_defaultVisual(mjVisual_* vis);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjModel_* mj_copyModel(mjModel_* dest, mjModel_* src);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_saveModel(mjModel_* m, [MarshalAs(UnmanagedType.LPStr)]string filename, void* buffer, int buffer_sz);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjModel_* mj_loadModel([MarshalAs(UnmanagedType.LPStr)]string filename, void* vfs);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_deleteModel(mjModel_* m);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_sizeModel(mjModel_* m);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjData_* mj_makeData(mjModel_* m);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjData_* mj_copyData(mjData_* dest, mjModel_* m, mjData_* src);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_resetData(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_resetDataDebug(mjModel_* m, mjData_* d, byte debug_value);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_resetDataKeyframe(mjModel_* m, mjData_* d, int key);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double* mj_stackAlloc(mjData_* d, int size);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_deleteData(mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_resetCallbacks();
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_setConst(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_setLengthRange(mjModel_* m, mjData_* d, int index, mjLROpt_* opt, StringBuilder error, int error_sz);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_printFormattedModel(mjModel_* m, [MarshalAs(UnmanagedType.LPStr)]string filename, [MarshalAs(UnmanagedType.LPStr)]string float_format_str);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_printModel(mjModel_* m, [MarshalAs(UnmanagedType.LPStr)]string filename);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_printData(mjModel_* m, mjData_* d, [MarshalAs(UnmanagedType.LPStr)]string filename);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_printMat(double* mat, int nr, int nc);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_printMatSparse(double* mat, int nr, int* rownnz, int* rowadr, int* colind);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_fwdPosition(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_fwdVelocity(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_fwdActuation(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_fwdAcceleration(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_fwdConstraint(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_Euler(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_RungeKutta(mjModel_* m, mjData_* d, int N);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_invPosition(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_invVelocity(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_invConstraint(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_compareFwdInv(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_sensorPos(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_sensorVel(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_sensorAcc(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_energyPos(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_energyVel(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_checkPos(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_checkVel(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_checkAcc(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_kinematics(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_comPos(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_camlight(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_tendon(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_transmission(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_crb(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_factorM(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_solveM(mjModel_* m, mjData_* d, double* x, double* y, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_solveM2(mjModel_* m, mjData_* d, double* x, double* y, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_comVel(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_passive(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_subtreeVel(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_rne(mjModel_* m, mjData_* d, int flg_acc, double* result);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_rnePostConstraint(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_collision(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_makeConstraint(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_projectConstraint(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_referenceConstraint(mjModel_* m, mjData_* d);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_constraintUpdate(mjModel_* m, mjData_* d, double* jar, double* cost, int flg_coneHessian);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_addContact(mjModel_* m, mjData_* d, mjContact_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_isPyramidal(mjModel_* m);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_isSparse(mjModel_* m);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_isDual(mjModel_* m);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_mulJacVec(mjModel_* m, mjData_* d, double* res, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_mulJacTVec(mjModel_* m, mjData_* d, double* res, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_jac(mjModel_* m, mjData_* d, double* jacp, double* jacr, double* point, int body);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_jacBody(mjModel_* m, mjData_* d, double* jacp, double* jacr, int body);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_jacBodyCom(mjModel_* m, mjData_* d, double* jacp, double* jacr, int body);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_jacGeom(mjModel_* m, mjData_* d, double* jacp, double* jacr, int geom);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_jacSite(mjModel_* m, mjData_* d, double* jacp, double* jacr, int site);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_jacPointAxis(mjModel_* m, mjData_* d, double* jacPoint, double* jacAxis, double* point, double* axis, int body);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_name2id(mjModel_* m, int type, [MarshalAs(UnmanagedType.LPStr)]string name);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+[return: MarshalAs(UnmanagedType.LPStr)]
+public static unsafe extern string mj_id2name(mjModel_* m, int type, int id);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_fullM(mjModel_* m, double* dst, double* M);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_mulM(mjModel_* m, mjData_* d, double* res, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_mulM2(mjModel_* m, mjData_* d, double* res, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_addM(mjModel_* m, mjData_* d, double* dst, int* rownnz, int* rowadr, int* colind);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_applyFT(mjModel_* m, mjData_* d, double* force, double* torque, double* point, int body, double* qfrc_target);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_objectVelocity(mjModel_* m, mjData_* d, int objtype, int objid, double* res, int flg_local);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_objectAcceleration(mjModel_* m, mjData_* d, int objtype, int objid, double* res, int flg_local);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_contactForce(mjModel_* m, mjData_* d, int id, double* result);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_differentiatePos(mjModel_* m, double* qvel, double dt, double* qpos1, double* qpos2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_integratePos(mjModel_* m, double* qpos, double* qvel, double dt);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_normalizeQuat(mjModel_* m, double* qpos);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_local2Global(mjData_* d, double* xpos, double* xmat, double* pos, double* quat, int body, byte sameframe);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mj_getTotalmass(mjModel_* m);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_setTotalmass(mjModel_* m, double newmass);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mj_version();
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mj_ray(mjModel_* m, mjData_* d, double* pnt, double* vec, byte* geomgroup, byte flg_static, int bodyexclude, int* geomid);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mj_rayHfield(mjModel_* m, mjData_* d, int geomid, double* pnt, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mj_rayMesh(mjModel_* m, mjData_* d, int geomid, double* pnt, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_rayGeom(double* pos, double* mat, double* size, double* pnt, double* vec, int geomtype);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_raySkin(int nface, int nvert, int* face, float* vert, double* pnt, double* vec, int* vertid);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_defaultCamera(mjvCamera_* cam);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_defaultPerturb(mjvPerturb_* pert);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_room2model(double* modelpos, double* modelquat, double* roompos, double* roomquat, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_model2room(double* roompos, double* roomquat, double* modelpos, double* modelquat, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_cameraInModel(double* headpos, double* forward, double* up, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_cameraInRoom(double* headpos, double* forward, double* up, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mjv_frustumHeight(mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_alignToCamera(double* res, double* vec, double* forward);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_moveCamera(mjModel_* m, int action, double reldx, double reldy, mjvScene_* scn, mjvCamera_* cam);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_movePerturb(mjModel_* m, mjData_* d, int action, double reldx, double reldy, mjvScene_* scn, mjvPerturb_* pert);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_moveModel(mjModel_* m, int action, double reldx, double reldy, double* roomup, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_initPerturb(mjModel_* m, mjData_* d, mjvScene_* scn, mjvPerturb_* pert);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_applyPerturbPose(mjModel_* m, mjData_* d, mjvPerturb_* pert, int flg_paused);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_applyPerturbForce(mjModel_* m, mjData_* d, mjvPerturb_* pert);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjvGLCamera_* mjv_averageCamera(mjvGLCamera_* cam1, mjvGLCamera_* cam2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mjv_select(mjModel_* m, mjData_* d, mjvOption_* vopt, double aspectratio, double relx, double rely, mjvScene_* scn, double* selpnt, int* geomid, int* skinid);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_defaultOption(mjvOption_* opt);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_defaultFigure(mjvFigure_* fig);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_initGeom(mjvGeom_* geom, int type, double* size, double* pos, double* mat, float* rgba);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_makeConnector(mjvGeom_* geom, int type, double width, double a0, double a1, double a2, double b0, double b1, double b2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_defaultScene(mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_makeScene(mjModel_* m, mjvScene_* scn, int maxgeom);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_freeScene(mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_updateScene(mjModel_* m, mjData_* d, mjvOption_* opt, mjvPerturb_* pert, mjvCamera_* cam, int catmask, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_addGeoms(mjModel_* m, mjData_* d, mjvOption_* opt, mjvPerturb_* pert, int catmask, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_makeLights(mjModel_* m, mjData_* d, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_updateCamera(mjModel_* m, mjData_* d, mjvCamera_* cam, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjv_updateSkin(mjModel_* m, mjData_* d, mjvScene_* scn);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_defaultContext(mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_makeContext(mjModel_* m, mjrContext_* con, int fontscale);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_changeFont(int fontscale, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_addAux(int index, int width, int height, int samples, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_freeContext(mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_uploadTexture(mjModel_* m, mjrContext_* con, int texid);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_uploadMesh(mjModel_* m, mjrContext_* con, int meshid);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_uploadHField(mjModel_* m, mjrContext_* con, int hfieldid);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_restoreBuffer(mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_setBuffer(int framebuffer, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_readPixels(byte* rgb, float* depth, mjrRect_* viewport, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_drawPixels(byte* rgb, float* depth, mjrRect_* viewport, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_blitBuffer(mjrRect_* src, mjrRect_* dst, int flg_color, int flg_depth, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_setAux(int index, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_blitAux(int index, mjrRect_* src, int left, int bottom, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_text(int font, [MarshalAs(UnmanagedType.LPStr)]string txt, mjrContext_* con, float x, float y, float r, float g, float b);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_overlay(int font, int gridpos, mjrRect_* viewport, [MarshalAs(UnmanagedType.LPStr)]string overlay, [MarshalAs(UnmanagedType.LPStr)]string overlay2, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjrRect_* mjr_maxViewport(mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_rectangle(mjrRect_* viewport, float r, float g, float b, float a);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_label(mjrRect_* viewport, int font, [MarshalAs(UnmanagedType.LPStr)]string txt, float r, float g, float b, float a, float rt, float gt, float bt, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_figure(mjrRect_* viewport, mjvFigure_* fig, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_render(mjrRect_* viewport, mjvScene_* scn, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjr_finish();
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mjr_getError();
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mjr_findRect(int x, int y, int nrect, mjrRect_* rect);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjuiThemeSpacing_* mjui_themeSpacing(int ind);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjuiThemeColor_* mjui_themeColor(int ind);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjui_add(mjUI_* ui, mjuiDef_* def);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjui_addToSection(mjUI_* ui, int sect, mjuiDef_* def);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjui_resize(mjUI_* ui, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjui_update(int section, int item, mjUI_* ui, mjuiState_* state, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern mjuiItem_* mjui_event(mjUI_* ui, mjuiState_* state, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mjui_render(mjUI_* ui, mjuiState_* state, mjrContext_* con);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_error([MarshalAs(UnmanagedType.LPStr)]string msg);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_error_i([MarshalAs(UnmanagedType.LPStr)]string msg, int i);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_error_s([MarshalAs(UnmanagedType.LPStr)]string msg, [MarshalAs(UnmanagedType.LPStr)]string text);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_warning([MarshalAs(UnmanagedType.LPStr)]string msg);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_warning_i([MarshalAs(UnmanagedType.LPStr)]string msg, int i);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_warning_s([MarshalAs(UnmanagedType.LPStr)]string msg, [MarshalAs(UnmanagedType.LPStr)]string text);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_clearHandlers();
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void* mju_malloc(uint size);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_free(void* ptr);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mj_warning(mjData_* d, int warning, int info);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_writeLog([MarshalAs(UnmanagedType.LPStr)]string type, [MarshalAs(UnmanagedType.LPStr)]string msg);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_zero3(double* res);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_copy3(double* res, double* data);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_scl3(double* res, double* vec, double scl);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_add3(double* res, double* vec1, double* vec2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_sub3(double* res, double* vec1, double* vec2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_addTo3(double* res, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_subFrom3(double* res, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_addToScl3(double* res, double* vec, double scl);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_addScl3(double* res, double* vec1, double* vec2, double scl);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_normalize3(double* res);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_norm3(double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_dot3(double* vec1, double* vec2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_dist3(double* pos1, double* pos2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_rotVecMat(double* res, double* vec, double* mat);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_rotVecMatT(double* res, double* vec, double* mat);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_cross(double* res, double* a, double* b);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_zero4(double* res);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_unit4(double* res);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_copy4(double* res, double* data);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_normalize4(double* res);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_zero(double* res, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_copy(double* res, double* data, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_sum(double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_L1(double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_scl(double* res, double* vec, double scl, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_add(double* res, double* vec1, double* vec2, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_sub(double* res, double* vec1, double* vec2, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_addTo(double* res, double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_subFrom(double* res, double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_addToScl(double* res, double* vec, double scl, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_addScl(double* res, double* vec1, double* vec2, double scl, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_normalize(double* res, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_norm(double* res, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_dot(double* vec1, double* vec2, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mulMatVec(double* res, double* mat, double* vec, int nr, int nc);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mulMatTVec(double* res, double* mat, double* vec, int nr, int nc);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_transpose(double* res, double* mat, int nr, int nc);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mulMatMat(double* res, double* mat1, double* mat2, int r1, int c1, int c2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mulMatMatT(double* res, double* mat1, double* mat2, int r1, int c1, int r2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mulMatTMat(double* res, double* mat1, double* mat2, int r1, int c1, int c2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_sqrMatTD(double* res, double* mat, double* diag, int nr, int nc);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_transformSpatial(double* res, double* vec, int flg_force, double* newpos, double* oldpos, double* rotnew2old);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_rotVecQuat(double* res, double* vec, double* quat);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_negQuat(double* res, double* quat);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mulQuat(double* res, double* quat1, double* quat2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mulQuatAxis(double* res, double* quat, double* axis);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_axisAngle2Quat(double* res, double* axis, double angle);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_quat2Vel(double* res, double* quat, double dt);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_subQuat(double* res, double* qa, double* qb);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_quat2Mat(double* res, double* quat);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mat2Quat(double* quat, double* mat);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_derivQuat(double* res, double* quat, double* vel);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_quatIntegrate(double* quat, double* vel, double scale);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_quatZ2Vec(double* quat, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_mulPose(double* posres, double* quatres, double* pos1, double* quat1, double* pos2, double* quat2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_negPose(double* posres, double* quatres, double* pos, double* quat);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_trnVecPose(double* res, double* pos, double* quat, double* vec);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mju_cholFactor(double* mat, int n, double mindiag);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_cholSolve(double* res, double* mat, double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mju_cholUpdate(double* mat, double* x, int n, int flg_plus);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mju_eig3(double* eigval, double* eigvec, double* quat, double* mat);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_muscleGain(double len, double vel, double* lengthrange, double acc0, double* prm);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_muscleBias(double len, double* lengthrange, double acc0, double* prm);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_muscleDynamics(double ctrl, double act, double* prm);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_encodePyramid(double* pyramid, double* force, double* mu, int dim);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_decodePyramid(double* force, double* pyramid, double* mu, int dim);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_springDamper(double pos0, double vel0, double Kp, double Kv, double dt);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_min(double a, double b);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_max(double a, double b);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_sign(double x);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mju_round(double x);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+[return: MarshalAs(UnmanagedType.LPStr)]
+public static unsafe extern string mju_type2Str(int type);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mju_str2Type([MarshalAs(UnmanagedType.LPStr)]string str);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+[return: MarshalAs(UnmanagedType.LPStr)]
+public static unsafe extern string mju_warningText(int warning, int info);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mju_isBad(double x);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern int mju_isZero(double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_standardNormal(double* num2);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_f2n(double* res, float* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_n2f(float* res, double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_d2n(double* res, double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_n2d(double* res, double* vec, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_insertionSort(double* list, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern void mju_insertionSortInt(int* list, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_Halton(int index, int base_);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+[return: MarshalAs(UnmanagedType.LPStr)]
+public static unsafe extern string mju_strncpy(StringBuilder dst, [MarshalAs(UnmanagedType.LPStr)]string src, int n);
+
+[DllImport("mujoco", CallingConvention = CallingConvention.Cdecl)]
+public static unsafe extern double mju_sigmoid(double x);
+}
+}
diff --git a/unity/Runtime/Bindings/MujocoBindings.cs.meta b/unity/Runtime/Bindings/MujocoBindings.cs.meta
new file mode 100644
index 00000000..a04cd6e0
--- /dev/null
+++ b/unity/Runtime/Bindings/MujocoBindings.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6bffff449e27e88308992f7b9ce821e1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components.meta b/unity/Runtime/Components.meta
new file mode 100644
index 00000000..d75ae487
--- /dev/null
+++ b/unity/Runtime/Components.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 49cbe951a7bc505f39a1762fe932f068
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/IMjShape.cs b/unity/Runtime/Components/IMjShape.cs
new file mode 100644
index 00000000..1b4ecd77
--- /dev/null
+++ b/unity/Runtime/Components/IMjShape.cs
@@ -0,0 +1,46 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Functionality that needs to be implemented for each shape type.
+public interface IMjShape {
+
+  // Generate the Mjcf representation of the shape. Infer the scale of the shape from the transform.
+  void ToMjcf(XmlElement mjcf, Transform transform);
+
+  // Parse the shape settings from the specified Mjcf node.
+  void FromMjcf(XmlElement mjcf);
+
+  // Build a parametric mesh (vertices, triangles) of this shape.
+  Tuple<Vector3[], int[]> BuildMesh();
+
+  // Generate a timestamp that can be used to quickly compare if the settings of a shape
+  // have changed.
+  // The timestamp should also allow to distinguish between different types of shapes.
+  //
+  // Because most of shapes use at most 3 floating point values as parameters, we will
+  // use the first 3 components of the returned Vector4 to store those values. We will store
+  // the id of the shape in the 4th component. That id will be derrived from MjShapeComponent.ShapeTypes
+  // enum.
+  Vector4 GetChangeStamp();
+
+  // Draw a debug gizmo for the shape.
+  void DebugDraw(Transform transform);
+}
+}
diff --git a/unity/Runtime/Components/IMjShape.cs.meta b/unity/Runtime/Components/IMjShape.cs.meta
new file mode 100644
index 00000000..0be1c1ad
--- /dev/null
+++ b/unity/Runtime/Components/IMjShape.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: f4b869d65e8404f3aa92042bbd7b9c43
+timeCreated: 1547647082
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MeshGenerators.cs b/unity/Runtime/Components/MeshGenerators.cs
new file mode 100644
index 00000000..b6e19d64
--- /dev/null
+++ b/unity/Runtime/Components/MeshGenerators.cs
@@ -0,0 +1,360 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEngine;
+
+namespace Mujoco {
+
+public static class MeshGenerators {
+
+  // Creates a sphere mesh geometry.
+  //
+  // Args:
+  //  scale: Non-uniform sphere scale. Allows to create ellipsoid shapes.
+  //  numVerticalSlices: How many vertices should there be in a single horizontal slice.
+  //  numHorizontalSlices: How many horizontal slices should the sphere consist of.
+  public static Tuple<Vector3[], int[]> BuildSphere(
+      Vector3 scale, int numVerticalSlices = 16, int numHorizontalSlices = 16) {
+    // Generate the vertices.
+    Vector3[] vertices;
+    int[] triangles;
+    GenerateSphereMeshSlice(
+        scale: scale,
+        numVerticalSlices: numVerticalSlices,
+        numHorizontalSlices: numHorizontalSlices,
+        firstSliceY: -1.0f,
+        lastSliceY: 1.0f,
+        vertices: out vertices,
+        triangles: out triangles);
+    return Tuple.Create(vertices, triangles);
+  }
+
+  // Creates a cylinder mesh geometry.
+  //
+  // Args:
+  //  radius: Radius of the cylider's body.
+  //  height: Height of the cylinder, from its bottom to its top base.
+  //  numVerticalSlices: How many vertices should there be around the base's circumference.
+  public static Tuple<Vector3[], int[]> BuildCylinder(
+      float radius, float height, int numVerticalSlices = 16) {
+    Vector3[] bodyVertices;
+    int[] bodyTriangles;
+    GenerateCylinderBody(radius, height, numVerticalSlices, out bodyVertices, out bodyTriangles);
+
+    Vector3[] baseCapVertices;
+    int[] baseCapTriangles;
+    GenerateCylinderBaseCaps(
+        radius, height, numVerticalSlices, out baseCapVertices, out baseCapTriangles);
+
+    var merger = new MeshMerger();
+    merger.Add(bodyVertices, bodyTriangles);
+    merger.Add(baseCapVertices, baseCapTriangles);
+    return Tuple.Create(merger.Vertices, merger.Triangles);
+  }
+
+  // Creates a capsule mesh geometry.
+  //
+  // Args:
+  //  radius: Radius of the capsule's body.
+  //  height: Height of the capsule, from its bottom to its top base.
+  //  numVerticalSlices: How many vertices should there be in a single horizontal slice.
+  //  numHorizontalSlices: How many vertical slices should the sphere consist of.
+  public static Tuple<Vector3[], int[]> BuildCapsule(
+      float radius, float height, int numVerticalSlices = 16, int numHorizontalSlices = 16) {
+    var baseHalfHeight = Math.Max(0.0f, height * 0.5f - radius);
+    Vector3[] topCapVertices;
+    int[] topCapTriangles;
+    GenerateSphereMeshSlice(
+        scale: Vector3.one * radius,
+        numVerticalSlices: numVerticalSlices,
+        numHorizontalSlices: numHorizontalSlices / 2,
+        firstSliceY: -1.0f,
+        lastSliceY: 0.0f,
+        vertices: out topCapVertices,
+        triangles: out topCapTriangles);
+
+    Vector3[] bottomCapVertices;
+    int[] bottomCapTriangles;
+    GenerateSphereMeshSlice(
+        scale: Vector3.one * radius,
+        numVerticalSlices: numVerticalSlices,
+        numHorizontalSlices: numHorizontalSlices / 2,
+        firstSliceY: 0.0f,
+        lastSliceY: 1.0f,
+        vertices: out bottomCapVertices,
+        triangles: out bottomCapTriangles);
+
+    Vector3[] bodyVertices;
+    int[] bodyTriangles;
+    GenerateCylinderBody(
+        radius: radius,
+        height: baseHalfHeight * 2.0f,
+        numVerticalSlices: numVerticalSlices,
+        vertices: out bodyVertices,
+        triangles: out bodyTriangles);
+
+    var merger = new MeshMerger();
+    merger.AddAndTranslate(topCapVertices, topCapTriangles, Vector3.up * baseHalfHeight * -1.0f);
+    merger.AddAndTranslate(
+        bottomCapVertices, bottomCapTriangles, Vector3.up * baseHalfHeight * 1.0f);
+    merger.Add(bodyVertices, bodyTriangles);
+    return Tuple.Create(merger.Vertices, merger.Triangles);
+  }
+
+  // Creates a box mesh geometry.
+  //
+  // Args:
+  //  extents: Extents of the box, along each major axis.
+  public static Tuple<Vector3[], int[]> BuildBox(Vector3 extents) {
+    // In order to ensure the box renders with flat faces, we need to make sure the triangles
+    // do not share vertices. We'll accomplish that by assigning a unique vertex to every triangle
+    // apex.
+    // We define a set of 8 vertex positions that form the box, and then sample from that set using
+    // triangle indices.
+    var vertexPositions = new Vector3[] {
+      Vector3.Scale(new Vector3(-1, -1, -1), extents),
+      Vector3.Scale(new Vector3(1, -1, -1), extents),
+      Vector3.Scale(new Vector3(-1, -1, 1), extents),
+      Vector3.Scale(new Vector3(1, -1, 1), extents),
+      Vector3.Scale(new Vector3(-1, 1, -1), extents),
+      Vector3.Scale(new Vector3(1, 1, -1), extents),
+      Vector3.Scale(new Vector3(-1, 1, 1), extents),
+      Vector3.Scale(new Vector3(1, 1, 1), extents),
+    };
+    var vertexSamplingPattern = new int[] {
+      0, 1, 3, 0, 3, 2,
+      4, 7, 5, 4, 6, 7,
+      0, 5, 1, 0, 4, 5,
+      1, 7, 3, 1, 5, 7,
+      3, 6, 2, 3, 7, 6,
+      2, 4, 0, 2, 6, 4,
+    };
+
+    var vertices = vertexSamplingPattern.Select(index => vertexPositions[index]).ToArray();
+    var triangles = Enumerable.Range(0, vertexSamplingPattern.Length).ToArray();
+    return Tuple.Create(vertices, triangles);
+  }
+
+  // Creates a plane mesh geometry.
+  //
+  // Args:
+  //  width: Width of the plane, along the OX axis.
+  //  height: Height of the plane, along the OZ axis.
+  public static Tuple<Vector3[], int[]> BuildPlane(float width, float height) {
+    var vertices = new Vector3[] {
+      new Vector3(-0.5f * width, 0, -0.5f * height),
+      new Vector3(0.5f * width, 0, -0.5f * height),
+      new Vector3(-0.5f * width, 0, 0.5f * height),
+      new Vector3(0.5f * width, 0, 0.5f * height),
+    };
+    var triangles = new int[] {
+      0, 3, 1,
+      0, 2, 3,
+    };
+    return Tuple.Create(vertices, triangles);
+  }
+
+  // Generates a slice of a sphere mesh.
+  // Conceptually, the algorithm generates a sphere with a unit radius (spanning from -1 to 1 along
+  // each of the major axes). Then, it cuts it using 2 planes parallel to the XZ plane, located at
+  // distances defined by 'firstSliceY' and 'lastSliceY' parameters respectively. It then returns
+  // the section of the mesh contained between those planes.
+  //
+  // This allows to use the method to generate variants of the sphere - full sphere, hemispheres.
+  //
+  // Args:
+  //  scale: Non-uniform sphere scale. Allows to create ellipsoid shapes.
+  //  numVerticalSlices: How many vertices should there be in a single horizontal slice.
+  //  numHorizontalSlices: How many horizontal slices should the sphere consist of.
+  //  firstSliceY: Vertical position of the first slice. Must be a value in range <-1, 1>.
+  //  lastSliceY: Vertical position of the last slice. Must a value in range <-1, 1>.
+  //  vertices: (Out) Array of sphere vertex positions.
+  //  triangles: (Out) Array with the sphere triangle connectivity.
+  private static void GenerateSphereMeshSlice(
+      Vector3 scale, int numVerticalSlices, int numHorizontalSlices, float firstSliceY,
+      float lastSliceY, out Vector3[] vertices, out int[] triangles) {
+    numVerticalSlices = Math.Max(3, numVerticalSlices);
+    numHorizontalSlices = Math.Max(3, numHorizontalSlices);
+    triangles = new int[(numHorizontalSlices - 1) * numVerticalSlices * 6];
+    vertices = new Vector3[numVerticalSlices * numHorizontalSlices];
+    if (firstSliceY < -1.0f || firstSliceY > 1.0f) {
+      throw new IOException("firstSliceY should be a value in range <-1, 1>");
+    }
+    if (lastSliceY < -1.0f || lastSliceY > 1.0f) {
+      throw new IOException("lastSliceY should be a value in range <-1, 1>");
+    }
+    if (firstSliceY > lastSliceY) {
+      throw new IOException("Value of firstSliceY should be lower than the value of lastSliceY.");
+    }
+    // Generate the vertices.
+    var deltaY = (lastSliceY - firstSliceY) / (numHorizontalSlices - 1);
+    var deltaYaw = 360.0f / numVerticalSlices;
+    for (var slice = 0; slice < numHorizontalSlices; ++slice) {
+      var y = firstSliceY + deltaY * slice;
+      var radius = (float)Math.Sqrt(1 - Math.Min(1.0f, y * y));
+      for (var vertex = 0; vertex < numVerticalSlices; ++vertex) {
+        var position = Quaternion.AngleAxis(deltaYaw * vertex, Vector3.up) * Vector3.right * radius;
+        position.y = y;
+        vertices[slice * numVerticalSlices + vertex] = Vector3.Scale(position, scale);
+      }
+    }
+    // Build the triangles.
+    for (var slice = 0; slice < (numHorizontalSlices - 1); ++slice) {
+      var firstVertexInSlice = slice * numVerticalSlices;
+      for (var vertex = 0; vertex < numVerticalSlices; ++vertex) {
+        var index1 = firstVertexInSlice + vertex;
+        var index2 = (vertex + 1 == numVerticalSlices) ? firstVertexInSlice : index1 + 1;
+        var index3 = index1 + numVerticalSlices;
+        var index4 = index2 + numVerticalSlices;
+        var quadBaseAddress = (slice * numVerticalSlices + vertex) * 6;
+        triangles[quadBaseAddress] = index1;
+        triangles[quadBaseAddress + 1] = index2;
+        triangles[quadBaseAddress + 2] = index4;
+        triangles[quadBaseAddress + 3] = index1;
+        triangles[quadBaseAddress + 4] = index4;
+        triangles[quadBaseAddress + 5] = index3;
+      }
+    }
+  }
+
+  // Generates the cylinder mesh vertices.
+  // This functionality will be shared between the cylinder body and cylinder base caps generators.
+  //
+  // Args:
+  //  radius: Cylinder radius.
+  //  height: Cylinder height.
+  //  numVerticalSlices: How many vertices should there be around the base's circumference.
+  //  vertices: (Out) Array of sphere vertex positions.
+  private static void GenerateCylinderVertices(
+      float radius, float height, int numVerticalSlices, out Vector3[] vertices) {
+    vertices = new Vector3[numVerticalSlices * 2];
+    var dYaw = 360.0f / numVerticalSlices;
+    var yaw = 0.0f;
+    var vertexIndex = 0;
+    for (var y = 0; y <= 1; ++y) {
+      var yPos = (y - 0.5f) * height;
+      for (var i = 0; i < numVerticalSlices; ++i, yaw += dYaw) {
+        var vertexPosition = Quaternion.AngleAxis(yaw, Vector3.up) * Vector3.right * radius;
+        vertexPosition.y = yPos;
+        vertices[vertexIndex++] = vertexPosition;
+      }
+    }
+  }
+
+  // Generates the meshes for the cylinder body, excluding its bases.
+  //
+  // Args:
+  //  radius: Cylinder radius.
+  //  height: Cylinder height.
+  //  numVerticalSlices: How many vertices should there be around the base's circumference.
+  //  vertices: (Out) Array of sphere vertex positions.
+  //  triangles: (Out) Array with the sphere triangle connectivity.
+  private static void GenerateCylinderBody(
+      float radius, float height, int numVerticalSlices, out Vector3[] vertices,
+      out int[] triangles) {
+    GenerateCylinderVertices(radius, height, numVerticalSlices, out vertices);
+    triangles = new int[numVerticalSlices * 6];
+    var apexIndex = 0;
+    for (var i = 0; i < numVerticalSlices; ++i) {
+      var v1 = i;
+      var v2 = (i + 1 == numVerticalSlices) ? 0 : v1 + 1;
+      var v3 = v1 + numVerticalSlices;
+      var v4 = v2 + numVerticalSlices;
+      triangles[apexIndex++] = v1;
+      triangles[apexIndex++] = v2;
+      triangles[apexIndex++] = v4;
+      triangles[apexIndex++] = v1;
+      triangles[apexIndex++] = v4;
+      triangles[apexIndex++] = v3;
+    }
+  }
+
+  // Generates the meshes for the cylinder base circles.
+  //
+  // Args:
+  //  radius: Cylinder radius.
+  //  height: Cylinder height.
+  //  numVerticalSlices: How many vertices should there be around the base's circumference.
+  //  vertices: (Out) Array of sphere vertex positions.
+  //  triangles: (Out) Array with the sphere triangle connectivity.
+  private static void GenerateCylinderBaseCaps(
+      float radius, float height, int numVerticalSlices, out Vector3[] vertices,
+      out int[] triangles) {
+    GenerateCylinderVertices(radius, height, numVerticalSlices, out vertices);
+    triangles = new int[(numVerticalSlices - 1) * 6];
+    var apexIndex = 0;
+    for (var baseIdx = 0; baseIdx <= 1; ++baseIdx) {
+      var v1 = baseIdx * numVerticalSlices;
+      for (var i = 1; i < numVerticalSlices; ++i) {
+        var v2 = v1 + (i % numVerticalSlices);
+        var v3 = v1 + ((i + 1) % numVerticalSlices);
+        triangles[apexIndex++] = v1;
+        triangles[apexIndex++] = baseIdx == 0 ? v3 : v2;
+        triangles[apexIndex++] = baseIdx == 0 ? v2 : v3;
+      }
+    }
+  }
+}
+
+// A tool used to merge the geometry of separate meshes.
+public class MeshMerger {
+  private List<Vector3> _vertices = new List<Vector3>();
+  private List<int> _triangles = new List<int>();
+
+  // The vertices of the merged mesh.
+  public Vector3[] Vertices => _vertices.ToArray();
+
+  // The connectivity array of the merged mesh.
+  public int[] Triangles => _triangles.ToArray();
+
+  // Adds a new submesh.
+  //
+  // Args:
+  //  vertices: Array of submesh vertices.
+  //  vertices: Triangles connectivity array of the submesh.
+  public void Add(Vector3[] vertices, int[] triangles) {
+    var triangleOffset = _triangles.Count;
+    var vertexOffset = _vertices.Count;
+    _vertices.AddRange(vertices);
+    _triangles.AddRange(triangles);
+    for (var i = triangleOffset; i < _triangles.Count; ++i) {
+      _triangles[i] += vertexOffset;
+    }
+  }
+
+  // Adds a new submesh, translating its vertices by a specified amount.
+  //
+  // Args:
+  //  vertices: Array of submesh vertices.
+  //  vertices: Triangles connectivity array of the submesh.
+  //  translation: Additional translation to be applied to the submesh.
+  public void AddAndTranslate(Vector3[] vertices, int[] triangles, Vector3 translation) {
+    var triangleOffset = _triangles.Count;
+    var vertexOffset = _vertices.Count;
+    _vertices.AddRange(vertices);
+    for (var i = vertexOffset; i < _vertices.Count; ++i) {
+      _vertices[i] += translation;
+    }
+    _triangles.AddRange(triangles);
+    for (var i = triangleOffset; i < _triangles.Count; ++i) {
+      _triangles[i] += vertexOffset;
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Components/MeshGenerators.cs.meta b/unity/Runtime/Components/MeshGenerators.cs.meta
new file mode 100644
index 00000000..4b85347f
--- /dev/null
+++ b/unity/Runtime/Components/MeshGenerators.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: deb4d8c01485d4e44bc815b133e707c0
+timeCreated: 1539115944
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjActuator.cs b/unity/Runtime/Components/MjActuator.cs
new file mode 100644
index 00000000..3eec1d31
--- /dev/null
+++ b/unity/Runtime/Components/MjActuator.cs
@@ -0,0 +1,394 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+// Actuators provide means to set joints in motion.
+public class MjActuator : MjComponent {
+
+  public enum ActuatorType {
+    General,
+    Motor,
+    Position,
+    Velocity,
+    Cylinder,
+    Muscle
+  }
+
+  // This structure holds the parameters shared by all types of actuators.
+  //
+  // All constants found in this class are copied from the official documentation, and can be found
+  // here: http://mujoco.org/book/XMLreference.html#actuator
+  [Serializable]
+  public class CommonParameters {
+
+    // If true, the control input to this actuator is automatically clamped to ctrlrange at runtime.
+    // If false, control input clamping is disabled.
+    public bool CtrlLimited;
+
+    // If true, the force output of this actuator is automatically clamped to forcerange at runtime.
+    // If false, force output clamping is disabled.
+    public bool ForceLimited;
+
+    // Range for clamping the control input.
+    public Vector2 CtrlRange;
+
+    // Range for clamping the force output.
+    public Vector2 ForceRange;
+
+    // Range of feasible lengths of the actuator's transmission.
+    public Vector2 LengthRange;
+
+    // This attribute scales the length (and consequently moment arms, velocity and force) of the
+    // actuator, for all transmission types. It is different from the gain in the force generation
+    // mechanism, because the gain only scales the force output and does not affect the length,
+    // moment arms and velocity.
+    public List<float> Gear = new List<float>() { 1.0f };
+
+    public void ToMjcf(XmlElement mjcf) {
+      mjcf.SetAttribute("ctrllimited", $"{CtrlLimited}".ToLowerInvariant());
+      mjcf.SetAttribute("forcelimited", $"{ForceLimited}".ToLowerInvariant());
+      mjcf.SetAttribute(
+          "ctrlrange",
+          $"{MjEngineTool.GetSorted(CtrlRange).x} {MjEngineTool.GetSorted(CtrlRange).y}");
+      mjcf.SetAttribute(
+          "forcerange",
+          $"{MjEngineTool.GetSorted(ForceRange).x} {MjEngineTool.GetSorted(ForceRange).y}");
+      mjcf.SetAttribute(
+          "lengthrange",
+          $"{MjEngineTool.GetSorted(LengthRange).x} {MjEngineTool.GetSorted(LengthRange).y}");
+      mjcf.SetAttribute("gear", MjEngineTool.ListToMjcf(Gear));
+    }
+
+    public void FromMjcf(XmlElement mjcf) {
+      CtrlLimited = mjcf.GetBoolAttribute("ctrllimited", defaultValue: false);
+      ForceLimited = mjcf.GetBoolAttribute("forcelimited", defaultValue: false);
+      CtrlRange = mjcf.GetVector2Attribute("ctrlrange", defaultValue: Vector2.zero);
+      ForceRange = mjcf.GetVector2Attribute("forcerange", defaultValue: Vector2.zero);
+      LengthRange = mjcf.GetVector2Attribute("lengthrange", defaultValue: Vector2.zero);
+      Gear = mjcf.GetFloatArrayAttribute("gear", defaultValue: new float[] { 1.0f }).ToList();
+    }
+  }
+
+  // This structure holds all parameters unique to each type of the actuator.
+  //
+  // Because UnityEditor doesn't handle polymorphism well, I decided to put all parameters here
+  // and then create a custom editor (MjActuatorEditor), that will display only the values
+  // relevant to the selected articulation type. The choice will be made based on the value of
+  // the 'Type' field.
+  //
+  // All constants found in this class are copied from the official documentation, and can be found
+  // here: http://mujoco.org/book/XMLreference.html#actuator
+  [Serializable]
+  public class CustomParameters {
+
+    //// General actuator parameters.
+
+    // Activation dynamics type for the actuator.
+    public MujocoLib.mjtDyn DynType;
+
+    // The gain and bias together determine the output of the force generation mechanism, which is
+    // currently assumed to be affine. As already explained in Actuation model, the general formula
+    // is:
+    //   scalar_force = gain_term * (act or ctrl) + bias_term.
+    // The formula uses the activation state when present, and the control otherwise.
+    public MujocoLib.mjtGain GainType;
+
+    // Bias type.
+    public MujocoLib.mjtBias BiasType;
+
+    // Activation dynamics parameters. The built-in activation types (except for muscle) use only
+    // the first parameter, but we provide additional parameters in case user callbacks implement a
+    // more elaborate model. The length of this array is not enforced by the parser, so the user can
+    // enter as many parameters as needed.
+    public List<float> DynPrm = new List<float>() { 1.0f, 0.0f, 0.0f };
+
+    // Gain parameters. The built-in gain types (except for muscle) use only the first parameter,
+    // but we provide additional parameters in case user callbacks implement a more elaborate model.
+    // The length of this array is not enforced by the parser, so the user can enter as many
+    // parameters as needed.
+    public List<float> GainPrm = new List<float>() { 1.0f, 0.0f, 0.0f };
+
+    // Bias parameters. The affine bias type uses three parameters. The length of this array is not
+    // enforced by the parser, so the user can enter as many parameters as needed.
+    public List<float> BiasPrm = new List<float>() { 0.0f, 0.0f, 0.0f };
+
+    public void GeneralToMjcf(XmlElement mjcf) {
+      mjcf.SetAttribute("dyntype", $"{DynType}".Substring(6).ToLowerInvariant());
+      mjcf.SetAttribute("gaintype", $"{GainType}".Substring(7).ToLowerInvariant());
+      mjcf.SetAttribute("biastype", $"{BiasType}".Substring(7).ToLowerInvariant());
+      mjcf.SetAttribute("dynprm", MjEngineTool.ListToMjcf(DynPrm));
+      mjcf.SetAttribute("gainprm", MjEngineTool.ListToMjcf(GainPrm));
+      mjcf.SetAttribute("biasprm", MjEngineTool.ListToMjcf(BiasPrm));
+    }
+
+    public void GeneralFromMjcf(XmlElement mjcf) {
+      var dynTypeStr = mjcf.GetStringAttribute("dyntype", defaultValue: "none");
+      var gainTypeStr = mjcf.GetStringAttribute("gaintype", defaultValue: "fixed");
+      var biasTypeStr = mjcf.GetStringAttribute("biastype", defaultValue: "none");
+      var ignoreCase = true;
+      Enum.TryParse<MujocoLib.mjtDyn>($"mjdyn_{dynTypeStr}", ignoreCase, out DynType);
+      Enum.TryParse<MujocoLib.mjtGain>($"mjgain_{gainTypeStr}", ignoreCase, out GainType);
+      Enum.TryParse<MujocoLib.mjtBias>($"mjbias_{biasTypeStr}", ignoreCase, out BiasType);
+
+      DynPrm = mjcf.GetFloatArrayAttribute(
+        "dynprm", defaultValue: new float[] { 1.0f, 0.0f, 0.0f }).ToList();
+      GainPrm = mjcf.GetFloatArrayAttribute(
+        "gainprm", defaultValue: new float[] { 1.0f, 0.0f, 0.0f }).ToList();
+      BiasPrm = mjcf.GetFloatArrayAttribute(
+        "biasprm", defaultValue: new float[] { 0.0f, 0.0f, 0.0f }).ToList();
+    }
+
+    //// Position actuator parameters.
+
+    // Position feedback gain.
+    [AbsoluteValue]
+    public float Kp = 1.0f;
+
+    public void PositionToMjcf(XmlElement mjcf) {
+      mjcf.SetAttribute("kp", $"{Math.Abs(Kp)}");
+    }
+    public void PositionFromMjcf(XmlElement mjcf) {
+      Kp = mjcf.GetFloatAttribute("kp", defaultValue: 1.0f);
+    }
+
+    //// Velocity actuator parameters.
+
+    // Velocity feedback gain.
+    [AbsoluteValue]
+    public float Kv = 1.0f;
+
+    public void VelocityToMjcf(XmlElement mjcf) {
+      mjcf.SetAttribute("kv", $"{Math.Abs(Kv)}");
+    }
+    public void VelocityFromMjcf(XmlElement mjcf) {
+      Kv = mjcf.GetFloatAttribute("kv", defaultValue: 1.0f);
+    }
+
+    //// Cylinder actuator parameters.
+
+    // Time constant of the activation dynamics.
+    public float CylinderTimeConst = 1.0f;
+
+    // Area of the cylinder. This is used internally as actuator gain.
+    [AbsoluteValue]
+    public float Area = 1.0f;
+
+    // Instead of area the user can specify diameter. If both are specified, diameter has
+    // precedence.
+    [AbsoluteValue]
+    public float Diameter = 0.0f;
+
+    // Bias parameters, copied internally into biasprm.
+    public float[] Bias = new float[] { 0.0f, 0.0f, 0.0f };
+
+    public void CylinderToMjcf(XmlElement mjcf) {
+      mjcf.SetAttribute("timeconst", $"{CylinderTimeConst}");
+      mjcf.SetAttribute("area", $"{Math.Abs(Area)}");
+      mjcf.SetAttribute("diameter", $"{Math.Abs(Diameter)}");
+      mjcf.SetAttribute("bias", MjEngineTool.ArrayToMjcf(Bias));
+    }
+
+    public void CylinderFromMjcf(XmlElement mjcf) {
+      CylinderTimeConst = mjcf.GetFloatAttribute("timeconst", defaultValue: 1.0f);
+      Area = mjcf.GetFloatAttribute("area", defaultValue: 1.0f);
+      Diameter = mjcf.GetFloatAttribute("diameter", defaultValue: 0.0f);
+      Bias = mjcf.GetFloatArrayAttribute("bias", defaultValue: new float[] { 0.0f, 0.0f, 0.0f });
+    }
+
+    //// Muscle actuator parameters.
+
+    // Time constants for activation and de-activation dynamics.
+    public Vector2 MuscleTimeConst = new Vector2(0.01f, 0.04f);
+
+    // Operating length range of the muscle, in units of L0.
+    public Vector2 Range = new Vector2(0.75f, 1.05f);
+
+    // Peak active force at rest. If this value is negative, the peak force is determined
+    // automatically using the scale attribute below.
+    public float Force = -1.0f;
+
+    // If the force attribute is negative, the peak active force for the muscle is set to this value
+    // divided by mjModel.actuator_acc0. The latter is the norm of the joint-space acceleration
+    // vector caused by unit force on the actuator's transmission in qpos0. In other words, scaling
+    // produces higher peak forces for muscles that pull more weight.
+    public float Scale = 200.0f;
+
+    // Lower position range of the normalized FLV curve, in units of L0.
+    public float LMin = 0.5f;
+
+    // Upper position range of the normalized FLV curve, in units of L0.
+    public float LMax = 1.6f;
+
+    // Shortening velocity at which muscle force drops to zero, in units of L0 per second.
+    public float VMax = 1.5f;
+
+    // Passive force generated at lmax, relative to the peak rest force.
+    public float FpMax = 1.3f;
+
+    // Active force generated at saturating lengthening velocity, relative to the peak rest force.
+    public float FvMax = 1.2f;
+
+    public void MuscleToMjcf(XmlElement mjcf) {
+      mjcf.SetAttribute("timeconst", $"{MuscleTimeConst[0]} {MuscleTimeConst[1]}");
+      mjcf.SetAttribute(
+        "range", $"{MjEngineTool.GetSorted(Range).x} {MjEngineTool.GetSorted(Range).y}");
+      mjcf.SetAttribute("force", $"{Force}");
+      mjcf.SetAttribute("scale", $"{Scale}");
+      mjcf.SetAttribute("lmin", $"{LMin}");
+      mjcf.SetAttribute("lmax", $"{LMax}");
+      mjcf.SetAttribute("vmax", $"{VMax}");
+      mjcf.SetAttribute("fpmax", $"{FpMax}");
+      mjcf.SetAttribute("fvmax", $"{FvMax}");
+    }
+
+    public void MuscleFromMjcf(XmlElement mjcf) {
+      MuscleTimeConst = mjcf.GetVector2Attribute(
+          "timeconst", defaultValue: new Vector2(0.01f, 0.04f));
+      Range = mjcf.GetVector2Attribute("range", defaultValue: new Vector2(0.75f, 1.05f));
+      Force = mjcf.GetFloatAttribute("force", defaultValue: -1.0f);
+      Scale = mjcf.GetFloatAttribute("scale", defaultValue: 200.0f);
+      LMin = mjcf.GetFloatAttribute("lmin", defaultValue: 0.5f);
+      LMax = mjcf.GetFloatAttribute("lmax", defaultValue: 1.6f);
+      VMax = mjcf.GetFloatAttribute("vmax", defaultValue: 1.5f);
+      FpMax = mjcf.GetFloatAttribute("fpmax", defaultValue: 1.3f);
+      FvMax = mjcf.GetFloatAttribute("fvmax", defaultValue: 1.2f);
+    }
+  }
+
+  public ActuatorType Type;
+
+  [Tooltip("Joint actuation target. Mutually exclusive with tendon target.")]
+  public MjBaseJoint Joint;
+
+  [Tooltip("Tendon actuation target. Mutually exclusive with joint target.")]
+  public MjBaseTendon Tendon;
+
+  [Tooltip("Parameters specific to each actuator type.")]
+  [HideInInspector]
+  public CustomParameters CustomParams = new CustomParameters();
+
+  [Tooltip("Parameters shared by all types of actuators.")]
+  public CommonParameters CommonParams = new CommonParameters();
+
+  [Tooltip("Actuator control.")]
+  public float Control;
+
+  // Actuator length.
+  public float Length { get; private set; }
+
+  // Actuator velocity.
+  public float Velocity { get; private set; }
+
+  // Actuator force.
+  public float Force { get; private set; }
+
+  public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_ACTUATOR;
+
+  // Parse the component settings from an external Mjcf.
+  protected override void OnParseMjcf(XmlElement mjcf) {
+    if (!Enum.TryParse(mjcf.Name, ignoreCase: true, result: out Type)) {
+      throw new ArgumentException($"Unknown actuator type {mjcf.Name}.");
+    }
+    CommonParams.FromMjcf(mjcf);
+    switch (Type) {
+      case MjActuator.ActuatorType.General: {
+        CustomParams.GeneralFromMjcf(mjcf);
+        break;
+      }
+      case MjActuator.ActuatorType.Position: {
+        CustomParams.PositionFromMjcf(mjcf);
+        break;
+      }
+      case MjActuator.ActuatorType.Velocity: {
+        CustomParams.VelocityFromMjcf(mjcf);
+        break;
+      }
+      case MjActuator.ActuatorType.Cylinder: {
+        CustomParams.CylinderFromMjcf(mjcf);
+        break;
+      }
+      case MjActuator.ActuatorType.Muscle: {
+        CustomParams.MuscleFromMjcf(mjcf);
+        break;
+      }
+    }
+    Joint = mjcf.GetObjectReferenceAttribute<MjBaseJoint>("joint");
+    Tendon = mjcf.GetObjectReferenceAttribute<MjBaseTendon>("tendon");
+  }
+
+  // Generate implementation specific XML element.
+  protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+    if (Joint == null && Tendon == null) {
+      throw new InvalidOperationException($"Actuator {name} is not assigned a joint nor tendon.");
+    }
+    if (Joint != null && Tendon != null) {
+      throw new InvalidOperationException(
+        $"Actuator {name} can't have both a tendon and a joint target.");
+    }
+
+    var mjcf = doc.CreateElement(Type.ToString().ToLowerInvariant());
+    if (Joint != null) {
+      mjcf.SetAttribute("joint", Joint.MujocoName);
+    } else {
+      mjcf.SetAttribute("tendon", Tendon.MujocoName);
+    }
+    CommonParams.ToMjcf(mjcf);
+
+    switch (Type) {
+      case MjActuator.ActuatorType.General: {
+        CustomParams.GeneralToMjcf(mjcf);
+        break;
+      }
+      case MjActuator.ActuatorType.Position: {
+        CustomParams.PositionToMjcf(mjcf);
+        break;
+      }
+      case MjActuator.ActuatorType.Velocity: {
+        CustomParams.VelocityToMjcf(mjcf);
+        break;
+      }
+      case MjActuator.ActuatorType.Cylinder: {
+        CustomParams.CylinderToMjcf(mjcf);
+        break;
+      }
+      case MjActuator.ActuatorType.Muscle: {
+        CustomParams.MuscleToMjcf(mjcf);
+        break;
+      }
+    }
+    return mjcf;
+  }
+
+  // Synchronize the state of the component.
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    data->ctrl[MujocoId] = Control;
+    Length = (float)data->actuator_length[MujocoId];
+    Velocity = (float)data->actuator_velocity[MujocoId];
+    Force = (float)data->actuator_force[MujocoId];
+  }
+
+  public void OnValidate() {
+    if (Joint != null && Tendon != null) {
+      Debug.LogError(
+          $"Actuator {name} can't have both a tendon and a joint target.", this);
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjActuator.cs.meta b/unity/Runtime/Components/MjActuator.cs.meta
new file mode 100644
index 00000000..709d85f5
--- /dev/null
+++ b/unity/Runtime/Components/MjActuator.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c3f3a0cb6a6d64327b27c7d5bdd8d430
+timeCreated: 1546881319
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjActuatorScalarSensor.cs b/unity/Runtime/Components/MjActuatorScalarSensor.cs
new file mode 100644
index 00000000..4c6f4e2b
--- /dev/null
+++ b/unity/Runtime/Components/MjActuatorScalarSensor.cs
@@ -0,0 +1,54 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+public class MjActuatorScalarSensor : MjBaseSensor {
+  // NOTE: These names must match sensor names listed on mujoco.org.
+  // Changing them is justified only when Mujoco is upgraded to a new version.
+  public enum AvailableSensors {
+    ActuatorPos,
+    ActuatorVel,
+    ActuatorFrc,
+  }
+  public AvailableSensors SensorType;
+  public MjActuator Actuator;
+
+  public double SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Actuator == null) {
+      throw new NullReferenceException("Missing a reference to a MjActuator.");
+    }
+    var mjcf = doc.CreateElement(SensorType.ToString().ToLower());
+    mjcf.SetAttribute("actuator", Actuator.MujocoName);
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    if (!Enum.TryParse(mjcf.Name, ignoreCase: true, result: out SensorType)) {
+      throw new ArgumentException($"Unknown sensor type {mjcf.Name}.");
+    }
+    Actuator = mjcf.GetObjectReferenceAttribute<MjActuator>("actuator");
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    SensorReading = data->sensordata[_sensorAddress];
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjActuatorScalarSensor.cs.meta b/unity/Runtime/Components/MjActuatorScalarSensor.cs.meta
new file mode 100644
index 00000000..5bcba51d
--- /dev/null
+++ b/unity/Runtime/Components/MjActuatorScalarSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9d6f957ac545d4e8ea581fcc861a0498
+timeCreated: 1548092931
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBallJoint.cs b/unity/Runtime/Components/MjBallJoint.cs
new file mode 100644
index 00000000..b5513f30
--- /dev/null
+++ b/unity/Runtime/Components/MjBallJoint.cs
@@ -0,0 +1,52 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  // The component represents a joint with 1 degree of translational freedom.
+  public class MjBallJoint : MjBaseJoint {
+    [Tooltip("In radians.")]
+    public float RangeUpper;
+
+    [Tooltip("Joint settings.")]
+    public MjJointSettings Settings = MjJointSettings.Default;
+
+    protected override void OnParseMjcf(XmlElement mjcf) {
+      // Transform.
+      transform.localPosition =
+          MjEngineTool.UnityVector3(mjcf.GetVector3Attribute("pos", defaultValue: Vector3.zero));
+
+      Settings.FromMjcf(mjcf);
+      var rangeValues = mjcf.GetFloatArrayAttribute("range", defaultValue: new float[] { 0, 0 });
+      // rangeValues[0] is always 0 for ball joints.
+      RangeUpper = rangeValues[1];
+    }
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      var mjcf = (XmlElement)doc.CreateElement("joint");
+      mjcf.SetAttribute("type", "ball");
+
+      MjEngineTool.PositionToMjcf(mjcf, this);
+
+      Settings.ToMjcf(mjcf);
+      mjcf.SetAttribute("range", $"0 {RangeUpper}");
+
+      return mjcf;
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjBallJoint.cs.meta b/unity/Runtime/Components/MjBallJoint.cs.meta
new file mode 100644
index 00000000..274f27db
--- /dev/null
+++ b/unity/Runtime/Components/MjBallJoint.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: bc71be844486c4586ba729c1ab4d914a
+timeCreated: 1552056297
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBaseBody.cs b/unity/Runtime/Components/MjBaseBody.cs
new file mode 100644
index 00000000..98c46f71
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseBody.cs
@@ -0,0 +1,24 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public abstract class MjBaseBody : MjComponent {
+    public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_BODY;
+  }
+}
diff --git a/unity/Runtime/Components/MjBaseBody.cs.meta b/unity/Runtime/Components/MjBaseBody.cs.meta
new file mode 100644
index 00000000..e63ac5af
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseBody.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 088eb1d485bd54fcaa1061c79b289dde
+timeCreated: 1551357866
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBaseConstraint.cs b/unity/Runtime/Components/MjBaseConstraint.cs
new file mode 100644
index 00000000..c543320f
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseConstraint.cs
@@ -0,0 +1,47 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public abstract class MjBaseConstraint : MjComponent {
+    public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_EQUALITY;
+
+    protected abstract string _constraintName { get; }
+
+    public SolverImpedance SolverImpedanceSettings = SolverImpedance.Default;
+    public SolverReference SolverReferenceSettings = SolverReference.Default;
+
+    protected abstract void ToMjcf(XmlElement mjcf);
+    protected abstract void FromMjcf(XmlElement mjcf);
+
+    protected override void OnParseMjcf(XmlElement mjcf) {
+      FromMjcf(mjcf);
+      SolverReferenceSettings.FromMjcf(mjcf, "solref");
+      SolverImpedanceSettings.FromMjcf(mjcf, "solimp");
+    }
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      var mjcf = (XmlElement)doc.CreateElement(_constraintName);
+      ToMjcf(mjcf);
+      SolverReferenceSettings.ToMjcf(mjcf, "solref");
+      SolverImpedanceSettings.ToMjcf(mjcf, "solimp");
+      return mjcf;
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjBaseConstraint.cs.meta b/unity/Runtime/Components/MjBaseConstraint.cs.meta
new file mode 100644
index 00000000..c43b041d
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseConstraint.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: a34f7c43f90c84e64a45942e605c0a2b
+timeCreated: 1552309644
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBaseJoint.cs b/unity/Runtime/Components/MjBaseJoint.cs
new file mode 100644
index 00000000..55fe0b2f
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseJoint.cs
@@ -0,0 +1,63 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public abstract class MjBaseJoint : MjComponent {
+    public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_JOINT;
+
+    public int QposAddress { get; private set; } = -1;
+    public int DofAddress { get; private set; } = -1;
+    // Joint will add Degrees of Freedom to this MjBaseBody.
+    // It's the MjBaseBody located immediately above this joint in the scene tree.
+    // NOTE: This property won't be initialized until runtime.
+    public MjBaseBody ParentBody { get; private set; }
+
+    // Joint will constrain the ParentBody to this MjBaseBody.
+    // It's the MjBaseBody located two levels above this joint in the scene tree.
+    // For some joints, such as MjFreeJoint, this can be null.
+    // NOTE: This property won't be initialized until runtime.
+    public MjBaseBody GrandParentBody { get; private set; }
+
+    // Return the bodies connected by this joint.
+    public void GetConnectedBodies(out MjBaseBody grandParent, out MjBaseBody parent) {
+      parent = MjHierarchyTool.FindParentComponent<MjBaseBody>(this);
+      if (parent != null) {
+        grandParent = MjHierarchyTool.FindParentComponent<MjBaseBody>(parent);
+      } else {
+        grandParent = null;
+      }
+    }
+
+    protected override unsafe void OnBindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {
+      QposAddress = model->jnt_qposadr[MujocoId];
+      DofAddress = model->jnt_dofadr[MujocoId];
+    }
+
+    protected override void Start() {
+      base.Start();
+      MjBaseBody grandparentBody, parentBody;
+      GetConnectedBodies(out grandparentBody, out parentBody);
+      GrandParentBody = grandparentBody;
+      ParentBody = parentBody;
+      if (ParentBody == null) {
+        throw new Exception("The joint doesn't have a ParentBody.");
+      }
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjBaseJoint.cs.meta b/unity/Runtime/Components/MjBaseJoint.cs.meta
new file mode 100644
index 00000000..12d03308
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseJoint.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 07bd997db28964e5daf6af0ff47e157f
+timeCreated: 1538399740
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBaseSensor.cs b/unity/Runtime/Components/MjBaseSensor.cs
new file mode 100644
index 00000000..d3a5294c
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseSensor.cs
@@ -0,0 +1,80 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// The base class for Mujoco sensors.
+//
+// Mujoco offers a very wide range of sensors, each contingent on the following three aspects:
+//  1. the Mujoco Component it observes: Body, Joint, etc.
+//  2. the type of data it returns: scalar, Vector3, quaternion, etc.
+//  3. the field it reads to retreive the data: xpos, xquat, cfrc, etc.
+//
+// In Mujoco proper, names of some of the sensors repeat for many data types. In order to get rid
+// of this ambiguity, we chose to split the sensors into groups.
+// Each sensor class represents a group of aspects (1) and (2), which is reflected in its name.
+// For example, the class of sensors that listen to Bodies and produce Vector3 observations is
+// called MjBodyVectorSensor.
+//
+// That very class contains a wide range of sensing capabilities - as in fact most of the classes
+// do. What each sensor can sense can be controlled by the sensor's Type field. Using the
+// MjBodyVectorSensor as an example, one can set it to SubtreeCom, FramePos or any of the other
+// supported observation types.
+public abstract class MjBaseSensor : MjComponent {
+
+  [Tooltip("The standard deviation of zero-mean Gaussian noise added to the sensor output.")]
+  [AbsoluteValue]
+  public float Noise = 0.0f;
+
+  [Tooltip("When this value is positive, it limits the absolute value of the sensor output.")]
+  [AbsoluteValue]
+  public float Cutoff = 0.0f;
+
+  public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_SENSOR;
+
+  // Address of the sensor, that can be used to index into MujocoLib.mjData_.sensordata.
+  protected int _sensorAddress;
+
+  // Parse the component settings from an external Mjcf.
+  protected override void OnParseMjcf(XmlElement mjcf) {
+    Noise = mjcf.GetFloatAttribute("noise", defaultValue: 0.0f);
+    Cutoff = mjcf.GetFloatAttribute("cutoff", defaultValue: 0.0f);
+    FromMjcf(mjcf);
+  }
+
+  // Generate implementation specific XML element.
+  protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+    var mjcf = ToMjcf(doc);
+    mjcf.SetAttribute("noise", Noise.ToString());
+    mjcf.SetAttribute("cutoff", Cutoff.ToString());
+    return mjcf;
+  }
+
+  // Perform bind time initialization of the component.
+  protected override unsafe void OnBindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {
+    _sensorAddress = model->sensor_adr[MujocoId];
+  }
+
+  // Create the implementation dependent Mjcf node.
+  protected abstract XmlElement ToMjcf(XmlDocument doc);
+
+  // Parse the implementation dependent details from the provided Mjcf node.
+  protected abstract void FromMjcf(XmlElement mjcf);
+}
+}
diff --git a/unity/Runtime/Components/MjBaseSensor.cs.meta b/unity/Runtime/Components/MjBaseSensor.cs.meta
new file mode 100644
index 00000000..4c394b7a
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9535e8d4bdb484c4dbd07806fcae7568
+timeCreated: 1548084206
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBaseTendon.cs b/unity/Runtime/Components/MjBaseTendon.cs
new file mode 100644
index 00000000..cc00899d
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseTendon.cs
@@ -0,0 +1,65 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+public abstract class MjBaseTendon : MjComponent {
+
+  public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_TENDON;
+
+  public SolverSettings Solver = SolverSettings.Default;
+
+  [Tooltip("Length at zero spring force. If negative, this resting length is computed at qpos0.")]
+  public float SpringLength = -1.0f;
+  public float Stiffness = 0.0f;
+  public float Damping = 0.0f;
+
+  // Tendon length.
+  public float Length { get; private set; }
+
+  // Create the implementation dependent Mjcf node.
+  protected abstract XmlElement ToMjcf(XmlDocument doc);
+
+  // Parse the implementation dependent details from the provided Mjcf node.
+  protected abstract void FromMjcf(XmlElement mjcf);
+
+  // Parse the component settings from an external Mjcf.
+  protected override void OnParseMjcf(XmlElement mjcf) {
+    Solver.FromMjcf(mjcf);
+    SpringLength = mjcf.GetFloatAttribute("springlength", defaultValue: -1.0f);
+    Stiffness = mjcf.GetFloatAttribute("damping");
+    Damping = mjcf.GetFloatAttribute("stiffness");
+    FromMjcf(mjcf);
+  }
+
+  // Generate implementation specific XML element.
+  protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+    var mjcf = ToMjcf(doc);
+    Solver.ToMjcf(mjcf);
+    mjcf.SetAttribute("springlength", $"{SpringLength}");
+    mjcf.SetAttribute("damping", $"{Damping}");
+    mjcf.SetAttribute("stiffness", $"{Stiffness}");
+    return mjcf;
+  }
+
+  // Synchronize the state of the component.
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    Length = (float)data->ten_length[MujocoId];
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjBaseTendon.cs.meta b/unity/Runtime/Components/MjBaseTendon.cs.meta
new file mode 100644
index 00000000..26d0a98b
--- /dev/null
+++ b/unity/Runtime/Components/MjBaseTendon.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 2d585fcecff4e4b13b8647ad4d18c5b5
+timeCreated: 1551348729
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBody.cs b/unity/Runtime/Components/MjBody.cs
new file mode 100644
index 00000000..acde7e11
--- /dev/null
+++ b/unity/Runtime/Components/MjBody.cs
@@ -0,0 +1,42 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  // The component represents the apex of hierarchy that defines a single rigid body.
+  public class MjBody : MjBaseBody {
+    protected override void OnParseMjcf(XmlElement mjcf) {
+      // Transform
+      transform.localPosition =
+          MjEngineTool.UnityVector3(mjcf.GetVector3Attribute("pos", defaultValue: Vector3.zero));
+      transform.localRotation = MjEngineTool.UnityQuaternion(
+          mjcf.GetQuaternionAttribute("quat", defaultValue: MjEngineTool.MjQuaternionIdentity));
+    }
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      var mjcf = (XmlElement)doc.CreateElement("body");
+      MjEngineTool.PositionRotationToMjcf(mjcf, this);
+      return mjcf;
+    }
+
+    public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+      transform.position = MjEngineTool.UnityVector3(data->xpos, MujocoId);
+      transform.rotation = MjEngineTool.UnityQuaternion(data->xquat, MujocoId);
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjBody.cs.meta b/unity/Runtime/Components/MjBody.cs.meta
new file mode 100644
index 00000000..165fea55
--- /dev/null
+++ b/unity/Runtime/Components/MjBody.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 4ef51a360e7c24695800e2d06f70db49
+timeCreated: 1537462857
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
\ No newline at end of file
diff --git a/unity/Runtime/Components/MjBodyQuaternionSensor.cs b/unity/Runtime/Components/MjBodyQuaternionSensor.cs
new file mode 100644
index 00000000..4cf32d27
--- /dev/null
+++ b/unity/Runtime/Components/MjBodyQuaternionSensor.cs
@@ -0,0 +1,52 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+public class MjBodyQuaternionSensor : MjBaseSensor {
+  public MjBody Body;
+
+  [Tooltip("Should the Frame sensors use the inertial or the regular frame of reference.")]
+  public bool UseInertialFrame;
+
+  public Quaternion SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Body == null) {
+      throw new NullReferenceException("Missing a reference to a MjBody.");
+    }
+    var mjcf = doc.CreateElement("framequat");
+    mjcf.SetAttribute("objtype", UseInertialFrame ? "body" : "xbody");
+    mjcf.SetAttribute("objname", Body.MujocoName);
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    UseInertialFrame = mjcf.HasAttribute("body");
+    Body = mjcf.GetObjectReferenceAttribute<MjBody>("objname");
+    if (Body == null) {
+      throw new NullReferenceException("Missing a reference to a MjBody.");
+    }
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    SensorReading = MjEngineTool.UnityQuaternion(data->sensordata, _sensorAddress);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjBodyQuaternionSensor.cs.meta b/unity/Runtime/Components/MjBodyQuaternionSensor.cs.meta
new file mode 100644
index 00000000..d4dda387
--- /dev/null
+++ b/unity/Runtime/Components/MjBodyQuaternionSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: af03f553fc93c44ec8d1cc3fbbcce947
+timeCreated: 1548170856
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBodyVectorSensor.cs b/unity/Runtime/Components/MjBodyVectorSensor.cs
new file mode 100644
index 00000000..dd0cc1f4
--- /dev/null
+++ b/unity/Runtime/Components/MjBodyVectorSensor.cs
@@ -0,0 +1,77 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+public class MjBodyVectorSensor : MjBaseSensor {
+  // NOTE: These names must match sensor names listed on mujoco.org.
+  // Changing them is justified only when Mujoco is upgraded to a new version.
+  public enum AvailableSensors {
+    SubtreeCom,
+    SubtreeLinVel,
+    SubtreeAngMom,
+    FramePos,
+    FrameXAxis,
+    FrameYAxis,
+    FrameZAxis,
+    FrameLinVel,
+    FrameAngVel,
+    FrameLinAcc,
+    FrameAngAcc,
+  }
+  public AvailableSensors SensorType;
+  public MjBody Body;
+
+  [Tooltip("Should the Frame sensors use the inertial or the regular frame of reference.")]
+  public bool UseInertialFrame;
+
+  public Vector3 SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Body == null) {
+      throw new NullReferenceException("Missing a reference to a MjBody.");
+    }
+    var tag = SensorType.ToString().ToLower();
+    var mjcf = doc.CreateElement(tag);
+    if (tag.Contains("frame")) {
+      mjcf.SetAttribute("objtype", UseInertialFrame ? "body" : "xbody");
+      mjcf.SetAttribute("objname", Body.MujocoName);
+    } else {
+      mjcf.SetAttribute("body", Body.MujocoName);
+    }
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    if (!Enum.TryParse(mjcf.Name, ignoreCase: true, result: out SensorType)) {
+      throw new ArgumentException($"Unknown sensor type {mjcf.Name}.");
+    }
+    if (mjcf.Name.Contains("frame")) {
+      UseInertialFrame = mjcf.HasAttribute("body"); // as opposed to xbody
+      Body = mjcf.GetObjectReferenceAttribute<MjBody>("objname");
+    } else {
+      Body = mjcf.GetObjectReferenceAttribute<MjBody>("body");
+    }
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    SensorReading = MjEngineTool.UnityVector3(data->sensordata, _sensorAddress);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjBodyVectorSensor.cs.meta b/unity/Runtime/Components/MjBodyVectorSensor.cs.meta
new file mode 100644
index 00000000..7e1000c0
--- /dev/null
+++ b/unity/Runtime/Components/MjBodyVectorSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 537df637b11f44df2a20bea718a015a6
+timeCreated: 1548092931
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjBoxShape.cs b/unity/Runtime/Components/MjBoxShape.cs
new file mode 100644
index 00000000..c570d94e
--- /dev/null
+++ b/unity/Runtime/Components/MjBoxShape.cs
@@ -0,0 +1,55 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+[Serializable]
+public class MjBoxShape : IMjShape {
+  public Vector3 Extents = Vector3.one * 0.5f;
+
+  public void ToMjcf(XmlElement mjcf, Transform transform) {
+    var scaledExtents = MjEngineTool.MjExtents(Vector3.Scale(Extents, transform.lossyScale));
+    mjcf.SetAttribute("size", MjEngineTool.Vector3ToMjcf(scaledExtents));
+  }
+
+  public void FromMjcf(XmlElement mjcf) {
+    Extents = MjEngineTool.UnityExtents(
+        mjcf.GetVector3Attribute("size", defaultValue: Vector3.one * 0.5f));
+
+    Vector3 fromPoint, toPoint;
+    if (MjEngineTool.ParseFromToMjcf(mjcf, out fromPoint, out toPoint)) {
+      var extent = (toPoint - fromPoint).magnitude * 0.5f;
+      Extents = Vector3.one * extent;
+    }
+  }
+
+  public Tuple<Vector3[], int[]> BuildMesh() {
+    return MeshGenerators.BuildBox(extents: Extents);
+  }
+
+  public Vector4 GetChangeStamp() {
+    return Extents;
+  }
+
+  public void DebugDraw(Transform transform) {
+    Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, transform.lossyScale);
+    Gizmos.DrawWireCube(Vector3.zero, Extents * 2.0f);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjBoxShape.cs.meta b/unity/Runtime/Components/MjBoxShape.cs.meta
new file mode 100644
index 00000000..56b65349
--- /dev/null
+++ b/unity/Runtime/Components/MjBoxShape.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9783bb0e781e341e5914cdbac095b35e
+timeCreated: 1547647081
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjCapsuleShape.cs b/unity/Runtime/Components/MjCapsuleShape.cs
new file mode 100644
index 00000000..0853d427
--- /dev/null
+++ b/unity/Runtime/Components/MjCapsuleShape.cs
@@ -0,0 +1,63 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+[Serializable]
+public class MjCapsuleShape : IMjShape {
+  public float Radius = 0.5f;
+  public float HalfHeight = 0.5f;
+  private const float _scaleTolerance = 1e-5f;
+
+  public void ToMjcf(XmlElement mjcf, Transform transform) {
+    if (Math.Abs(transform.lossyScale.x - transform.lossyScale.z) > _scaleTolerance) {
+      Debug.LogWarning(
+          $"{transform.name}: Capsule shapes require uniform scaling of XZ plane. Using the" +
+          " value of X and Y components.", transform);
+    }
+    mjcf.SetAttribute(
+        "size", $"{Radius * transform.lossyScale.x} {HalfHeight * transform.lossyScale.y}");
+  }
+
+  public void FromMjcf(XmlElement mjcf) {
+    var components = mjcf.GetFloatArrayAttribute("size", defaultValue: new float[] { 0.5f, 0.5f });
+    Radius = components[0];
+    HalfHeight = components[1];
+
+    Vector3 fromPoint, toPoint;
+    if (MjEngineTool.ParseFromToMjcf(mjcf, out fromPoint, out toPoint)) {
+      HalfHeight = 0.5f * (toPoint - fromPoint).magnitude;
+    }
+  }
+
+  public Tuple<Vector3[], int[]> BuildMesh() {
+    return MeshGenerators.BuildCapsule(radius: Radius, height: (HalfHeight + Radius) * 2.0f);
+  }
+
+  public Vector4 GetChangeStamp() {
+    return new Vector4(Radius, HalfHeight, 1, 0);
+  }
+
+  public void DebugDraw(Transform transform) {
+    Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
+    MjGizmos.DrawWireCapsule(
+        Vector3.zero, Radius * transform.lossyScale.x, 2 * HalfHeight * transform.lossyScale.y);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjCapsuleShape.cs.meta b/unity/Runtime/Components/MjCapsuleShape.cs.meta
new file mode 100644
index 00000000..c88575aa
--- /dev/null
+++ b/unity/Runtime/Components/MjCapsuleShape.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9b0a2054e1eec409fbf34c796a572b38
+timeCreated: 1547647081
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjComponent.cs b/unity/Runtime/Components/MjComponent.cs
new file mode 100644
index 00000000..1371c001
--- /dev/null
+++ b/unity/Runtime/Components/MjComponent.cs
@@ -0,0 +1,108 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// The base class for all components that represent Mujoco scene nodes.
+[DisallowMultipleComponent]
+public abstract class MjComponent : MonoBehaviour {
+
+  // Unique name assigned to each Mujoco component.
+  public string MujocoName { get; private set; }
+
+  // Id of the geom in Mujoco's internal data structures.
+  public int MujocoId { get; protected set; }
+
+  public abstract MujocoLib.mjtObj ObjectType { get; }
+
+  // Some components (Inertial frames for example) cannot have the name attribute
+  // added to the generated Mjcf.
+  protected virtual bool _suppressNameAttribute => false;
+
+  // Binds this component to the compiled Mujoco model.
+  public unsafe void BindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {
+    MujocoId = MujocoLib.mj_name2id(model, (int)ObjectType, MujocoName);
+    if (MujocoId == -1 && !_suppressNameAttribute) {
+      throw new NullReferenceException($"element name {MujocoName} not found");
+    }
+    OnBindToRuntime(model, data);
+  }
+
+  // Generates the XML element that corresponds to this scene node.
+  public XmlElement GenerateMjcf(string name, XmlDocument doc) {
+    MujocoName = name;
+
+    var mjcf = OnGenerateMjcf(doc);
+    if (!_suppressNameAttribute) {
+      mjcf.SetAttribute("name", name);
+    }
+
+    return mjcf;
+  }
+
+  // Parse the component settings from an external Mjcf.
+  public void ParseMjcf(XmlElement mjcf) {
+    // I would like to preserve the naming dualism - external mechanisms
+    // calling a method, and the internal implementation implementing
+    // the method with an "On" prefix.
+    OnParseMjcf(mjcf);
+  }
+
+  // Parse the component settings from an external Mjcf.
+  protected abstract void OnParseMjcf(XmlElement mjcf);
+
+  // Generate implementation specific XML element.
+  protected abstract XmlElement OnGenerateMjcf(XmlDocument doc);
+
+  // Perform bind time initialization of the component.
+  protected virtual unsafe void OnBindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {}
+
+  // Synchronize the state of the component.
+  public virtual unsafe void OnSyncState(MujocoLib.mjData_* data) {}
+
+  private bool _sceneExcludesMe = false;
+
+  protected unsafe virtual void Start() {
+    if (MjScene.Instance == null) {
+      throw new Exception("MuJoCo Scene not found");
+    }
+    if (MjScene.Instance.Model != null) {
+      _sceneExcludesMe = true;
+    }
+  }
+
+  protected void Update() {
+    if (_sceneExcludesMe) {
+      MjScene.Instance.SceneRecreationAtLateUpdateRequested = true;
+      _sceneExcludesMe = false;
+    }
+  }
+
+  private bool _exiting = false;
+  public void OnApplicationQuit() {
+    _exiting = true;
+  }
+
+  public void OnDisable() {
+    if (!_exiting) {
+      MjScene.Instance.SceneRecreationAtLateUpdateRequested = true;
+    }
+  }
+
+}
+}
diff --git a/unity/Runtime/Components/MjComponent.cs.meta b/unity/Runtime/Components/MjComponent.cs.meta
new file mode 100644
index 00000000..8d3fb92d
--- /dev/null
+++ b/unity/Runtime/Components/MjComponent.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 7cb8afbea854147a8bf92a08d5f6577b
+timeCreated: 1536879723
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjConnect.cs b/unity/Runtime/Components/MjConnect.cs
new file mode 100644
index 00000000..efdb93a1
--- /dev/null
+++ b/unity/Runtime/Components/MjConnect.cs
@@ -0,0 +1,51 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public class MjConnect : MjBaseConstraint {
+    public MjBaseBody Body1;
+    public MjBaseBody Body2;
+    protected override string _constraintName => "connect";
+
+    protected override void FromMjcf(XmlElement mjcf) {
+      Body1 = mjcf.GetObjectReferenceAttribute<MjBaseBody>("body1");
+      Body2 = mjcf.GetObjectReferenceAttribute<MjBaseBody>("body2");
+      if (mjcf.GetStringAttribute("anchor") != null) {
+        Debug.Log($"anchor in connect {name} ignored. Set Transforms in the editor.");
+      }
+    }
+
+    // Generate implementation specific XML element.
+    protected override void ToMjcf(XmlElement mjcf) {
+      if (Body1 == null || Body2 == null) {
+        throw new NullReferenceException($"Both bodies in connect {name} are required.");
+      }
+      mjcf.SetAttribute("body1", Body1.MujocoName);
+      mjcf.SetAttribute("body2", Body2.MujocoName);
+    }
+
+    public void OnValidate() {
+      if (Body1 != null && Body1 == Body2) {
+        Debug.LogError("Body1 and Body2 can't be the same - resetting Body2.", this);
+        Body2 = null;
+      }
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjConnect.cs.meta b/unity/Runtime/Components/MjConnect.cs.meta
new file mode 100644
index 00000000..d64e9a14
--- /dev/null
+++ b/unity/Runtime/Components/MjConnect.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ee6081d65578643bf8a26f200299a51a
+timeCreated: 1552313909
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjCylinderShape.cs b/unity/Runtime/Components/MjCylinderShape.cs
new file mode 100644
index 00000000..692eb526
--- /dev/null
+++ b/unity/Runtime/Components/MjCylinderShape.cs
@@ -0,0 +1,63 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+[Serializable]
+public class MjCylinderShape : IMjShape {
+  public float Radius = 0.5f;
+  public float HalfHeight = 1.0f;
+  private const float _scaleTolerance = 1e-6f;
+
+  public void ToMjcf(XmlElement mjcf, Transform transform) {
+    if (Math.Abs(transform.lossyScale.x - transform.lossyScale.z) > _scaleTolerance) {
+      Debug.LogWarning(
+          $"{transform.name}: Cylinder shapes require uniform scaling of XZ plane. Using the" +
+          " value of X and Y components.", transform);
+    }
+    mjcf.SetAttribute(
+        "size", $"{Radius * transform.lossyScale.x} {HalfHeight * transform.lossyScale.y}");
+  }
+
+  public void FromMjcf(XmlElement mjcf) {
+    var components = mjcf.GetFloatArrayAttribute("size", defaultValue: new float[] { 0.5f, 1.0f });
+    Radius = components[0];
+    HalfHeight = components[1];
+
+    Vector3 fromPoint, toPoint;
+    if (MjEngineTool.ParseFromToMjcf(mjcf, out fromPoint, out toPoint)) {
+      HalfHeight = (toPoint - fromPoint).magnitude * 0.5f;
+    }
+  }
+
+  public Tuple<Vector3[], int[]> BuildMesh() {
+    return MeshGenerators.BuildCylinder(radius: Radius, height: HalfHeight * 2);
+  }
+
+  public Vector4 GetChangeStamp() {
+    return new Vector4(Radius, HalfHeight, 1, 0);
+  }
+
+  public void DebugDraw(Transform transform) {
+    Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
+    MjGizmos.DrawWireCylinder(
+        Vector3.zero, Radius * transform.lossyScale.x, HalfHeight * 2 * transform.lossyScale.y);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjCylinderShape.cs.meta b/unity/Runtime/Components/MjCylinderShape.cs.meta
new file mode 100644
index 00000000..d921c656
--- /dev/null
+++ b/unity/Runtime/Components/MjCylinderShape.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: bd3a2b00a0a2f4ba9be8bd2f054a3835
+timeCreated: 1547647081
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjDistance.cs b/unity/Runtime/Components/MjDistance.cs
new file mode 100644
index 00000000..9a5b21f2
--- /dev/null
+++ b/unity/Runtime/Components/MjDistance.cs
@@ -0,0 +1,48 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public class MjDistance : MjBaseConstraint {
+    public MjGeom Geom1;
+    public MjGeom Geom2;
+    protected override string _constraintName => "distance";
+
+    protected override void FromMjcf(XmlElement mjcf) {
+      Geom1 = mjcf.GetObjectReferenceAttribute<MjGeom>("geom1");
+      Geom2 = mjcf.GetObjectReferenceAttribute<MjGeom>("geom2");
+    }
+
+    protected override void ToMjcf(XmlElement mjcf) {
+      if (Geom1 == null || Geom2 == null) {
+        throw new NullReferenceException($"Both geoms in distance {name} must be assigned.");
+      }
+
+      mjcf.SetAttribute("geom1", Geom1.MujocoName);
+      mjcf.SetAttribute("geom2", Geom2.MujocoName);
+    }
+
+    public void OnValidate() {
+      if (Geom1 != null && Geom1 == Geom2) {
+        Debug.LogError("Geom1 and Geom2 can't be the same - resetting Geom2.", this);
+        Geom2 = null;
+      }
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjDistance.cs.meta b/unity/Runtime/Components/MjDistance.cs.meta
new file mode 100644
index 00000000..d43611e6
--- /dev/null
+++ b/unity/Runtime/Components/MjDistance.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ad0689a32f102481fb189836c11931f9
+timeCreated: 1552309644
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjEllipsoidShape.cs b/unity/Runtime/Components/MjEllipsoidShape.cs
new file mode 100644
index 00000000..44ee699e
--- /dev/null
+++ b/unity/Runtime/Components/MjEllipsoidShape.cs
@@ -0,0 +1,58 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+[Serializable]
+public class MjEllipsoidShape : IMjShape {
+  public Vector3 Radiuses = Vector3.one * 0.5f;
+
+  public void ToMjcf(XmlElement mjcf, Transform transform) {
+    var scaledRadiuses = MjEngineTool.MjExtents(Vector3.Scale(Radiuses, transform.lossyScale));
+    mjcf.SetAttribute("size", MjEngineTool.Vector3ToMjcf(scaledRadiuses));
+  }
+
+  public void FromMjcf(XmlElement mjcf) {
+    Radiuses = MjEngineTool.UnityExtents(
+        mjcf.GetVector3Attribute("size", defaultValue: Vector3.one * 0.5f));
+
+    Vector3 fromPoint, toPoint;
+    if (MjEngineTool.ParseFromToMjcf(mjcf, out fromPoint, out toPoint)) {
+      var radius = (toPoint - fromPoint).magnitude * 0.5f;
+      Radiuses = Vector3.one * radius;
+    }
+  }
+
+  public Tuple<Vector3[], int[]> BuildMesh() {
+    return MeshGenerators.BuildSphere(scale: Radiuses);
+  }
+
+  public Vector4 GetChangeStamp() {
+    return Radiuses;
+  }
+
+  public void DebugDraw(Transform transform) {
+    Gizmos.matrix = Matrix4x4.TRS(
+        transform.position,
+        transform.rotation,
+        Vector3.Scale(Radiuses, transform.lossyScale));
+    Gizmos.DrawWireSphere(Vector3.zero, 1.0f);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjEllipsoidShape.cs.meta b/unity/Runtime/Components/MjEllipsoidShape.cs.meta
new file mode 100644
index 00000000..0ce6d969
--- /dev/null
+++ b/unity/Runtime/Components/MjEllipsoidShape.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 8316fb5037f4a450c9270267e5428567
+timeCreated: 1547647081
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjExclude.cs b/unity/Runtime/Components/MjExclude.cs
new file mode 100644
index 00000000..e50b28ec
--- /dev/null
+++ b/unity/Runtime/Components/MjExclude.cs
@@ -0,0 +1,54 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+public class MjExclude : MjComponent {
+
+  [Tooltip("A body whose contacts with other body are ignored")]
+  public MjBody Body1;
+  [Tooltip("Other body whose contacts with first body are ignored")]
+  public MjBody Body2;
+
+  public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_EXCLUDE;
+
+  protected override void OnParseMjcf(XmlElement mjcf) {
+    var body1Name = mjcf.GetStringAttribute("body1", defaultValue: string.Empty);
+    if (!string.IsNullOrEmpty(body1Name)) {
+      Body1 = MjHierarchyTool.FindComponentOfTypeAndName<MjBody>(body1Name);
+    }
+    var body2Name = mjcf.GetStringAttribute("body2", defaultValue: string.Empty);
+    if (!string.IsNullOrEmpty(body2Name)) {
+      Body2 = MjHierarchyTool.FindComponentOfTypeAndName<MjBody>(body2Name);
+    }
+  }
+
+  // Generate implementation specific XML element.
+  protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+    if (Body1 == null || Body2 == null) {
+      throw new NullReferenceException($"Both bodies in {name} must be assigned.");
+    }
+
+    var mjcf = (XmlElement)doc.CreateElement("exclude");
+    mjcf.SetAttribute("body1", Body1.MujocoName);
+    mjcf.SetAttribute("body2", Body2.MujocoName);
+    return mjcf;
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjExclude.cs.meta b/unity/Runtime/Components/MjExclude.cs.meta
new file mode 100644
index 00000000..1ef85a16
--- /dev/null
+++ b/unity/Runtime/Components/MjExclude.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 8d271c366e5c04a259f36a15b42f78a5
+timeCreated: 1550051492
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjFixedTendon.cs b/unity/Runtime/Components/MjFixedTendon.cs
new file mode 100644
index 00000000..37b87654
--- /dev/null
+++ b/unity/Runtime/Components/MjFixedTendon.cs
@@ -0,0 +1,81 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+[Serializable]
+public class FixedTendonEntry {
+  [Tooltip("Only scalar joints can be used - hinge and slide.")]
+  public MjBaseJoint Joint;
+
+  [Tooltip("Multiplier for the value of the joint.")]
+  public float Coefficient = 1.0f;
+}
+
+public class MjFixedTendon : MjBaseTendon {
+
+  [Tooltip("In (scaled) radians/meters.")]
+  public float RangeLower;
+  [Tooltip("In (scaled) radians/meters.")]
+  public float RangeUpper;
+
+  public List<FixedTendonEntry> JointList = new List<FixedTendonEntry>() {};
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    foreach (var child in mjcf.Cast<XmlNode>().OfType<XmlElement>()) {
+      var fixedTendonEntry = new FixedTendonEntry();
+      fixedTendonEntry.Joint = child.GetObjectReferenceAttribute<MjBaseJoint>("joint");
+      fixedTendonEntry.Coefficient = child.GetFloatAttribute("coef", defaultValue: 1.0f);
+      JointList.Add(fixedTendonEntry);
+    }
+    var rangeValues = mjcf.GetFloatArrayAttribute("range", defaultValue: new float[] { 0, 0 });
+    RangeLower = rangeValues[0];
+    RangeUpper = rangeValues[1];
+  }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (JointList.Count < 1) {
+      throw new ArgumentOutOfRangeException($"Fixed tendon {name} needs at least one joint.");
+    }
+    var mjcf = doc.CreateElement("fixed");
+    foreach (FixedTendonEntry fixedTendonEntry in JointList) {
+      var jointMjcf = doc.CreateElement("joint");
+      jointMjcf.SetAttribute("joint", fixedTendonEntry.Joint.MujocoName);
+      jointMjcf.SetAttribute("coef", $"{fixedTendonEntry.Coefficient}");
+      mjcf.AppendChild(jointMjcf);
+    }
+    if (RangeLower > RangeUpper) {
+      throw new ArgumentException("Lower range value can't be bigger than Higher");
+    }
+    mjcf.SetAttribute("range", $"{RangeLower} {RangeUpper}");
+
+    return mjcf;
+  }
+
+  public void OnValidate() {
+    foreach (FixedTendonEntry fixedTendonEntry in JointList) {
+      if (!(fixedTendonEntry.Joint is MjHingeJoint) &&
+          !(fixedTendonEntry.Joint is MjSlideJoint)) {
+        Debug.LogError("Only scalar joints (hinge or slide) are allowed.", this);
+        fixedTendonEntry.Joint = null;
+      }
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjFixedTendon.cs.meta b/unity/Runtime/Components/MjFixedTendon.cs.meta
new file mode 100644
index 00000000..1eabf8f2
--- /dev/null
+++ b/unity/Runtime/Components/MjFixedTendon.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: e49529c3d80714a368699287bbdd8f72
+timeCreated: 1549990455
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjFreeJoint.cs b/unity/Runtime/Components/MjFreeJoint.cs
new file mode 100644
index 00000000..0cdb7a0b
--- /dev/null
+++ b/unity/Runtime/Components/MjFreeJoint.cs
@@ -0,0 +1,29 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  // The component represents a joint with 6 degrees of freedom.
+  public class MjFreeJoint : MjBaseJoint {
+    protected override void OnParseMjcf(XmlElement mjcf) {}
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      return (XmlElement)doc.CreateElement("freejoint");
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjFreeJoint.cs.meta b/unity/Runtime/Components/MjFreeJoint.cs.meta
new file mode 100644
index 00000000..d76ca90c
--- /dev/null
+++ b/unity/Runtime/Components/MjFreeJoint.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 7ef627bd3075d42d886135a149a187a2
+timeCreated: 1537540954
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjGeom.cs b/unity/Runtime/Components/MjGeom.cs
new file mode 100644
index 00000000..25a5d488
--- /dev/null
+++ b/unity/Runtime/Components/MjGeom.cs
@@ -0,0 +1,96 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// The component represents a physical shape and models its inertia and material properties.
+public class MjGeom : MjShapeComponent {
+  [Tooltip("If larger than zero, Density has no effect.")]
+  public float Mass = 0.0f;
+
+  [Tooltip("Material density. Set to 0 for a zero-mass geom.")]
+  public float Density = 1000.0f;
+
+  [Tooltip("Advanced settings.")]
+  public MjGeomSettings Settings = MjGeomSettings.Default;
+
+  public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_GEOM;
+  private MjTransformation _geomInGlobalFrame = new MjTransformation();
+  private MjTransformation _comTransform;
+
+  protected override void OnParseMjcf(XmlElement mjcf) {
+    ShapeFromMjcf(mjcf);
+    Mass = mjcf.GetFloatAttribute("mass", defaultValue: 0.0f);
+    Density = mjcf.GetFloatAttribute("density", defaultValue: 1000.0f);
+    MjEngineTool.ParseTransformMjcf(mjcf, transform);
+    Settings.FromMjcf(mjcf);
+  }
+
+  // The MuJoCo compiler shifts meshes' frames, so we need to cache this transformation at init and
+  // apply it at runtime.
+  protected override unsafe void OnBindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {
+    var MjParent = MjHierarchyTool.FindParentComponent<MjBaseBody>(this);
+    if (MjParent != null) {
+      var comInParentFrame = new MjTransformation(
+          translation: MjEngineTool.UnityVector3(model->geom_pos, MujocoId),
+          rotation: MjEngineTool.UnityQuaternion(model->geom_quat, MujocoId));
+
+      // We don't want to bother calculating global transform in mujoco from mjModel,
+      // so we'll assume it's the same as the Unity transfor (it's the beginning of simulation after
+      // all).
+      var globalParentFrame = MjTransformation.LoadGlobal(transform.parent);
+      var comInGlobalFrame = globalParentFrame * comInParentFrame;
+      var globalFrame = MjTransformation.LoadGlobal(transform);
+      _comTransform = comInGlobalFrame.Inverse() * globalFrame;
+    }
+  }
+
+  protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+    var mjcf = (XmlElement)doc.CreateElement("geom");
+    if (Mass > 0) {
+      mjcf.SetAttribute("mass", $"{Mass}");
+    } else {
+      mjcf.SetAttribute("density", $"{Density}");
+    }
+    ShapeToMjcf(mjcf, transform);
+    MjEngineTool.PositionRotationToMjcf(mjcf, this);
+    Settings.ToMjcf(mjcf);
+
+    return mjcf;
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    if (ShapeType == ShapeTypes.Mesh) {
+      _geomInGlobalFrame.Set(
+          translation: MjEngineTool.UnityVector3(data->geom_xpos, MujocoId),
+          rotation: MjEngineTool.UnityQuaternionFromMatrix(data->geom_xmat, MujocoId));
+      var comInGlobalFrame = _geomInGlobalFrame * _comTransform;
+      comInGlobalFrame.StoreGlobal(transform);
+    } else {
+      transform.position = MjEngineTool.UnityVector3(data->geom_xpos, MujocoId);
+      transform.rotation = MjEngineTool.UnityQuaternionFromMatrix(data->geom_xmat, MujocoId);
+    }
+  }
+
+  public void OnDrawGizmosSelected() {
+    Gizmos.color = Color.blue;
+    DrawGizmos(transform);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjGeom.cs.meta b/unity/Runtime/Components/MjGeom.cs.meta
new file mode 100644
index 00000000..b7acce03
--- /dev/null
+++ b/unity/Runtime/Components/MjGeom.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ba8757a90afe442d9acfbd600758b843
+timeCreated: 1536743564
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjGeomQuaternionSensor.cs b/unity/Runtime/Components/MjGeomQuaternionSensor.cs
new file mode 100644
index 00000000..26039420
--- /dev/null
+++ b/unity/Runtime/Components/MjGeomQuaternionSensor.cs
@@ -0,0 +1,47 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+public class MjGeomQuaternionSensor : MjBaseSensor {
+  public MjGeom Geom;
+
+  public Quaternion SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Geom == null) {
+      throw new NullReferenceException("Missing a reference to a MjGeom.");
+    }
+    var mjcf = doc.CreateElement("framequat");
+    mjcf.SetAttribute("objtype", "geom");
+    mjcf.SetAttribute("objname", Geom.MujocoName);
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    Geom = mjcf.GetObjectReferenceAttribute<MjGeom>("objname");
+    if (Geom == null) {
+      throw new NullReferenceException("Missing a reference to a MjGeom.");
+    }
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    SensorReading = MjEngineTool.UnityQuaternion(data->sensordata, _sensorAddress);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjGeomQuaternionSensor.cs.meta b/unity/Runtime/Components/MjGeomQuaternionSensor.cs.meta
new file mode 100644
index 00000000..808dada4
--- /dev/null
+++ b/unity/Runtime/Components/MjGeomQuaternionSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 71b28b4bc4c27423aaba5b98863e0c92
+timeCreated: 1548170856
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjGeomSettings.cs b/unity/Runtime/Components/MjGeomSettings.cs
new file mode 100644
index 00000000..82cbd8a2
--- /dev/null
+++ b/unity/Runtime/Components/MjGeomSettings.cs
@@ -0,0 +1,148 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Advanced settings of MjGeom component.
+[Serializable]
+public struct MjGeomSettings {
+  [Tooltip("Solver accuracy settings.")]
+  public GeomSolver Solver;
+
+  [Tooltip("Collision filtering settings.")]
+  public CollisionFiltering Filtering;
+
+  [Tooltip("Contact friction parameters for dynamically generated contact pairs.")]
+  public GeomFriction Friction;
+
+  // Default geom settings.
+  public static MjGeomSettings Default = new MjGeomSettings() {
+    Solver = GeomSolver.Default,
+    Filtering = CollisionFiltering.Default,
+    Friction = GeomFriction.Default
+  };
+
+  public void FromMjcf(XmlElement mjcf) {
+    // Contact filtering settings.
+    Filtering.Contype = (int)mjcf.GetFloatAttribute("contype", CollisionFiltering.Default.Contype);
+    Filtering.Conaffinity = (int)mjcf.GetFloatAttribute(
+        "conaffinity", CollisionFiltering.Default.Conaffinity);
+    Filtering.Group = (int)mjcf.GetFloatAttribute("group", CollisionFiltering.Default.Group);
+
+    // Solver settings.
+    Solver.ConDim = (int)mjcf.GetFloatAttribute("condim", GeomSolver.Default.ConDim);
+    Solver.SolMix = mjcf.GetFloatAttribute("solmix", GeomSolver.Default.SolMix);
+    var solref = mjcf.GetFloatArrayAttribute(
+        "solref", new float[] { GeomSolver.Default.SolRef.TimeConst,
+        GeomSolver.Default.SolRef.DampRatio });
+    Solver.SolRef.TimeConst = solref[0];
+    Solver.SolRef.DampRatio = solref[1];
+    var solimp = mjcf.GetFloatArrayAttribute(
+      "solimp", new float[] { GeomSolver.Default.SolImp.DMin, GeomSolver.Default.SolImp.DMax,
+      GeomSolver.Default.SolImp.Width });
+    Solver.SolImp.DMin = solimp[0];
+    Solver.SolImp.DMax = solimp[1];
+    Solver.SolImp.Width = solimp[2];
+    Solver.Margin = mjcf.GetFloatAttribute("margin", GeomSolver.Default.Margin);
+    Solver.Gap = mjcf.GetFloatAttribute("gap", GeomSolver.Default.Gap);
+
+    // Inertia and friction settings.
+    var friction = mjcf.GetFloatArrayAttribute(
+        "friction", new float[] { GeomFriction.Default.Sliding, GeomFriction.Default.Torsional,
+        GeomFriction.Default.Rolling });
+    Friction.Sliding = friction[0];
+    Friction.Torsional = friction[1];
+    Friction.Rolling = friction[2];
+  }
+
+  public void ToMjcf(XmlElement mjcf) {
+    // Contact filtering settings.
+    mjcf.SetAttribute("contype", $"{Filtering.Contype}");
+    mjcf.SetAttribute("conaffinity", $"{Filtering.Conaffinity}");
+    mjcf.SetAttribute("group", $"{Filtering.Group}");
+
+    // Solver settings.
+    mjcf.SetAttribute("condim", $"{Solver.ConDim}");
+    mjcf.SetAttribute("solmix", $"{Solver.SolMix}");
+    mjcf.SetAttribute("solref", $"{Solver.SolRef.TimeConst} {Solver.SolRef.DampRatio}");
+    mjcf.SetAttribute(
+      "solimp", $"{Solver.SolImp.DMin} {Solver.SolImp.DMax} {Solver.SolImp.Width}");
+    mjcf.SetAttribute("margin", $"{Solver.Margin}");
+    mjcf.SetAttribute("gap", $"{Solver.Gap}");
+
+    // Inertia and friction settings.
+    mjcf.SetAttribute("friction", $"{Friction.Sliding} {Friction.Torsional} {Friction.Rolling}");
+  }
+}
+
+[Serializable]
+public struct GeomFriction {
+  public float Sliding;
+  public float Torsional;
+  public float Rolling;
+
+  public static GeomFriction Default = new GeomFriction {
+      Sliding = 1.0f, Torsional = 0.005f, Rolling = 0.0001f
+  };
+}
+
+[Serializable]
+public struct CollisionFiltering {
+
+  [Tooltip("Bitmasks used for contact filtering of dynamically generated contact pairs.")]
+  public int Contype;
+
+  [Tooltip("Bitmask for contact filtering")]
+  public int Conaffinity;
+
+  // The only effect on the physics is at compile time, when body masses and inertias are inferred
+  // from geoms selected based on their group.
+  [Tooltip("Group to which the geom belongs.")]
+  public int Group;
+
+  public static CollisionFiltering Default = new CollisionFiltering() {
+    Contype = 1, Conaffinity = 1, Group = 0
+  };
+}
+
+[Serializable]
+public struct GeomSolver {
+  [Tooltip("The dimensionality of the contact space.")]
+  public int ConDim;
+
+  [Tooltip("Weight used for averaging of constraint solver parameters.")]
+  public float SolMix;
+
+  [Tooltip("Solver function d(r) reference parameters.")]
+  public SolverReference SolRef;
+
+  [Tooltip("Solver function d(r) impedance parameters.")]
+  public SolverImpedance SolImp;
+
+  [Tooltip("Distance threshold below which contacts are detected.")]
+  public float Margin;
+
+  [Tooltip("Positive value enables generation of inactive contacts.")]
+  public float Gap;
+
+  public static GeomSolver Default = new GeomSolver() {
+    ConDim = 3, SolMix = 1.0f, SolRef = SolverReference.Default, SolImp = SolverImpedance.Default,
+    Margin = 0.0f, Gap = 0.0f
+  };
+}
+}
diff --git a/unity/Runtime/Components/MjGeomSettings.cs.meta b/unity/Runtime/Components/MjGeomSettings.cs.meta
new file mode 100644
index 00000000..21aff66d
--- /dev/null
+++ b/unity/Runtime/Components/MjGeomSettings.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: d472b07eedb654ed5a83bfd6822587a3
+timeCreated: 1538655839
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjGeomVectorSensor.cs b/unity/Runtime/Components/MjGeomVectorSensor.cs
new file mode 100644
index 00000000..4e983215
--- /dev/null
+++ b/unity/Runtime/Components/MjGeomVectorSensor.cs
@@ -0,0 +1,63 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+public class MjGeomVectorSensor : MjBaseSensor {
+  // NOTE: These names must match sensor names listed on mujoco.org.
+  // Changing them is justified only when Mujoco is upgraded to a new version.
+  public enum AvailableSensors {
+    FramePos,
+    FrameXAxis,
+    FrameYAxis,
+    FrameZAxis,
+    FrameLinVel,
+    FrameAngVel,
+    FrameLinAcc,
+    FrameAngAcc,
+  }
+
+  public AvailableSensors SensorType;
+
+  public MjGeom Geom;
+
+  public Vector3 SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Geom == null) {
+      throw new NullReferenceException("Missing a reference to a MjGeom.");
+    }
+    var mjcf = doc.CreateElement(SensorType.ToString().ToLower());
+    mjcf.SetAttribute("objtype", "geom");
+    mjcf.SetAttribute("objname", Geom.MujocoName);
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    if (!Enum.TryParse(mjcf.Name, ignoreCase: true, result: out SensorType)) {
+      throw new ArgumentException($"Unknown sensor type {mjcf.Name}.");
+    }
+    Geom = mjcf.GetObjectReferenceAttribute<MjGeom>("objname");
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    SensorReading = MjEngineTool.UnityVector3(data->sensordata, _sensorAddress);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjGeomVectorSensor.cs.meta b/unity/Runtime/Components/MjGeomVectorSensor.cs.meta
new file mode 100644
index 00000000..09fe043d
--- /dev/null
+++ b/unity/Runtime/Components/MjGeomVectorSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c63b35fff51454145b2c5cabf4a81669
+timeCreated: 1548107238
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjGizmos.cs b/unity/Runtime/Components/MjGizmos.cs
new file mode 100644
index 00000000..b0ef5c90
--- /dev/null
+++ b/unity/Runtime/Components/MjGizmos.cs
@@ -0,0 +1,116 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Additional Debug Gizmos.
+public static class MjGizmos {
+
+  private const float _vectorPerpendicularityMagnitudeThreshold = 1e-6f;
+
+  public static int NumCircleSegments = 32;
+
+  private static Vector3[] _circumferenceVertices = new Vector3[] {
+    Vector3.right, -Vector3.right, Vector3.forward, -Vector3.forward,
+  };
+
+  public static Action<Vector3 /*from*/, Vector3 /*to*/> DrawLine { get; set; } = Gizmos.DrawLine;
+
+  public static Action<Vector3 /*position*/, float /*radius*/, Vector3 /*axis*/, float /*length*/,
+                       float /*startAngle*/> DrawArc { get; set; } = MjGizmos.DrawArcInternal;
+
+  // Draws a wireframe capsule of the specified radius and height.
+  // The capsule's height will be aligned with the global Y axis.
+  // The specified height represents the height of the cylinder between two hemisphere bases.
+  public static void DrawWireCapsule(Vector3 position, float radius, float height) {
+    var offset = DrawHollowWireCylinder(position, radius, height);
+    // Arches marking the bases of the capsule.
+    DrawArc(position - offset, radius, Vector3.right, 0.5f, 0.0f);
+    DrawArc(position + offset, radius, Vector3.right, 0.5f, 180.0f);
+    DrawArc(position + offset, radius, Vector3.forward, 0.5f, -90.0f);
+    DrawArc(position - offset, radius, Vector3.forward, 0.5f, 90.0f);
+  }
+
+  // Draws a wireframe cylinder of the specified radius and height.
+  // The cylinder's height will be aligned with the global Y axis.
+  public static void DrawWireCylinder(Vector3 position, float radius, float height) {
+    var offset = DrawHollowWireCylinder(position, radius, height);
+    // Lines marking the bases of the cylinder.
+    for (var i = 0; i < _circumferenceVertices.Length / 2; ++i) {
+      var vertex = _circumferenceVertices[i * 2] * radius;
+      var nextVertex = _circumferenceVertices[i * 2 + 1] * radius;
+      DrawLine(position + offset + vertex, position + offset + nextVertex);
+      DrawLine(position - offset + vertex, position - offset + nextVertex);
+    }
+  }
+
+  private static Vector3 DrawHollowWireCylinder(Vector3 position, float radius, float height) {
+    var offset = Vector3.up * (height * 0.5f);
+    // Cylinder bases.
+    DrawArc(position + offset, radius, Vector3.up, 1.0f, 0.0f);
+    DrawArc(position - offset, radius, Vector3.up, 1.0f, 0.0f);
+    // Lines marking the sides of the cylinder.
+    for (var i = 0; i < _circumferenceVertices.Length; ++i) {
+      // Lines marking the sides of the cylinder.
+      var vertex = _circumferenceVertices[i] * radius;
+      DrawLine(position + offset + vertex, position - offset + vertex);
+    }
+    return offset;
+  }
+
+  // Draws an arc in the XZ plane.
+  // 'length' parameter, in range (0, 1], allows to define how much of the circumference should be
+  // drawn. In other words, it allows to draw arbitrary arcs.
+  // Two additional parameters, 'axis' and 'startAngle', allow to orient the figure without having
+  // to manipulate the value of Gizmos.matrix.
+  public static void DrawArcInternal(
+      Vector3 position, float radius, Vector3 axis, float length, float startAngle) {
+    var deltaAngle = 360.0f / NumCircleSegments;
+    var numSegments = Math.Ceiling(length * NumCircleSegments);
+
+    var perpendicular = Vector3.Cross(axis, Vector3.right);
+    if (perpendicular.magnitude <= _vectorPerpendicularityMagnitudeThreshold) {
+      perpendicular = Vector3.Cross(axis, Vector3.up);
+    }
+    perpendicular.Normalize();
+
+    var offset = perpendicular * radius;
+    var start = Quaternion.AngleAxis(startAngle, axis) * offset;
+    var angle = startAngle + deltaAngle;
+
+    for (var segment = 0; segment < numSegments; ++segment, angle += deltaAngle) {
+      var end = Quaternion.AngleAxis(angle, axis) * offset;
+      DrawLine(position + start, position + end);
+      start = end;
+    }
+  }
+
+  public static void DrawWirePlane(Vector3 position, float width, float height) {
+    var quadPoints = new Vector3[] {
+      new Vector3(-0.5f * width, 0, -0.5f * height),
+      new Vector3(0.5f * width, 0, -0.5f * height),
+      new Vector3(0.5f * width, 0, 0.5f * height),
+      new Vector3(-0.5f * width, 0, 0.5f * height),
+      new Vector3(-0.5f * width, 0, -0.5f * height),
+      new Vector3(0.5f * width, 0, 0.5f * height),
+    };
+    for (var i = 0; i < quadPoints.Length - 1; ++i) {
+      DrawLine(position + quadPoints[i], position + quadPoints[i + 1]);
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjGizmos.cs.meta b/unity/Runtime/Components/MjGizmos.cs.meta
new file mode 100644
index 00000000..eb1d6bbd
--- /dev/null
+++ b/unity/Runtime/Components/MjGizmos.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: f9b1794ad59f445418c86157f57519bd
+timeCreated: 1536771527
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjGlobalSettings.cs b/unity/Runtime/Components/MjGlobalSettings.cs
new file mode 100644
index 00000000..bbad126c
--- /dev/null
+++ b/unity/Runtime/Components/MjGlobalSettings.cs
@@ -0,0 +1,378 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Xml;
+using UnityEngine;
+using UnityEngine.Profiling;
+
+namespace Mujoco {
+
+// The MuJoCo parser is case-sensitive.  The case format of the entries in the enums below is
+// exactly what the documentation specifies: http://mujoco.org/book/XMLreference.html#option .
+public enum IntegratorType {
+  Euler,
+  RK4
+}
+
+public enum CollisionCheckType {
+  all
+}
+
+public enum FrictionConeType {
+  pyramidal,
+  elliptic
+}
+
+public enum JacobianType {
+  dense,
+  sparse,
+  auto
+}
+
+public enum ConstraintSolverType {
+  PGS,
+  CG,
+  Newton
+}
+
+public enum EnableDisableFlag {
+  enable,
+  disable
+}
+
+[Serializable]
+public struct MjcfOptionFlag {
+  public EnableDisableFlag Constraint;
+  public EnableDisableFlag Equality;
+  public EnableDisableFlag FrictionLoss;
+  public EnableDisableFlag Limit;
+  public EnableDisableFlag Contact;
+  public EnableDisableFlag Passive;
+  public EnableDisableFlag Gravity;
+  public EnableDisableFlag ClampCtrl;
+  public EnableDisableFlag WarmStart;
+  public EnableDisableFlag FilterParent;
+  public EnableDisableFlag Actuation;
+  public EnableDisableFlag RefSafe;
+  public EnableDisableFlag Override;
+  public EnableDisableFlag Energy;
+  public EnableDisableFlag FwdInv;
+  public EnableDisableFlag SensorNoise;
+  public static MjcfOptionFlag Default = new MjcfOptionFlag() {
+    Constraint = EnableDisableFlag.enable,
+    Equality = EnableDisableFlag.enable,
+    FrictionLoss = EnableDisableFlag.enable,
+    Limit = EnableDisableFlag.enable,
+    Contact = EnableDisableFlag.enable,
+    Passive = EnableDisableFlag.enable,
+    Gravity = EnableDisableFlag.enable,
+    ClampCtrl = EnableDisableFlag.enable,
+    WarmStart = EnableDisableFlag.enable,
+    FilterParent = EnableDisableFlag.enable,
+    Actuation = EnableDisableFlag.enable,
+    RefSafe = EnableDisableFlag.enable,
+    Override = EnableDisableFlag.disable,
+    Energy = EnableDisableFlag.disable,
+    FwdInv = EnableDisableFlag.disable,
+    SensorNoise = EnableDisableFlag.disable
+  };
+
+  public void FromMjcf(XmlElement mjcf) {
+    var localDefault = MjcfOptionFlag.Default;
+    Constraint = mjcf.GetEnumAttribute<EnableDisableFlag>("constraint", localDefault.Constraint);
+    Equality = mjcf.GetEnumAttribute<EnableDisableFlag>("equality", localDefault.Equality);
+    FrictionLoss = mjcf.GetEnumAttribute<EnableDisableFlag>("frictionloss",
+                                                            localDefault.FrictionLoss);
+    Limit = mjcf.GetEnumAttribute<EnableDisableFlag>("limit", localDefault.Limit);
+    Contact = mjcf.GetEnumAttribute<EnableDisableFlag>("contact", localDefault.Contact);
+    Passive = mjcf.GetEnumAttribute<EnableDisableFlag>("passive", localDefault.Passive);
+    Gravity = mjcf.GetEnumAttribute<EnableDisableFlag>("gravity", localDefault.Gravity);
+    ClampCtrl = mjcf.GetEnumAttribute<EnableDisableFlag>("clampctrl", localDefault.ClampCtrl);
+    WarmStart = mjcf.GetEnumAttribute<EnableDisableFlag>("warmstart", localDefault.WarmStart);
+    FilterParent = mjcf.GetEnumAttribute<EnableDisableFlag>("filterparent",
+                                                            localDefault.FilterParent);
+    Actuation = mjcf.GetEnumAttribute<EnableDisableFlag>("actuation", localDefault.Actuation);
+    RefSafe = mjcf.GetEnumAttribute<EnableDisableFlag>("refsafe", localDefault.RefSafe);
+    Override = mjcf.GetEnumAttribute<EnableDisableFlag>("override", localDefault.Override);
+    Energy = mjcf.GetEnumAttribute<EnableDisableFlag>("energy", localDefault.Energy);
+    FwdInv = mjcf.GetEnumAttribute<EnableDisableFlag>("fwdinv", localDefault.FwdInv);
+    SensorNoise = mjcf.GetEnumAttribute<EnableDisableFlag>("sensornoise", localDefault.SensorNoise);
+  }
+
+  public void ToMjcf(XmlElement mjcf) {
+    mjcf.SetAttribute("constraint", Constraint.ToString());
+    mjcf.SetAttribute("equality", Equality.ToString());
+    mjcf.SetAttribute("frictionloss", FrictionLoss.ToString());
+    mjcf.SetAttribute("limit", Limit.ToString());
+    mjcf.SetAttribute("contact", Contact.ToString());
+    mjcf.SetAttribute("passive", Passive.ToString());
+    mjcf.SetAttribute("gravity", Gravity.ToString());
+    mjcf.SetAttribute("clampctrl", ClampCtrl.ToString());
+    mjcf.SetAttribute("warmstart", WarmStart.ToString());
+    mjcf.SetAttribute("filterparent", FilterParent.ToString());
+    mjcf.SetAttribute("actuation", Actuation.ToString());
+    mjcf.SetAttribute("refsafe", RefSafe.ToString());
+    mjcf.SetAttribute("override", Override.ToString());
+    mjcf.SetAttribute("energy", Energy.ToString());
+    mjcf.SetAttribute("fwdinv", FwdInv.ToString());
+    mjcf.SetAttribute("sensornoise", SensorNoise.ToString());
+  }
+}
+
+[Serializable]
+public struct MjSizeStruct {
+  public int Njmax;
+  public int Nconmax;
+  public int Nstack;
+  public static MjSizeStruct Default = new MjSizeStruct() {
+    Njmax = 0,
+    Nconmax = 0,
+    Nstack = 0
+  };
+
+  public void ParseMjcf(XmlElement mjcf) {
+    var localDefault = MjSizeStruct.Default;
+    Njmax = (int)mjcf.GetFloatAttribute("njmax", localDefault.Njmax);
+    Nconmax = (int)mjcf.GetFloatAttribute("nconmax", localDefault.Nconmax);
+    Nstack = (int)mjcf.GetFloatAttribute("nstack", localDefault.Nstack);
+  }
+
+  public XmlElement ToMjcf(XmlElement mjcf) {
+    if (Njmax > 0) {
+      mjcf.SetAttribute("njmax", $"{Njmax}");
+    }
+    if (Nconmax > 0) {
+      mjcf.SetAttribute("nconmax", $"{Nconmax}");
+    }
+    if (Nstack > 0) {
+      mjcf.SetAttribute("nstack", $"{Nstack}");
+    }
+    return mjcf;
+  }
+}
+
+[Serializable]
+public struct MjOptionStruct {
+
+  // "timestep" and "gravity" come from global settings.
+  // "apirate" is only relevant to HAPTIX.
+  [Tooltip("Ratio of frictional-to-normal constraint impedance.")]
+  public float ImpRatio;
+  [Tooltip("Global magnetic flux used by magnetometer sensors.")]
+  public Vector3 Magnetic;
+  [Tooltip("Velocity vector of the medium, scales with the values of Density and Viscosity below.")]
+  public Vector3 Wind;
+  [Tooltip("Density of the medium for lift and drag forces. 0 disables lift and drag forces.")]
+  public float Density;
+  [Tooltip("Viscosity of the medium for viscous forces. 0 disables viscous forces.")]
+  public float Viscosity;
+  [Tooltip("Contact pair margin used when ContactOverride flag is set.")]
+  public float OverrideMargin;
+  [Tooltip("Contact pair solref used when ContactOverride flag is set.")]
+  public SolverReference OverrideSolRef;
+  [Tooltip("Contact pair solimp used when ContactOverride flag is set.")]
+  public SolverImpedance OverrideSolImp;
+  [Tooltip("Numerical integrator.")]
+  public IntegratorType Integrator;
+  [Tooltip("What collision types should be checked.")]
+  public CollisionCheckType Collision;
+  [Tooltip("How to model the friction cone.")]
+  public FrictionConeType Cone;
+  [Tooltip("How to represent the constraint Jacobian.")]
+  public JacobianType Jacobian;
+  [Tooltip("Constraint solver algorithm.")]
+  public ConstraintSolverType Solver;
+  [Tooltip("Maximum iterations for the constraint solver.")]
+  public int Iterations;
+  [Tooltip("Threshold used for early termination of the constraint solver.")]
+  public float Tolerance;
+  [Tooltip("Maximum iterations for the no-slip phase of the constraint solver.")]
+  public int NoSlipIterations;
+  [Tooltip("Threshold used for early termination of the Noslip solver.")]
+  public float NoSlipTolerance;
+  [Tooltip("Maximum iterations for convex mesh collisions.")]
+  public int MprIterations;
+  [Tooltip("Threshold used for early termination of the MPR algorithm.")]
+  public float MprTolerance;
+
+  public MjcfOptionFlag Flag;
+
+  // Default values copied from the "XML reference" page in the MuJoCo documentation.
+  public static MjOptionStruct Default = new MjOptionStruct() {
+    ImpRatio = 1.0f,
+    Magnetic = Vector3.zero,
+    Wind = new Vector3(0.0f, -0.5f, 0.0f),
+    Density = 0.0f,
+    Viscosity = 0.0f,
+    OverrideMargin = 0.0f,
+    OverrideSolRef = SolverReference.Default,
+    OverrideSolImp = SolverImpedance.Default,
+    Integrator = IntegratorType.Euler,
+    Collision = CollisionCheckType.all,
+    Cone = FrictionConeType.pyramidal,
+    Jacobian = JacobianType.auto,
+    Solver = ConstraintSolverType.Newton,
+    Iterations = 100,
+    Tolerance = 1e-8f,
+    NoSlipIterations = 0,
+    NoSlipTolerance = 1e-6f,
+    MprIterations = 50,
+    MprTolerance = 1e-6f,
+    Flag = MjcfOptionFlag.Default
+  };
+
+  public void ParseMjcf(XmlElement mjcf) {
+    if (mjcf.HasAttribute("timestep")) {
+      var mjTimestep = mjcf.GetFloatAttribute("timestep", Time.fixedDeltaTime);
+      if (mjTimestep != Time.fixedDeltaTime) {
+        Debug.unityLogger.LogWarning(
+            "MuJoCo",
+            $"MuJoCo's timestep ({mjTimestep}s) ignored, please set fixedDeltaTime manually.",
+            null);
+      }
+    }
+    if (mjcf.HasAttribute("gravity")) {
+      var mjGravity = mjcf.GetVector3Attribute("gravity", Vector3.zero);
+      Debug.unityLogger.LogWarning(
+          "MuJoCo",
+          $"MuJoCo's gravity ({mjGravity.x} {mjGravity.z} {mjGravity.y}) ignored, " +
+          "please set gravity in the Physics Manager.",
+          null);
+    }
+    var localDefault = MjOptionStruct.Default;
+    ImpRatio = mjcf.GetFloatAttribute("impratio", localDefault.ImpRatio);
+    Magnetic = mjcf.GetVector3Attribute("magnetic", localDefault.Magnetic);
+    Wind = mjcf.GetVector3Attribute("wind", localDefault.Wind);
+    Density = mjcf.GetFloatAttribute("density", localDefault.Density);
+    Viscosity = mjcf.GetFloatAttribute("viscosity", localDefault.Viscosity);
+    OverrideMargin = mjcf.GetFloatAttribute("o_margin", localDefault.OverrideMargin);
+
+    OverrideSolRef.FromMjcf(mjcf, "o_solref");
+    OverrideSolImp.FromMjcf(mjcf, "o_solimp");
+
+    Integrator = mjcf.GetEnumAttribute<IntegratorType>("integrator", localDefault.Integrator);
+    Collision = mjcf.GetEnumAttribute<CollisionCheckType>("collision", localDefault.Collision);
+    Cone = mjcf.GetEnumAttribute<FrictionConeType>("cone", localDefault.Cone);
+    Jacobian = mjcf.GetEnumAttribute<JacobianType>("jacobian", localDefault.Jacobian);
+    Solver = mjcf.GetEnumAttribute<ConstraintSolverType>("solver", localDefault.Solver);
+
+    Iterations = (int)mjcf.GetFloatAttribute("iterations", localDefault.Iterations);
+    Tolerance = mjcf.GetFloatAttribute("tolerance", localDefault.Tolerance);
+    NoSlipIterations = (int)mjcf.GetFloatAttribute(
+        "noslip_iterations", localDefault.NoSlipIterations);
+    NoSlipTolerance = mjcf.GetFloatAttribute("noslip_tolerance", localDefault.NoSlipTolerance);
+    MprIterations = (int)mjcf.GetFloatAttribute("mpr_iterations", localDefault.MprIterations);
+    MprTolerance = mjcf.GetFloatAttribute("mpr_tolerance", localDefault.MprTolerance);
+
+    var flagElements = mjcf.GetElementsByTagName("flag");
+    if (flagElements.Count == 1) {
+      Flag.FromMjcf(flagElements[0] as XmlElement);
+    } else if (flagElements.Count > 1) {
+      throw new ArgumentException("More than one <flag> node is not supported.");
+    }
+  }
+
+  public XmlElement ToMjcf(XmlElement mjcf) {
+    mjcf.SetAttribute("impratio", $"{ImpRatio}");
+
+    mjcf.SetAttribute("magnetic", $"{Magnetic.x} {Magnetic.y} {Magnetic.z}");
+    mjcf.SetAttribute("wind", $"{Wind.x} {Wind.y} {Wind.z}");
+
+    mjcf.SetAttribute("density", $"{Density}");
+    mjcf.SetAttribute("viscosity", $"{Viscosity}");
+    mjcf.SetAttribute("o_margin", $"{OverrideMargin}");
+
+    OverrideSolRef.ToMjcf(mjcf, "o_solref");
+    OverrideSolImp.ToMjcf(mjcf, "o_solimp");
+
+    mjcf.SetAttribute("integrator", Integrator.ToString());
+    mjcf.SetAttribute("collision", Collision.ToString());
+    mjcf.SetAttribute("cone", Cone.ToString());
+    mjcf.SetAttribute("jacobian", Jacobian.ToString());
+    mjcf.SetAttribute("solver", Solver.ToString());
+
+    mjcf.SetAttribute("iterations", $"{Iterations}");
+    mjcf.SetAttribute("tolerance", $"{Tolerance}");
+    mjcf.SetAttribute("noslip_iterations", $"{NoSlipIterations}");
+    mjcf.SetAttribute("noslip_tolerance", $"{NoSlipTolerance}");
+    mjcf.SetAttribute("mpr_iterations", $"{MprIterations}");
+    mjcf.SetAttribute("mpr_tolerance", $"{MprTolerance}");
+
+    var flags = (XmlElement)mjcf.AppendChild(
+        mjcf.OwnerDocument.CreateElement("flag"));
+    Flag.ToMjcf(flags);
+    return mjcf;
+  }
+}
+
+public class MjGlobalSettings : MonoBehaviour {
+
+  [Tooltip("Filename for the generated scene XML.")]
+  public string DebugFileName;
+
+  [Tooltip("Scales the force applied by the mouse spring.")]
+  public float MouseSpringStiffness = 100;
+
+  public MjOptionStruct GlobalOptions = MjOptionStruct.Default;
+
+  public MjSizeStruct GlobalSizes = MjSizeStruct.Default;
+
+  public static MjGlobalSettings Instance {
+    get {
+     if (_instance == null) {
+        var instances = FindObjectsOfType<MjGlobalSettings>();
+        if (instances.Length > 1) {
+          throw new InvalidOperationException(
+              "Only one MjGlobalSettings instance is allowed - please resolve manually.");
+        } else if (instances.Length == 1) {
+          _instance = instances[0];
+        }
+      }
+      return _instance;
+    }
+  }
+
+  private static MjGlobalSettings _instance = null;
+
+  public void Awake() {
+    if (_instance == null) {
+      _instance = this;
+    } else if (_instance != this) {
+      throw new InvalidOperationException(
+          "At most one MjGlobalSettings should be present.");
+    }
+  }
+
+  public void ParseOptionSizeMjcf(XmlElement option, XmlElement size) {
+    if (option != null) {
+      GlobalOptions.ParseMjcf(option);
+    }
+    if (size != null) {
+      GlobalSizes.ParseMjcf(size);
+    }
+  }
+
+  public void OptionSizeToMjcf(XmlElement option, XmlElement size) {
+    GlobalOptions.ToMjcf(option);
+    GlobalSizes.ToMjcf(size);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjGlobalSettings.cs.meta b/unity/Runtime/Components/MjGlobalSettings.cs.meta
new file mode 100644
index 00000000..653f07ac
--- /dev/null
+++ b/unity/Runtime/Components/MjGlobalSettings.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: aafd577af429d4011831f681fe16df0b
+timeCreated: 1548950233
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjHingeJoint.cs b/unity/Runtime/Components/MjHingeJoint.cs
new file mode 100644
index 00000000..eb5c2490
--- /dev/null
+++ b/unity/Runtime/Components/MjHingeJoint.cs
@@ -0,0 +1,88 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public class MjHingeJoint : MjBaseJoint {
+    [Tooltip("In degrees.")]
+    public float RangeLower;
+    [Tooltip("In degrees.")]
+    public float RangeUpper;
+
+    [Tooltip("The current joint angle, in degrees. Read-only at play time.")]
+    public float Configuration;
+
+    [Tooltip("Joint movement, in rad/sec. Read-only at play time.")]
+    public float Velocity;
+
+    [Tooltip("Joint settings.")]
+    public MjJointSettings Settings = MjJointSettings.Default;
+
+    // World space rotation axis.
+    public Vector3 RotationAxis => transform.rotation * Vector3.right;
+
+    protected override unsafe void OnBindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {
+      base.OnBindToRuntime(model, data);
+      data->qvel[DofAddress] = Velocity;
+    }
+
+    public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+      var qpos = (float)data->qpos[QposAddress];
+      Configuration = (qpos % (2 * Mathf.PI)) * Mathf.Rad2Deg;
+      Velocity = (float)data->qvel[DofAddress];
+    }
+
+    protected override void OnParseMjcf(XmlElement mjcf) {
+      transform.localPosition =
+          MjEngineTool.UnityVector3(mjcf.GetVector3Attribute("pos", defaultValue: Vector3.zero));
+
+      var rotationAxis =
+          MjEngineTool.UnityVector3(mjcf.GetVector3Attribute("axis", defaultValue: Vector3.right));
+      transform.localRotation = Quaternion.FromToRotation(Vector3.right, rotationAxis);
+
+      var rangeValues = mjcf.GetFloatArrayAttribute("range", defaultValue: new float[] { 0, 0 });
+      RangeLower = rangeValues[0];
+      RangeUpper = rangeValues[1];
+
+      if (!MjSceneImportSettings.AnglesInDegrees) {
+        RangeLower *= Mathf.Rad2Deg;
+        RangeUpper *= Mathf.Rad2Deg;
+      }
+
+      Configuration = mjcf.GetFloatAttribute("ref", 0.0f);
+
+      Settings.FromMjcf(mjcf);
+    }
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      var mjcf = (XmlElement)doc.CreateElement("joint");
+      mjcf.SetAttribute("type", "hinge");
+
+      MjEngineTool.PositionAxisToMjcf(mjcf, this);
+
+      Settings.ToMjcf(mjcf);
+      if (RangeLower > RangeUpper) {
+        throw new ArgumentException("Lower range value can't be bigger than Higher");
+      }
+      mjcf.SetAttribute("range", $"{RangeLower} {RangeUpper}");
+      mjcf.SetAttribute("ref", $"{Configuration}");
+
+      return mjcf;
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjHingeJoint.cs.meta b/unity/Runtime/Components/MjHingeJoint.cs.meta
new file mode 100644
index 00000000..fb730d9a
--- /dev/null
+++ b/unity/Runtime/Components/MjHingeJoint.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 517cde9d618b143a19f0ad61355a7f31
+timeCreated: 1537542636
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjInertial.cs b/unity/Runtime/Components/MjInertial.cs
new file mode 100644
index 00000000..f43406f3
--- /dev/null
+++ b/unity/Runtime/Components/MjInertial.cs
@@ -0,0 +1,64 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Defines an inertial frame of a body.
+public class MjInertial : MjComponent {
+
+  [Tooltip("Mass assigned to the parent body.")]
+  public float Mass = 1.0f;
+
+  [Tooltip("Diagonal inertia matrix, expressing the body inertia relative to the inertial frame.")]
+  public Vector3 DiagInertia = Vector3.one;
+
+  public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_BODY;
+  protected override bool _suppressNameAttribute => true;
+
+  // Parse the component settings from an external Mjcf.
+  protected override void OnParseMjcf(XmlElement mjcf) {
+    MjEngineTool.ParseTransformMjcf(mjcf, transform);
+    Mass = mjcf.GetFloatAttribute("mass", defaultValue: 1.0f);
+    DiagInertia = MjEngineTool.UnityExtents(
+        mjcf.GetVector3Attribute("diaginertia", defaultValue: Vector3.one));
+  }
+
+  // Generate implementation specific XML element.
+  protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+    var mjcf = (XmlElement)doc.CreateElement("inertial");
+    MjEngineTool.PositionRotationToMjcf(mjcf, this);
+    mjcf.SetAttribute("mass", $"{Mass}");
+    mjcf.SetAttribute("diaginertia",
+                      MjEngineTool.Vector3ToMjcf(MjEngineTool.MjExtents(DiagInertia)));
+    return mjcf;
+  }
+
+  protected void OnDrawGizmosSelected() {
+    Gizmos.color = Color.yellow;
+    var oldMatrix = Gizmos.matrix;
+    Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, transform.lossyScale);
+    var box = new Vector3(
+        Mathf.Sqrt((DiagInertia[1] + DiagInertia[2] - DiagInertia[0]) / Mass * 6.0f),
+        Mathf.Sqrt((DiagInertia[0] + DiagInertia[2] - DiagInertia[1]) / Mass * 6.0f),
+        Mathf.Sqrt((DiagInertia[0] + DiagInertia[1] - DiagInertia[2]) / Mass * 6.0f));
+    Gizmos.DrawWireCube(Vector3.zero, box);
+    Gizmos.matrix = oldMatrix;
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjInertial.cs.meta b/unity/Runtime/Components/MjInertial.cs.meta
new file mode 100644
index 00000000..e96f0bf8
--- /dev/null
+++ b/unity/Runtime/Components/MjInertial.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0fdc02620a5cf483ea8ca90a983aa0bc
+timeCreated: 1550587293
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjJointConstraint.cs b/unity/Runtime/Components/MjJointConstraint.cs
new file mode 100644
index 00000000..17182ec1
--- /dev/null
+++ b/unity/Runtime/Components/MjJointConstraint.cs
@@ -0,0 +1,59 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public class MjJointConstraint : MjBaseConstraint {
+    [Tooltip("Mandatory.")]
+    public MjBaseJoint Joint1;
+
+    [Tooltip("Optional - if empty, constrain the value of Joint1")]
+    public MjBaseJoint Joint2;
+
+    public float[] PolynomialCoefficients = new float[5] { 0, 1, 0, 0, 0 };
+    protected override string _constraintName => "joint";
+
+    protected override void FromMjcf(XmlElement mjcf) {
+      Joint1 = mjcf.GetObjectReferenceAttribute<MjBaseJoint>("joint1");
+      Joint2 = mjcf.GetObjectReferenceAttribute<MjBaseJoint>("joint2");
+      PolynomialCoefficients =
+          mjcf.GetFloatArrayAttribute("polycoef", defaultValue: new float[] { 0, 1, 0, 0, 0 });
+    }
+
+    // Generate implementation specific XML element.
+    protected override void ToMjcf(XmlElement mjcf) {
+      if (Joint1 == null) {
+        throw new NullReferenceException($"At least Joint1 in constraint {name} must be assigned.");
+      }
+
+      mjcf.SetAttribute("joint1", Joint1.MujocoName);
+      if (Joint2 != null) {
+        mjcf.SetAttribute("joint2", Joint2.MujocoName);
+      }
+      mjcf.SetAttribute("polycoef", MjEngineTool.ArrayToMjcf(PolynomialCoefficients));
+    }
+
+    public void OnValidate() {
+      if (Joint1 != null && Joint1 == Joint2) {
+        Debug.LogError("Joint1 and Joint2 can't be the same - resetting Joint2.", this);
+        Joint2 = null;
+      }
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjJointConstraint.cs.meta b/unity/Runtime/Components/MjJointConstraint.cs.meta
new file mode 100644
index 00000000..e2789541
--- /dev/null
+++ b/unity/Runtime/Components/MjJointConstraint.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 1cf109d843189466880870d026d0c2c7
+timeCreated: 1552309644
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjJointScalarSensor.cs b/unity/Runtime/Components/MjJointScalarSensor.cs
new file mode 100644
index 00000000..37867f09
--- /dev/null
+++ b/unity/Runtime/Components/MjJointScalarSensor.cs
@@ -0,0 +1,56 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+public class MjJointScalarSensor : MjBaseSensor {
+  // NOTE: These names must match sensor names listed on mujoco.org.
+  // Changing them is justified only when Mujoco is upgraded to a new version.
+  public enum AvailableSensors {
+    JointPos,
+    JointVel,
+    JointLimitPos,
+    JointLimitVel,
+    JointLimitFrc,
+  }
+  public AvailableSensors SensorType;
+  public MjBaseJoint Joint;
+
+  public double SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Joint == null) {
+      throw new NullReferenceException("Missing a reference to a Joint.");
+    }
+    var mjcf = doc.CreateElement(SensorType.ToString().ToLower());
+    mjcf.SetAttribute("joint", Joint.MujocoName);
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    if (!Enum.TryParse(mjcf.Name, ignoreCase: true, result: out SensorType)) {
+      throw new ArgumentException($"Unknown sensor type {mjcf.Name}.");
+    }
+    Joint = mjcf.GetObjectReferenceAttribute<MjBaseJoint>("joint");
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+     SensorReading = data->sensordata[_sensorAddress];
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjJointScalarSensor.cs.meta b/unity/Runtime/Components/MjJointScalarSensor.cs.meta
new file mode 100644
index 00000000..dcbcf278
--- /dev/null
+++ b/unity/Runtime/Components/MjJointScalarSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: a4f0b9237548c452e8a050f3e4cba63e
+timeCreated: 1548092931
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjJointSettings.cs b/unity/Runtime/Components/MjJointSettings.cs
new file mode 100644
index 00000000..da96e373
--- /dev/null
+++ b/unity/Runtime/Components/MjJointSettings.cs
@@ -0,0 +1,171 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [Serializable]
+  public struct MjJointSettings {
+    [Tooltip("Added inertia of all DoFs created by this joint.")]
+    public float Armature;
+
+    [Tooltip("Joint spring settings.")]
+    public SpringSettings Spring;
+
+    [Tooltip("Joint solver settings.")]
+    public SolverSettings Solver;
+
+    // Default joint settings.
+    public static MjJointSettings Default = new MjJointSettings() {
+      Solver = SolverSettings.Default,
+    };
+
+    public void FromMjcf(XmlElement mjcf) {
+      Armature = mjcf.GetFloatAttribute("armature", 0.0f);
+      Spring.FromMjcf(mjcf);
+      Solver.FromMjcf(mjcf);
+    }
+
+    public void ToMjcf(XmlElement mjcf) {
+      mjcf.SetAttribute("armature", $"{Armature}");
+      Spring.ToMjcf(mjcf);
+      Solver.ToMjcf(mjcf);
+    }
+  }
+
+  [Serializable]
+  public struct SpringSettings {
+    public float TimeConstant;
+    public float DampingRatio;
+
+    [Tooltip("Joint stiffness. If this value is positive, a spring will be created.")]
+    public float Stiffness;
+    [Tooltip("Damping applied to all degrees of freedom created by this joint.")]
+    public float Damping;
+
+    [Tooltip("Spring equilibrium pose.")]
+    public float EquilibriumPose;
+
+    public void ToMjcf(XmlElement mjcf) {
+      // Spring settings.
+      mjcf.SetAttribute("springref", $"{EquilibriumPose}");
+      mjcf.SetAttribute("springdamper", $"{TimeConstant} {DampingRatio}");
+      mjcf.SetAttribute("damping", $"{Damping}");
+      mjcf.SetAttribute("stiffness", $"{Stiffness}");
+    }
+
+    public void FromMjcf(XmlElement mjcf) {
+      var springDamper = mjcf.GetVector2Attribute("springdamper", Vector2.zero);
+      TimeConstant = springDamper.x;
+      DampingRatio = springDamper.y;
+      EquilibriumPose = mjcf.GetFloatAttribute("springref", 0.0f);
+      Damping = mjcf.GetFloatAttribute("damping", 0.0f);
+      Stiffness = mjcf.GetFloatAttribute("stiffness", 0.0f);
+    }
+  }
+
+  [Serializable]
+  public struct SolverImpedance {
+    public float DMin;
+    public float DMax;
+    public float Width;
+    public float Midpoint;
+    public float Power;
+
+    public static SolverImpedance Default =
+        new SolverImpedance() { DMin = 0.9f, DMax = 0.95f, Width = 0.001f, Midpoint = 0.5f,
+                                Power = 2.0f };
+
+    public void FromMjcf(XmlElement element, string attributeName) {
+      var values = element.GetFloatArrayAttribute(
+          attributeName, new float[] { Default.DMin, Default.DMax, Default.Width, Default.Midpoint,
+                                       Default.Power });
+      DMin = values[0];
+      DMax = values[1];
+      Width = values[2];
+      Midpoint = values[3];
+      Power = values[4];
+    }
+
+    public void ToMjcf(XmlElement element, string attributeName) {
+      element.SetAttribute(attributeName, $"{DMin} {DMax} {Width} {Midpoint} {Power}");
+    }
+  }
+
+  [Serializable]
+  public struct SolverReference {
+    public float TimeConst;
+    public float DampRatio;
+
+    public static SolverReference Default =
+        new SolverReference() { TimeConst = 0.02f, DampRatio = 1.0f };
+
+    public void FromMjcf(XmlElement element, string attributeName) {
+      var values = element.GetFloatArrayAttribute(
+          attributeName, new float[] { Default.TimeConst, Default.DampRatio });
+      TimeConst = values[0];
+      DampRatio = values[1];
+    }
+
+    public void ToMjcf(XmlElement element, string attributeName) {
+      element.SetAttribute(attributeName, $"{TimeConst} {DampRatio}");
+    }
+  }
+
+  [Serializable]
+  public struct SolverSettings {
+    [Tooltip("Does the joint have limits.")]
+    public bool Limited;
+
+    [Tooltip("Limit margin - always in radians/meters.")]
+    public float Margin;
+    public SolverReference RefLimit;
+    public SolverImpedance ImpLimit;
+
+    [Tooltip("Friction loss due to dry friction.")]
+    public float FrictionLoss;
+    public SolverImpedance ImpFriction;
+    public SolverReference RefFriction;
+
+    public static SolverSettings Default = new SolverSettings() {
+      ImpFriction = SolverImpedance.Default,
+      ImpLimit = SolverImpedance.Default,
+      RefFriction = SolverReference.Default,
+      RefLimit = SolverReference.Default,
+    };
+
+    public void ToMjcf(XmlElement mjcf) {
+      RefLimit.ToMjcf(mjcf, "solreflimit");
+      ImpLimit.ToMjcf(mjcf, "solimplimit");
+      RefFriction.ToMjcf(mjcf, "solreffriction");
+      ImpFriction.ToMjcf(mjcf, "solimpfriction");
+      mjcf.SetAttribute("frictionloss", $"{FrictionLoss}");
+      mjcf.SetAttribute("limited", $"{Limited}".ToLower());
+      mjcf.SetAttribute("margin", $"{Margin}");
+    }
+
+    public void FromMjcf(XmlElement mjcf) {
+      RefLimit.FromMjcf(mjcf, "solreflimit");
+      ImpLimit.FromMjcf(mjcf, "solimplimit");
+      RefFriction.FromMjcf(mjcf, "solreffriction");
+      ImpFriction.FromMjcf(mjcf, "solimpfriction");
+      FrictionLoss = mjcf.GetFloatAttribute("frictionloss", 0.0f);
+      Limited = mjcf.GetBoolAttribute("limited", false);
+      Margin = mjcf.GetFloatAttribute("margin", defaultValue: 0.0f);
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjJointSettings.cs.meta b/unity/Runtime/Components/MjJointSettings.cs.meta
new file mode 100644
index 00000000..d9b50190
--- /dev/null
+++ b/unity/Runtime/Components/MjJointSettings.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c02a22208190149a6a949f4247c77155
+timeCreated: 1537542636
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjMeshFilter.cs b/unity/Runtime/Components/MjMeshFilter.cs
new file mode 100644
index 00000000..dd238ba4
--- /dev/null
+++ b/unity/Runtime/Components/MjMeshFilter.cs
@@ -0,0 +1,78 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Mujoco {
+
+[RequireComponent(typeof(MjShapeComponent))]
+[RequireComponent(typeof(MeshFilter))]
+[ExecuteInEditMode]
+public class MjMeshFilter : MonoBehaviour {
+  private MjShapeComponent _geom;
+  private Vector4 _shapeChangeStamp;
+  private MeshFilter _meshFilter;
+
+  protected void Awake() {
+    _geom = GetComponent<MjShapeComponent>();
+    _shapeChangeStamp = new Vector4(0, 0, 0, -1);
+    _meshFilter = GetComponent<MeshFilter>();
+  }
+
+  protected void Update() {
+    var currentChangeStamp = _geom.GetChangeStamp();
+    if ((_shapeChangeStamp - currentChangeStamp).magnitude <= 1e-3f) {
+      return;
+    }
+
+    _shapeChangeStamp = currentChangeStamp;
+    Tuple<Vector3[], int[]> meshData = _geom.BuildMesh();
+
+    if (meshData == null) {
+      throw new ArgumentException("Unsupported geom shape detected");
+    }
+
+    DisposeCurrentMesh();
+
+    var mesh = new Mesh();
+    // Name this mesh to easily track resources in Unity analysis tools.
+    mesh.name = $"Mujoco mesh for {gameObject.name}, id:{mesh.GetInstanceID()}";
+    _meshFilter.sharedMesh = mesh;
+    mesh.vertices = meshData.Item1;
+    mesh.triangles = meshData.Item2;
+    mesh.RecalculateNormals();
+    mesh.RecalculateTangents();
+  }
+
+  protected void OnDestroy() {
+    DisposeCurrentMesh();
+  }
+
+  // Dynamically created meshes with no references are only disposed automatically on scene changes.
+  // This prevents resource leaks in case the host environment doesn't reload scenes.
+  private void DisposeCurrentMesh() {
+    if (_meshFilter.sharedMesh != null) {
+#if UNITY_EDITOR
+      DestroyImmediate(_meshFilter.sharedMesh);
+#else
+      Destroy(_meshFilter.sharedMesh);
+#endif
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjMeshFilter.cs.meta b/unity/Runtime/Components/MjMeshFilter.cs.meta
new file mode 100644
index 00000000..976a1776
--- /dev/null
+++ b/unity/Runtime/Components/MjMeshFilter.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c762400e63d394f6fa8f9f7885edb79e
+timeCreated: 1539770521
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjMeshShape.cs b/unity/Runtime/Components/MjMeshShape.cs
new file mode 100644
index 00000000..e4fa338d
--- /dev/null
+++ b/unity/Runtime/Components/MjMeshShape.cs
@@ -0,0 +1,56 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+[Serializable]
+public class MjMeshShape : IMjShape {
+
+  public Mesh Mesh;
+
+  public void ToMjcf(XmlElement mjcf, Transform transform) {
+    var scene = MjScene.Instance;
+    var assetName = scene.GenerationContext.AddMeshAsset(Mesh);
+    mjcf.SetAttribute("mesh", assetName);
+  }
+
+  public void FromMjcf(XmlElement mjcf) {
+    // When the asset was parsed and stored its name was sanitized, so we should load it using a
+    // sanitized name:
+    var assetName = MjEngineTool.Sanitize(
+        mjcf.GetStringAttribute("mesh", defaultValue: string.Empty));
+    if (!string.IsNullOrEmpty(assetName)) {
+      Mesh = (Mesh)Resources.Load(assetName);
+    }
+  }
+
+  public Tuple<Vector3[], int[]> BuildMesh() {
+    return Tuple.Create(Mesh.vertices, Mesh.triangles);
+  }
+
+  public Vector4 GetChangeStamp() {
+    return Vector4.one;
+  }
+
+  public void DebugDraw(Transform transform) {
+    Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, transform.lossyScale);
+    Gizmos.DrawWireMesh(Mesh);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjMeshShape.cs.meta b/unity/Runtime/Components/MjMeshShape.cs.meta
new file mode 100644
index 00000000..e4fb7936
--- /dev/null
+++ b/unity/Runtime/Components/MjMeshShape.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 74b6655bbc8424b73ab3428b5ea018e6
+timeCreated: 1549902766
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjMocapBody.cs b/unity/Runtime/Components/MjMocapBody.cs
new file mode 100644
index 00000000..4977a1d6
--- /dev/null
+++ b/unity/Runtime/Components/MjMocapBody.cs
@@ -0,0 +1,42 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+  public class MjMocapBody : MjBaseBody {
+    protected override void OnParseMjcf(XmlElement mjcf) {
+      throw new Exception("parsing mocap bodies isn't supported.");
+    }
+
+    protected override unsafe void OnBindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {
+      var bodyId = MujocoLib.mj_name2id(model, (int)ObjectType, MujocoName);
+      MujocoId = model->body_mocapid[bodyId];
+    }
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      var mjcf = doc.CreateElement("body");
+      MjEngineTool.PositionRotationToMjcf(mjcf, this);
+      mjcf.SetAttribute("mocap", "true");
+      return mjcf;
+    }
+
+    public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+      MjEngineTool.SetMjVector3(data->mocap_pos, transform.position, MujocoId);
+      MjEngineTool.SetMjQuaternion(data->mocap_quat, transform.rotation, MujocoId);
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjMocapBody.cs.meta b/unity/Runtime/Components/MjMocapBody.cs.meta
new file mode 100644
index 00000000..57e7c486
--- /dev/null
+++ b/unity/Runtime/Components/MjMocapBody.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 70484c223582e443890dac6faef67046
+timeCreated: 1551357866
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjPlaneShape.cs b/unity/Runtime/Components/MjPlaneShape.cs
new file mode 100644
index 00000000..640b3ead
--- /dev/null
+++ b/unity/Runtime/Components/MjPlaneShape.cs
@@ -0,0 +1,50 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+[Serializable]
+public class MjPlaneShape : IMjShape {
+  public Vector2 Extents = Vector3.one;
+
+  public void ToMjcf(XmlElement mjcf, Transform transform) {
+    var extents = new Vector3(Extents.x, Extents.y, 1.0f);
+    var scaledExtents = Vector3.Scale(extents, transform.lossyScale);
+    mjcf.SetAttribute("size", $"{scaledExtents.x} {scaledExtents.y} {scaledExtents.z}");
+  }
+
+  public void FromMjcf(XmlElement mjcf) {
+    var components = mjcf.GetFloatArrayAttribute("size", defaultValue: new float[] { 1, 1, 1 });
+    Extents = new Vector2(components[0], components[1]);
+  }
+
+  public Tuple<Vector3[], int[]> BuildMesh() {
+    return MeshGenerators.BuildPlane(Extents.x * 2.0f, Extents.y * 2.0f);
+  }
+
+  public Vector4 GetChangeStamp() {
+    return new Vector4(Extents.x, Extents.y, 1, 0);
+  }
+
+  public void DebugDraw(Transform transform) {
+    Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
+    MjGizmos.DrawWirePlane(Vector3.zero, Extents.x * 2.0f, Extents.y * 2.0f);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjPlaneShape.cs.meta b/unity/Runtime/Components/MjPlaneShape.cs.meta
new file mode 100644
index 00000000..8a0726fa
--- /dev/null
+++ b/unity/Runtime/Components/MjPlaneShape.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 8f4c670eb5b2f4a97826a6a22705ed4d
+timeCreated: 1547647081
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjScene.cs b/unity/Runtime/Components/MjScene.cs
new file mode 100644
index 00000000..0ecb890a
--- /dev/null
+++ b/unity/Runtime/Components/MjScene.cs
@@ -0,0 +1,451 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Xml;
+using UnityEngine;
+using UnityEngine.Profiling;
+
+namespace Mujoco {
+
+public class PhysicsRuntimeException : Exception {
+  public PhysicsRuntimeException(string message) : base(message) {}
+}
+
+public class MjScene : MonoBehaviour {
+
+  public unsafe MujocoLib.mjModel_* Model = null;
+  public unsafe MujocoLib.mjData_* Data = null;
+
+  // Public and global access to the active MjSceneGenerationContext.
+  // Throws an exception if accessed when the scene is not being generated.
+  public MjcfGenerationContext GenerationContext {
+    get {
+      if (_generationContext == null) {
+        throw new InvalidOperationException(
+            "This property can only be accessed from the scope of MjComponent.GenerateMjcf().");
+      }
+      return _generationContext;
+    }
+  }
+
+  public static MjScene Instance {
+    get {
+      if (_instance == null) {
+        var instances = FindObjectsOfType<MjScene>();
+        if (instances.Length >= 1) { // even one is too much - _instance shouldn't have been null.
+          throw new InvalidOperationException(
+              "A MjScene singleton is created automatically, yet multiple instances exist.");
+        } else {
+          GameObject go = new GameObject("MjScene");
+          _instance = go.AddComponent<MjScene>();
+        }
+      }
+      return _instance;
+    }
+  }
+
+  public void Awake() {
+    if (_instance == null) {
+      _instance = this;
+    } else if (_instance != this) {
+      throw new InvalidOperationException(
+          "MjScene is a singleton, yet multiple instances found.");
+    }
+  }
+
+  private static MjScene _instance = null;
+
+  private List<MjComponent> _orderedComponents;
+
+  protected unsafe void Start() {
+    CreateScene();
+  }
+
+  protected unsafe void OnDestroy() {
+    DestroyScene();
+  }
+
+  protected unsafe void FixedUpdate() {
+    StepScene();
+  }
+
+  public bool SceneRecreationAtLateUpdateRequested = false;
+
+  protected unsafe void LateUpdate() {
+    if (SceneRecreationAtLateUpdateRequested) {
+      RecreateScene();
+      SceneRecreationAtLateUpdateRequested = false;
+    }
+  }
+
+  // Context used during scene generation where components will store their shared dependencies
+  // (such as the mesh assets they reference, or common compiler settings that need to be resolved
+  // globally).
+  // The field will be initialized with a class instance only during the scene generation.
+  // A public read-only property will provide MjComponents with access to the instance
+  // of that field.
+  private MjcfGenerationContext _generationContext;
+
+  // Builds a new Mujoco scene.
+  public unsafe XmlDocument CreateScene(bool skipCompile=false) {
+    if (_generationContext != null) {
+      throw new InvalidOperationException(
+          "The scene is currently being generated on another thread.");
+    }
+    // Linearize the hierarchy of transforms of the components.
+    // We will use this list to update the transforms of the associated GameObject in a way that
+    // ensures we first update the parent transforms, and then we progress down the hierarchy
+    // tree and update the children.
+    // We're doing this, because we will use Unity's hierarchical transforms system to translate
+    // Mujoco elements' world transforms directly to Unity's world coordinates. That however
+    // will only work if we can guarantee that for every child, the parent transforms have already
+    // been recalculated.
+    //
+    // DESIGN: An alternative to that would be to operate in local space on the Unity side.
+    // I briefly explored that approach, but decided against it. It increases the amount of code
+    // on the side of the individual components. This solution allows to restrict the code in the
+    // components to a bare minimum, at the expense of one extra method here.
+    var hierarchyRoots = FindObjectsOfType<MjComponent>()
+        .Where(component => MjHierarchyTool.FindParentComponent(component) == null)
+        .Select(component => component.transform)
+        .Distinct();
+    _orderedComponents = new List<MjComponent>();
+    foreach (var root in hierarchyRoots) {
+      _orderedComponents.AddRange(MjHierarchyTool.LinearizeHierarchyBFS(root));
+    }
+
+    XmlDocument sceneMjcf = null;
+    try {
+      _generationContext = new MjcfGenerationContext();
+      sceneMjcf = GenerateSceneMjcf(_orderedComponents);
+    } catch (Exception e) {
+      _generationContext = null;
+      Debug.LogException(e);
+#if UNITY_EDITOR
+      UnityEditor.EditorApplication.isPlaying = false;
+#else
+      Application.Quit();
+#endif
+      throw;
+    }
+    _generationContext = null;
+
+    // Save the Mjcf to a file for debug purposes.
+    var settings = MjGlobalSettings.Instance;
+    if (settings && !string.IsNullOrEmpty(settings.DebugFileName)) {
+      SaveToFile(sceneMjcf, Path.Combine(Application.temporaryCachePath, settings.DebugFileName));
+    }
+
+    if (!skipCompile) {
+      // Compile the scene from the Mjcf.
+      CompileScene(sceneMjcf, _orderedComponents);
+    }
+    return sceneMjcf;
+  }
+
+  private unsafe void CompileScene(
+      XmlDocument mjcf, IEnumerable<MjComponent> components) {
+    Model = MjEngineTool.LoadModelFromString(mjcf.OuterXml);
+    if (Model == null) {
+      throw new NullReferenceException("Failed to create Mujoco runtime model.");
+    } else {
+      Data = MujocoLib.mj_makeData(Model);
+    }
+    if (Data == null) {
+      throw new NullReferenceException("Failed to create Mujoco runtime data.");
+    }
+
+    // Bind the components to their Mujoco counterparts.
+    foreach (var component in components) {
+      component.BindToRuntime(Model, Data);
+    }
+  }
+
+  public unsafe void SyncUnityToMjState() {
+    foreach (var component in _orderedComponents) {
+      if (component != null && component.isActiveAndEnabled) {
+        component.OnSyncState(Data);
+      }
+    }
+  }
+
+  // This must be called after every change in the Unity scene during runtime, in order to keep the
+  // MuJoCo physics scene in sync.  The spatial arrangement in the MJCF that creates the new physics
+  // is defined by the Unity transforms; therefore, we:
+  // 1. cache the joint states;
+  // 2. reset the Unity scene to its configuration at initialization;
+  // 3. recreate the scene in this pristine configuration;
+  // 4. rehydrate the physics scene, and sync the Unity scene to it.
+  public unsafe void RecreateScene() {
+    // cache joint states in order to re-apply it to the new scene
+    var joints = FindObjectsOfType<MjBaseJoint>();
+    var positions = new Dictionary<MjBaseJoint, double[]>();
+    var velocities = new Dictionary<MjBaseJoint, double[]>();
+    foreach (var joint in joints) {
+      if (joint.QposAddress > -1) { // newly added components shouldn't be cached
+        switch (Model->jnt_type[joint.MujocoId]) {
+          default:
+          case (int)MujocoLib.mjtJoint.mjJNT_HINGE:
+          case (int)MujocoLib.mjtJoint.mjJNT_SLIDE:
+            positions[joint] = new double[] {Data->qpos[joint.QposAddress]};
+            velocities[joint] = new double[] {Data->qvel[joint.DofAddress]};
+            break;
+          case (int)MujocoLib.mjtJoint.mjJNT_BALL:
+            positions[joint] = new double[] {
+                Data->qpos[joint.QposAddress],
+                Data->qpos[joint.QposAddress+1],
+                Data->qpos[joint.QposAddress+2],
+                Data->qpos[joint.QposAddress+3]};
+            velocities[joint] = new double[] {
+                Data->qvel[joint.DofAddress],
+                Data->qvel[joint.DofAddress+1],
+                Data->qvel[joint.DofAddress+2]};
+            break;
+          case (int)MujocoLib.mjtJoint.mjJNT_FREE:
+            positions[joint] = new double[] {
+                Data->qpos[joint.QposAddress],
+                Data->qpos[joint.QposAddress+1],
+                Data->qpos[joint.QposAddress+2],
+                Data->qpos[joint.QposAddress+3],
+                Data->qpos[joint.QposAddress+4],
+                Data->qpos[joint.QposAddress+5],
+                Data->qpos[joint.QposAddress+6]};
+            velocities[joint] = new double[] {
+                Data->qvel[joint.DofAddress],
+                Data->qvel[joint.DofAddress+1],
+                Data->qvel[joint.DofAddress+2],
+                Data->qvel[joint.DofAddress+3],
+                Data->qvel[joint.DofAddress+4],
+                Data->qvel[joint.DofAddress+5]};
+            break;
+        }
+      }
+    }
+
+    // update unity transforms according to qpos0, so they're ready to create the new MJCF
+    MujocoLib.mj_resetData(Model, Data);
+    MujocoLib.mj_kinematics(Model, Data);
+    SyncUnityToMjState();
+
+    // Delete previous model, data
+    DestroyScene();
+    // Create a new MJCF and new model+data, indices may be different
+    CreateScene();
+
+    // for joints that persisted, set state of the new MuJoCo scene according to the cached state
+    foreach (var joint in joints) {
+      try {
+        var position = positions[joint]; // this will fail for new joints, hence try/catch
+        var velocity = velocities[joint];
+        switch (Model->jnt_type[joint.MujocoId]) {
+          default:
+          case (int)MujocoLib.mjtJoint.mjJNT_HINGE:
+          case (int)MujocoLib.mjtJoint.mjJNT_SLIDE:
+            Data->qpos[joint.QposAddress] = position[0];
+            Data->qvel[joint.DofAddress] = velocity[0];
+            break;
+          case (int)MujocoLib.mjtJoint.mjJNT_BALL:
+            Data->qpos[joint.QposAddress] = position[0];
+            Data->qpos[joint.QposAddress+1] = position[1];
+            Data->qpos[joint.QposAddress+2] = position[2];
+            Data->qpos[joint.QposAddress+3] = position[3];
+            Data->qvel[joint.DofAddress] = velocity[0];
+            Data->qvel[joint.DofAddress+1] = velocity[1];
+            Data->qvel[joint.DofAddress+2] = velocity[2];
+            break;
+          case (int)MujocoLib.mjtJoint.mjJNT_FREE:
+            Data->qpos[joint.QposAddress] = position[0];
+            Data->qpos[joint.QposAddress+1] = position[1];
+            Data->qpos[joint.QposAddress+2] = position[2];
+            Data->qpos[joint.QposAddress+3] = position[3];
+            Data->qpos[joint.QposAddress+4] = position[4];
+            Data->qpos[joint.QposAddress+5] = position[5];
+            Data->qpos[joint.QposAddress+6] = position[6];
+            Data->qvel[joint.DofAddress] = velocity[0];
+            Data->qvel[joint.DofAddress+1] = velocity[1];
+            Data->qvel[joint.DofAddress+2] = velocity[2];
+            Data->qvel[joint.DofAddress+3] = velocity[3];
+            Data->qvel[joint.DofAddress+4] = velocity[4];
+            Data->qvel[joint.DofAddress+5] = velocity[5];
+            break;
+        }
+      } catch {}
+    }
+    // update mj transforms:
+    MujocoLib.mj_kinematics(Model, Data);
+    SyncUnityToMjState();
+  }
+
+  // Destroys the Mujoco scene.
+  public unsafe void DestroyScene() {
+    if (Model != null) {
+      MujocoLib.mj_deleteModel(Model);
+      Model = null;
+    }
+    if (Data != null) {
+      MujocoLib.mj_deleteData(Data);
+      Data = null;
+    }
+  }
+
+  // Updates the scene and the state of Mujoco simulation.
+  public unsafe void StepScene() {
+    if (Model == null || Data == null) {
+      throw new NullReferenceException("Failed to create Mujoco runtime.");
+    }
+    Profiler.BeginSample("MjStep");
+    Profiler.BeginSample("MjStep.mj_step");
+    MujocoLib.mj_step(Model, Data);
+    Profiler.EndSample(); // MjStep.mj_step
+    CheckForPhysicsException();
+
+    Profiler.BeginSample("MjStep.OnSyncState");
+    SyncUnityToMjState();
+    Profiler.EndSample(); // MjStep.OnSyncState
+    Profiler.EndSample(); // MjStep
+  }
+
+  private unsafe void CheckForPhysicsException() {
+    if (Data->warning0.number > 0) {
+      Data->warning0.number = 0;
+      throw new PhysicsRuntimeException("INERTIA: (Near-) Singular inertia matrix.");
+    }
+    if (Data->warning1.number > 0) {
+      Data->warning1.number = 0;
+      throw new PhysicsRuntimeException($"CONTACTFULL: nconmax {Model->nconmax} isn't sufficient.");
+    }
+    if (Data->warning2.number > 0) {
+      Data->warning2.number = 0;
+      throw new PhysicsRuntimeException("CNSTRFULL: njmax {Model.njmax} isn't sufficient.");
+    }
+    if (Data->warning3.number > 0) {
+      Data->warning3.number = 0;
+      throw new PhysicsRuntimeException("VGEOMFULL: who constructed a mjvScene?!");
+    }
+    if (Data->warning4.number > 0) {
+      Data->warning4.number = 0;
+      throw new PhysicsRuntimeException("BADQPOS: NaN/inf in qpos.");
+    }
+    if (Data->warning5.number > 0) {
+      Data->warning5.number = 0;
+      throw new PhysicsRuntimeException("BADQVEL: NaN/inf in qvel.");
+    }
+    if (Data->warning6.number > 0) {
+      Data->warning6.number = 0;
+      throw new PhysicsRuntimeException("BADQACC: NaN/inf in qacc.");
+    }
+    if (Data->warning7.number > 0) {
+      Data->warning7.number = 0;
+      throw new PhysicsRuntimeException("BADCTRL: NaN/inf in ctrl.");
+    }
+  }
+
+  // Generate a Mujoco scene description using the specified components.
+  private XmlDocument GenerateSceneMjcf(IEnumerable<MjComponent> components) {
+    var doc = new XmlDocument();
+    var MjRoot = (XmlElement)doc.AppendChild(doc.CreateElement("mujoco"));
+
+    // Scene definition section.
+    var worldMjcf = (XmlElement)MjRoot.AppendChild(doc.CreateElement("worldbody"));
+    BuildHierarchicalMjcf(
+        doc,
+        components.Where(component =>
+            (component is MjBaseBody) ||
+            (component is MjInertial) ||
+            (component is MjBaseJoint) ||
+            (component is MjGeom) ||
+            (component is MjSite)),
+        worldMjcf);
+
+    // Non-hierarchical sections:
+    MjRoot.AppendChild(GenerateMjcfSection(
+        doc, components.Where(component => component is MjExclude), "contact"));
+
+    MjRoot.AppendChild(GenerateMjcfSection(
+        doc, components.Where(component => component is MjBaseTendon), "tendon"));
+
+    MjRoot.AppendChild(GenerateMjcfSection(
+        doc, components.Where(component => component is MjBaseConstraint), "equality"));
+
+    MjRoot.AppendChild(GenerateMjcfSection(
+        doc, components.Where(component => component is MjActuator), "actuator"));
+
+    MjRoot.AppendChild(GenerateMjcfSection(
+        doc, components.Where(component => component is MjBaseSensor), "sensor"));
+
+    // Generate the Mjcf of the runtime dependencies added to the context.
+    _generationContext.GenerateMjcf(MjRoot);
+    return doc;
+  }
+
+  private XmlElement GenerateMjcfSection(
+      XmlDocument doc, IEnumerable<MjComponent> components, string sectionName) {
+    var section = doc.CreateElement(sectionName);
+    foreach (var component in components) {
+      var componentMjcf = component.GenerateMjcf(_generationContext.GenerateName(component), doc);
+      section.AppendChild(componentMjcf);
+    }
+    return section;
+  }
+
+  private void BuildHierarchicalMjcf(
+      XmlDocument doc, IEnumerable<MjComponent> components, XmlElement worldMjcf) {
+    var associations = new Dictionary<MjComponent, XmlElement>();
+
+    // Build individual Mjcfs.
+    foreach (var component in components) {
+      var componentMjcf = component.GenerateMjcf(
+          _generationContext.GenerateName(component), doc);
+      // We'll use a dictionary to define associations between the components and the corresponding
+      // Mjcf elements.
+      associations.Add(component, componentMjcf);
+    }
+
+    // Connect the Mjcfs into hierarchy.
+    foreach (var component in components) {
+      var componentMjcf = associations[component];
+      var parentComponent = MjHierarchyTool.FindParentComponent(component);
+      if (parentComponent != null) {
+        var parentComponentMjcf = associations[parentComponent];
+        parentComponentMjcf.AppendChild(componentMjcf);
+      } else {
+        worldMjcf.AppendChild(componentMjcf);
+      }
+    }
+  }
+
+  // Saves an XML document to the specified file.
+  private void SaveToFile(XmlDocument document, string filePath) {
+    try {
+      using (var stream = File.Open(filePath, FileMode.Create)) {
+        using (var writer = new XmlTextWriter(stream, new UTF8Encoding(false))) {
+          writer.Formatting = Formatting.Indented;
+          document.WriteContentTo(writer);
+          Debug.Log($"MJCF saved to {filePath}");
+        }
+      }
+    } catch (IOException ex) {
+      Debug.LogWarning("Failed to save Xml to a file: " + ex.ToString(), this);
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjScene.cs.meta b/unity/Runtime/Components/MjScene.cs.meta
new file mode 100644
index 00000000..f6869607
--- /dev/null
+++ b/unity/Runtime/Components/MjScene.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: dc0e4847259184563a80db5e2e581464
+timeCreated: 1532377765
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjShapeComponent.cs b/unity/Runtime/Components/MjShapeComponent.cs
new file mode 100644
index 00000000..2ebf4958
--- /dev/null
+++ b/unity/Runtime/Components/MjShapeComponent.cs
@@ -0,0 +1,92 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// A facade that allows to select a type of Mujoco shape and define that shape's properties.
+//
+// To work around the lack of serialization support for polymorphism, the class aggregates
+// the settings of all available shape types. Coupled with a set of custom property drawers,
+// it will be presented in the Inspector as a single entity, encapsulating the details of
+// data persistance, Mjcf parsing and generation and debug visualization.
+public abstract class MjShapeComponent : MjComponent {
+
+  public enum ShapeTypes {
+    Sphere,
+    Capsule,
+    Ellipsoid,
+    Cylinder,
+    Box,
+    Plane,
+    Mesh
+  }
+
+  public ShapeTypes ShapeType;
+
+  public MjSphereShape Sphere = new MjSphereShape();
+  public MjCapsuleShape Capsule = new MjCapsuleShape();
+  public MjCylinderShape Cylinder = new MjCylinderShape();
+  public MjBoxShape Box = new MjBoxShape();
+  public MjEllipsoidShape Ellipsoid = new MjEllipsoidShape();
+  public MjPlaneShape Plane = new MjPlaneShape();
+  public MjMeshShape Mesh = new MjMeshShape();
+
+  public IMjShape Shape {
+    get {
+      switch (ShapeType) {
+        default:
+        case ShapeTypes.Sphere: return Sphere;
+        case ShapeTypes.Capsule: return Capsule;
+        case ShapeTypes.Cylinder: return Cylinder;
+        case ShapeTypes.Ellipsoid: return Ellipsoid;
+        case ShapeTypes.Box: return Box;
+        case ShapeTypes.Plane: return Plane;
+        case ShapeTypes.Mesh: return Mesh;
+      }
+    }
+  }
+
+  public void ShapeToMjcf(XmlElement mjcf, Transform transform) {
+    mjcf.SetAttribute("type", ShapeType.ToString().ToLower());
+    Shape.ToMjcf(mjcf, transform);
+  }
+
+  public void ShapeFromMjcf(XmlElement mjcf) {
+    ShapeType = mjcf.GetEnumAttribute<ShapeTypes>(
+        "type", ShapeTypes.Sphere, ignoreCase: true);
+    Shape.FromMjcf(mjcf);
+  }
+
+  public Tuple<Vector3[], int[]> BuildMesh() {
+    return Shape.BuildMesh();
+  }
+
+  public Vector4 GetChangeStamp() {
+    var stamp = Shape.GetChangeStamp();
+    stamp.w = (float)ShapeType;
+    return stamp;
+  }
+
+  public void DrawGizmos(Transform transform) {
+    var oldMatrix = Gizmos.matrix;
+    Shape.DebugDraw(transform);
+    Gizmos.matrix = oldMatrix;
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjShapeComponent.cs.meta b/unity/Runtime/Components/MjShapeComponent.cs.meta
new file mode 100644
index 00000000..22386916
--- /dev/null
+++ b/unity/Runtime/Components/MjShapeComponent.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 5c4948e0eae49455caa9c131435c0b5b
+timeCreated: 1547594327
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjSite.cs b/unity/Runtime/Components/MjSite.cs
new file mode 100644
index 00000000..2608bd27
--- /dev/null
+++ b/unity/Runtime/Components/MjSite.cs
@@ -0,0 +1,52 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Defines a reference frame and an anchoring point for other elements of the rig.
+public class MjSite : MjShapeComponent {
+
+  public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_SITE;
+
+  // Parse the component settings from an external Mjcf.
+  protected override void OnParseMjcf(XmlElement mjcf) {
+    ShapeFromMjcf(mjcf);
+    MjEngineTool.ParseTransformMjcf(mjcf, transform);
+  }
+
+  // Generate implementation specific XML element.
+  protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+    var mjcf = (XmlElement)doc.CreateElement("site");
+    ShapeToMjcf(mjcf, transform);
+    MjEngineTool.PositionRotationToMjcf(mjcf, this);
+    return mjcf;
+  }
+
+  // Synchronize the state of the component.
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    transform.position = MjEngineTool.UnityVector3(data->site_xpos, MujocoId);
+    transform.rotation = MjEngineTool.UnityQuaternionFromMatrix(data->site_xmat, MujocoId);
+  }
+
+  public void OnDrawGizmosSelected() {
+    Gizmos.color = Color.magenta;
+    DrawGizmos(transform);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjSite.cs.meta b/unity/Runtime/Components/MjSite.cs.meta
new file mode 100644
index 00000000..d568bf9c
--- /dev/null
+++ b/unity/Runtime/Components/MjSite.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 1f92b229515774d928f13cd3faead49a
+timeCreated: 1547220273
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjSiteQuaternionSensor.cs b/unity/Runtime/Components/MjSiteQuaternionSensor.cs
new file mode 100644
index 00000000..325874df
--- /dev/null
+++ b/unity/Runtime/Components/MjSiteQuaternionSensor.cs
@@ -0,0 +1,49 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+public class MjSiteQuaternionSensor : MjBaseSensor {
+
+  public MjSite Site;
+
+  public Quaternion SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Site == null) {
+      throw new NullReferenceException("Missing a reference to a MjSite.");
+    }
+    var mjcf = doc.CreateElement("framequat");
+    mjcf.SetAttribute("objtype", "site");
+    mjcf.SetAttribute("objname", Site.MujocoName);
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    Site = mjcf.GetObjectReferenceAttribute<MjSite>("objname");
+    if (Site == null) {
+      throw new NullReferenceException("Missing a reference to a MjSite.");
+    }
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    SensorReading = MjEngineTool.UnityQuaternion(data->sensordata, _sensorAddress);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjSiteQuaternionSensor.cs.meta b/unity/Runtime/Components/MjSiteQuaternionSensor.cs.meta
new file mode 100644
index 00000000..a007c962
--- /dev/null
+++ b/unity/Runtime/Components/MjSiteQuaternionSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9184adbba0c7046b49d799f28d26c8a8
+timeCreated: 1548170856
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjSiteScalarSensor.cs b/unity/Runtime/Components/MjSiteScalarSensor.cs
new file mode 100644
index 00000000..1c51615a
--- /dev/null
+++ b/unity/Runtime/Components/MjSiteScalarSensor.cs
@@ -0,0 +1,54 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+public class MjSiteScalarSensor : MjBaseSensor {
+  // NOTE: These names must match sensor names listed on mujoco.org.
+  // Changing them is justified only when Mujoco is upgraded to a new version.
+  public enum AvailableSensors {
+    Touch,
+    RangeFinder,
+  }
+  public AvailableSensors SensorType;
+  public MjSite Site;
+
+  public double SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Site == null) {
+      throw new NullReferenceException("Missing a reference to a MjSite.");
+    }
+    var mjcf = doc.CreateElement(SensorType.ToString().ToLower());
+    mjcf.SetAttribute("site", Site.MujocoName);
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    if (!Enum.TryParse(mjcf.Name, ignoreCase: true, result: out SensorType)) {
+      throw new ArgumentException($"Unknown sensor type {mjcf.Name}.");
+    }
+    Site = mjcf.GetObjectReferenceAttribute<MjSite>("site");
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    SensorReading = data->sensordata[_sensorAddress];
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjSiteScalarSensor.cs.meta b/unity/Runtime/Components/MjSiteScalarSensor.cs.meta
new file mode 100644
index 00000000..f17afb13
--- /dev/null
+++ b/unity/Runtime/Components/MjSiteScalarSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: b9d61f371ce8e4821ac8c64a5bd90232
+timeCreated: 1548167404
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjSiteVectorSensor.cs b/unity/Runtime/Components/MjSiteVectorSensor.cs
new file mode 100644
index 00000000..f63bb528
--- /dev/null
+++ b/unity/Runtime/Components/MjSiteVectorSensor.cs
@@ -0,0 +1,75 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+public class MjSiteVectorSensor : MjBaseSensor {
+  // NOTE: These names must match sensor names listed on mujoco.org.
+  // Changing them is justified only when Mujoco is upgraded to a new version.
+  public enum AvailableSensors {
+    Accelerometer,
+    Velocimeter,
+    Gyro,
+    Force,
+    Torque,
+    Magnetometer,
+    FramePos,
+    FrameXAxis,
+    FrameYAxis,
+    FrameZAxis,
+    FrameLinVel,
+    FrameAngVel,
+    FrameLinAcc,
+    FrameAngAcc,
+  }
+  public AvailableSensors SensorType;
+  public MjSite Site;
+
+  public Vector3 SensorReading { get; private set; }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (Site == null) {
+      throw new NullReferenceException("Missing a reference to a MjSite.");
+    }
+    var tag = SensorType.ToString().ToLower();
+    var mjcf = doc.CreateElement(tag);
+    if (tag.Contains("frame")) {
+      mjcf.SetAttribute("objtype", "site");
+      mjcf.SetAttribute("objname", Site.MujocoName);
+    } else {
+      mjcf.SetAttribute("site", Site.MujocoName);
+    }
+    return mjcf;
+  }
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    if (!Enum.TryParse(mjcf.Name, ignoreCase: true, result: out SensorType)) {
+      throw new ArgumentException($"Unknown sensor type {mjcf.Name}.");
+    }
+    if (mjcf.Name.Contains("frame")) {
+      Site = mjcf.GetObjectReferenceAttribute<MjSite>("objname");
+    } else {
+      Site = mjcf.GetObjectReferenceAttribute<MjSite>("site");
+    }
+  }
+
+  public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+    SensorReading = MjEngineTool.UnityVector3(data->sensordata, _sensorAddress);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjSiteVectorSensor.cs.meta b/unity/Runtime/Components/MjSiteVectorSensor.cs.meta
new file mode 100644
index 00000000..531bc0c6
--- /dev/null
+++ b/unity/Runtime/Components/MjSiteVectorSensor.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 8ed49bd87930f40b9aaaf5b77beead64
+timeCreated: 1548168043
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjSlideJoint.cs b/unity/Runtime/Components/MjSlideJoint.cs
new file mode 100644
index 00000000..e413455a
--- /dev/null
+++ b/unity/Runtime/Components/MjSlideJoint.cs
@@ -0,0 +1,85 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  // The component represents a joint with 1 degree of translational freedom.
+  public class MjSlideJoint : MjBaseJoint {
+    [Tooltip("In meters.")]
+    public float RangeLower;
+    [Tooltip("In meters.")]
+    public float RangeUpper;
+
+    [Tooltip("The current joint angle, in degrees. Read-only at play time.")]
+    public float Configuration;
+
+    [Tooltip("Joint movement, in rad/sec. Read-only at play time.")]
+    public float Velocity;
+
+    [Tooltip("Joint settings.")]
+    public MjJointSettings Settings = MjJointSettings.Default;
+
+    // World space slide axis.
+    public Vector3 SlideAxis => transform.rotation * Vector3.right;
+
+    protected override unsafe void OnBindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {
+      base.OnBindToRuntime(model, data);
+      data->qvel[DofAddress] = Velocity;
+    }
+
+    public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+      var qpos = (float)data->qpos[QposAddress];
+      Configuration = (qpos % (2 * Mathf.PI)) * Mathf.Rad2Deg;
+      Velocity = (float)data->qvel[DofAddress];
+    }
+
+    protected override void OnParseMjcf(XmlElement mjcf) {
+      // Transform.
+      transform.localPosition =
+          MjEngineTool.UnityVector3(mjcf.GetVector3Attribute("pos", defaultValue: Vector3.zero));
+
+      var rotationAxis =
+          MjEngineTool.UnityVector3(mjcf.GetVector3Attribute("axis", defaultValue: Vector3.right));
+      transform.localRotation = Quaternion.FromToRotation(Vector3.right, rotationAxis);
+
+      var rangeValues = mjcf.GetFloatArrayAttribute("range", defaultValue: new float[] { 0, 0 });
+      RangeLower = rangeValues[0];
+      RangeUpper = rangeValues[1];
+
+      Configuration = mjcf.GetFloatAttribute("ref", 0.0f);
+
+      Settings.FromMjcf(mjcf);
+    }
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      var mjcf = (XmlElement)doc.CreateElement("joint");
+      mjcf.SetAttribute("type", "slide");
+
+      MjEngineTool.PositionAxisToMjcf(mjcf, this);
+
+      Settings.ToMjcf(mjcf);
+      if (RangeLower > RangeUpper) {
+        throw new ArgumentException("Lower range value can't be bigger than Higher");
+      }
+      mjcf.SetAttribute("range", $"{RangeLower} {RangeUpper}");
+      mjcf.SetAttribute("ref", $"{Configuration}");
+
+      return mjcf;
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjSlideJoint.cs.meta b/unity/Runtime/Components/MjSlideJoint.cs.meta
new file mode 100644
index 00000000..4a106d24
--- /dev/null
+++ b/unity/Runtime/Components/MjSlideJoint.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0f0920b38d2fe4e21bb645eff3f73be4
+timeCreated: 1537527115
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjSpatialTendon.cs b/unity/Runtime/Components/MjSpatialTendon.cs
new file mode 100644
index 00000000..608f3bec
--- /dev/null
+++ b/unity/Runtime/Components/MjSpatialTendon.cs
@@ -0,0 +1,131 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+[Serializable]
+public class SpatialTendonEntry {
+  [Tooltip("Only one of site/geom/pulley can be specified at each entry.")]
+  public MjSite Site;
+  [Tooltip("Only one of site/geom/pulley can be specified at each entry.")]
+  public MjGeom WrapGeom;
+  [Tooltip("Only used if wrap geom is specified.")]
+  public MjSite WrapSideSite;
+  [Tooltip("Only one of site/geom/pulley can be specified at each entry.")]
+  public float PulleyDivisor;
+}
+
+public class MjSpatialTendon : MjBaseTendon {
+
+  [Tooltip("In meters.")]
+  public float RangeLower;
+  [Tooltip("In meters.")]
+  public float RangeUpper;
+
+  public List<SpatialTendonEntry> ViapointsList = new List<SpatialTendonEntry>() {};
+
+  protected override void FromMjcf(XmlElement mjcf) {
+    foreach (var child in mjcf.Cast<XmlNode>().OfType<XmlElement>()) {
+      var viapoint = new SpatialTendonEntry();
+      viapoint.Site = child.GetObjectReferenceAttribute<MjSite>("site");
+      viapoint.WrapGeom = child.GetObjectReferenceAttribute<MjGeom>("geom");
+      viapoint.WrapSideSite = child.GetObjectReferenceAttribute<MjSite>("sidesite");
+      viapoint.PulleyDivisor = child.GetFloatAttribute("pulley");
+      ViapointsList.Add(viapoint);
+    }
+    var rangeValues = mjcf.GetFloatArrayAttribute("range", defaultValue: new float[] { 0, 0 });
+    RangeLower = rangeValues[0];
+    RangeUpper = rangeValues[1];
+  }
+
+  protected override XmlElement ToMjcf(XmlDocument doc) {
+    if (ViapointsList.Count() < 2) {
+      throw new ArgumentOutOfRangeException($"Spatial tendon {name} needs at least 2 sites.");
+    }
+    if (ViapointsList[0].Site == null) {
+      throw new NullReferenceException(
+      $"The first entry of a spatial tendon {name} must be a site.");
+    }
+    if (ViapointsList[ViapointsList.Count - 1].Site == null) {
+      throw new NullReferenceException(
+      $"The last entry of a spatial tendon {name} must be a site.");
+    }
+    var mjcf = doc.CreateElement("spatial");
+    foreach (SpatialTendonEntry spatialTendonEntry in ViapointsList) {
+      XmlElement elementMjcf;
+      if (spatialTendonEntry.Site) {
+        if (spatialTendonEntry.WrapGeom || spatialTendonEntry.PulleyDivisor != 0) {
+          throw new ArgumentException(
+          $"Only one of site/wrap geom/pulley {name} is allowed at each entry.");
+        }
+        elementMjcf = doc.CreateElement("site");
+        elementMjcf.SetAttribute("site", spatialTendonEntry.Site.MujocoName);
+      } else if (spatialTendonEntry.WrapGeom) {
+        if (spatialTendonEntry.PulleyDivisor != 0) {
+          throw new ArgumentException(
+          $"Only one of site/wrap geom/pulley {name} is allowed at each entry.");
+        }
+        elementMjcf = doc.CreateElement("geom");
+        elementMjcf.SetAttribute("geom", spatialTendonEntry.WrapGeom.MujocoName);
+        if (spatialTendonEntry.WrapSideSite) {
+          elementMjcf.SetAttribute("sidesite", spatialTendonEntry.WrapSideSite.MujocoName);
+        }
+      } else {
+        if (spatialTendonEntry.PulleyDivisor == 0) {
+          throw new ArgumentException(
+          $"Exactly one of site/wrap geom/pulley {name} is required at each entry.");
+        }
+        elementMjcf = doc.CreateElement("pulley");
+        elementMjcf.SetAttribute("divisor", $"{spatialTendonEntry.PulleyDivisor}");
+      }
+      mjcf.AppendChild(elementMjcf);
+    }
+    if (RangeLower > RangeUpper) {
+      throw new ArgumentException("Lower range value can't be bigger than Higher");
+    }
+    mjcf.SetAttribute("range", $"{RangeLower} {RangeUpper}");
+
+    return mjcf;
+  }
+
+  public unsafe void OnDrawGizmos() {
+    if (Application.isPlaying) {
+      var scene = MjScene.Instance;
+      var segmentCount = scene.Model->nwrap - 1;
+      var data = scene.Data;
+      int readHead = 0;
+      for (int i = 0; i < segmentCount; ++i) {
+        // Skip drawing of pulley:
+        if (data->wrap_obj[readHead] == -2 || data->wrap_obj[readHead + 1] == -2) {
+          readHead += 1;
+        } else {
+          Vector3 start = MjEngineTool.UnityVector3(data->wrap_xpos, readHead);
+          Vector3 end = MjEngineTool.UnityVector3(data->wrap_xpos, readHead + 1);
+          Gizmos.DrawLine(start, end);
+          if (data->wrap_obj[readHead + 1] >= 0) { // a wrap geom
+            readHead += 2;
+          } else { // site or pulley
+            readHead += 1;
+          }
+        }
+      }
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjSpatialTendon.cs.meta b/unity/Runtime/Components/MjSpatialTendon.cs.meta
new file mode 100644
index 00000000..652b18f9
--- /dev/null
+++ b/unity/Runtime/Components/MjSpatialTendon.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c057416978f884ffbb63af370eed69dd
+timeCreated: 1551348731
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjSphereShape.cs b/unity/Runtime/Components/MjSphereShape.cs
new file mode 100644
index 00000000..3d736cf3
--- /dev/null
+++ b/unity/Runtime/Components/MjSphereShape.cs
@@ -0,0 +1,55 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+[Serializable]
+public class MjSphereShape : IMjShape {
+  public float Radius = 0.5f;
+  private const float _scaleTolerance = 1e-6f;
+
+  public void ToMjcf(XmlElement mjcf, Transform transform) {
+    if (Math.Abs(transform.lossyScale.x - transform.lossyScale.y) > _scaleTolerance ||
+        Math.Abs(transform.lossyScale.y - transform.lossyScale.z) > _scaleTolerance) {
+      Debug.LogWarning(
+          $"{transform.name}: Sphere shapes work only with uniform scaling. Using the value of X" +
+          " component.\n Consider using Ellipsoid shape if you want to use non-uniform scaling.",
+          transform);
+    }
+    mjcf.SetAttribute("size", $"{Radius * transform.lossyScale.x}");
+  }
+
+  public void FromMjcf(XmlElement mjcf) {
+    var values = mjcf.GetFloatArrayAttribute("size", defaultValue: new float[] { 0.5f });
+    Radius = values[0];
+  }
+
+  public Tuple<Vector3[], int[]> BuildMesh() {
+    return MeshGenerators.BuildSphere(scale: Vector3.one * Radius);
+  }
+
+  public Vector4 GetChangeStamp() {
+    return new Vector4(Radius, 1, 1, 0);
+  }
+
+  public void DebugDraw(Transform transform) {
+    Gizmos.DrawWireSphere(transform.position, Radius * transform.lossyScale.x);
+  }
+}
+}
diff --git a/unity/Runtime/Components/MjSphereShape.cs.meta b/unity/Runtime/Components/MjSphereShape.cs.meta
new file mode 100644
index 00000000..bcac8306
--- /dev/null
+++ b/unity/Runtime/Components/MjSphereShape.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: accf5ed21337c4fe38417b01fe8c5468
+timeCreated: 1547647081
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjTendonConstraint.cs b/unity/Runtime/Components/MjTendonConstraint.cs
new file mode 100644
index 00000000..7fbef8b8
--- /dev/null
+++ b/unity/Runtime/Components/MjTendonConstraint.cs
@@ -0,0 +1,57 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public class MjTendonConstraint : MjBaseConstraint {
+    public MjBaseTendon Tendon1;
+    public MjBaseTendon Tendon2;
+    public float[] PolynomialCoefficients = new float[5] { 0, 1, 0, 0, 0 };
+    protected override string _constraintName => "tendon";
+
+    protected override void FromMjcf(XmlElement mjcf) {
+      Tendon1 = mjcf.GetObjectReferenceAttribute<MjBaseTendon>("tendon1");
+      Tendon2 = mjcf.GetObjectReferenceAttribute<MjBaseTendon>("tendon2");
+      PolynomialCoefficients =
+          mjcf.GetFloatArrayAttribute("polycoef", new Single[] { 0, 1, 0, 0, 0 });
+    }
+
+    // Generate implementation specific XML element.
+    protected override void ToMjcf(XmlElement mjcf) {
+      if (Tendon1 == null) {
+        throw new NullReferenceException(
+            $"At least Tendon1 in constraint {name} must be assigned.");
+      }
+
+      mjcf.SetAttribute("tendon1", Tendon1.MujocoName);
+      if (Tendon2 != null) {
+        mjcf.SetAttribute("tendon2", Tendon2.MujocoName);
+      }
+      mjcf.SetAttribute("polycoef", MjEngineTool.ArrayToMjcf(PolynomialCoefficients));
+    }
+
+    public void OnValidate() {
+      if (Tendon1 != null && Tendon1 == Tendon2) {
+        Debug.LogWarning(
+            "Tendon1 and Tendon2 can't be the same - resetting Tendon2.", this);
+        Tendon2 = null;
+      }
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjTendonConstraint.cs.meta b/unity/Runtime/Components/MjTendonConstraint.cs.meta
new file mode 100644
index 00000000..26825539
--- /dev/null
+++ b/unity/Runtime/Components/MjTendonConstraint.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 81536160634694c9f8b78d0de2fe6fde
+timeCreated: 1552309644
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Components/MjWeld.cs b/unity/Runtime/Components/MjWeld.cs
new file mode 100644
index 00000000..6eeb3479
--- /dev/null
+++ b/unity/Runtime/Components/MjWeld.cs
@@ -0,0 +1,61 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public class MjWeld : MjBaseConstraint {
+    public MjBaseBody Body1;
+    public MjBaseBody Body2;
+    public Transform WeldOffset;
+    protected override string _constraintName => "weld";
+
+    protected override unsafe void OnBindToRuntime(MujocoLib.mjModel_* model, MujocoLib.mjData_* data) {
+      if (WeldOffset) {
+        MjEngineTool.SetMjTransform(model->eq_data, WeldOffset.localPosition,
+                                    WeldOffset.localRotation, MujocoId);
+      }
+    }
+
+    protected override void FromMjcf(XmlElement mjcf) {
+      Body1 = mjcf.GetObjectReferenceAttribute<MjBaseBody>("body1");
+      Body2 = mjcf.GetObjectReferenceAttribute<MjBaseBody>("body2");
+      var relpose = mjcf.GetStringAttribute("relpose");
+      if (relpose != null) {
+        Debug.Log(
+            $"relpose {relpose} in weld {name} ignored. Set WeldOffset in the editor.");
+      }
+    }
+
+    protected override void ToMjcf(XmlElement mjcf) {
+      if (Body1 == null || Body2 == null) {
+        throw new NullReferenceException($"Both bodies in weld {name} must be assigned.");
+      }
+
+      mjcf.SetAttribute("body1", Body1.MujocoName);
+      mjcf.SetAttribute("body2", Body2.MujocoName);
+    }
+
+    public void OnValidate() {
+      if (Body1 != null && Body1 == Body2) {
+        Debug.LogWarning("Body1 and Body2 can't be the same - resetting Body2.", this);
+        Body2 = null;
+      }
+    }
+  }
+}
diff --git a/unity/Runtime/Components/MjWeld.cs.meta b/unity/Runtime/Components/MjWeld.cs.meta
new file mode 100644
index 00000000..acd034e3
--- /dev/null
+++ b/unity/Runtime/Components/MjWeld.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: b6f83e13e2c454767a785a138674c84f
+timeCreated: 1550663136
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Importer.meta b/unity/Runtime/Importer.meta
new file mode 100644
index 00000000..b1eb4efd
--- /dev/null
+++ b/unity/Runtime/Importer.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7d55596646c101db79c3f6777b2f3888
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Importer/MjXmlModifiers.cs b/unity/Runtime/Importer/MjXmlModifiers.cs
new file mode 100644
index 00000000..66460b59
--- /dev/null
+++ b/unity/Runtime/Importer/MjXmlModifiers.cs
@@ -0,0 +1,115 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+  public class MjXmlModifiers {
+    private XmlDocument _root;
+
+    public MjXmlModifiers(XmlDocument root) {
+      _root = root;
+    }
+
+    public void ApplyModifiersToElement(XmlElement element) {
+      // Combine all defaults into one. At this stage, we want to overwrite attributes defined by
+      // the previous defaults.
+      var aggregateDefaults = _root.CreateElement("aggregate");
+      // Root default leaf should be processed only once, and handled first (so it's overriden).
+      var rootDefaultLeaf = _root.SelectSingleNode($"/mujoco/default/{element.Name}") as XmlElement;
+      if (rootDefaultLeaf != null) {
+        CopyAttributes(rootDefaultLeaf, aggregateDefaults);
+      }
+      // Order matters - reverse class list so that most relevant is last.
+      var classes = GetApplicableDefaultClasses(element).Reverse();
+      foreach (var className in classes) {
+        var defaultClassElement =
+            _root.SelectSingleNode($"descendant::default[@class='{className}']") as XmlElement;
+        // Ancestry iterates up in the tree, but we want to apply changes from remote to specific.
+        var ancestors = GetDefaultAncestry(defaultClassElement, element.Name).Reverse();
+        foreach (var defaultAncestor in ancestors) {
+          CopyAttributesOverwriteExisting(defaultAncestor, aggregateDefaults);
+        }
+      }
+      // Add the merged attribiutes to the node, without overwriting the existing values.
+      CopyAttributes(aggregateDefaults, element);
+    }
+
+    private IEnumerable<XmlElement> GetDefaultAncestry(XmlElement classElement, string nodeType) {
+      var defaultElement = classElement;
+      var top = _root.SelectSingleNode("/mujoco/default");
+      while (defaultElement != top) {
+        foreach (var element in defaultElement.ChildNodes) {
+          if (((XmlElement)element).Name == nodeType) {
+            yield return (XmlElement)element;
+          }
+        }
+        defaultElement = defaultElement.ParentNode as XmlElement;
+      }
+    }
+
+    // Return a list of names of all the applicable classes.  Implemented by climbing up the tree,
+    // hence results are in order of relevance, from the most specific to most remotely-inherited.
+    public static IEnumerable<string> GetApplicableDefaultClasses(XmlElement modifiedElement) {
+      var nodeType = modifiedElement.Name;
+
+      // Build the inheritance list for the element that's meant to be modified.
+      // It will consist of all qualifiers supplied by the element itself and its parents
+      // using "class" and "childclass" values.
+      var inheritance = new List<string>();
+      var element = modifiedElement;
+      while (element != null) {
+        var className = element.GetStringAttribute("childclass", string.Empty);
+        if (element == modifiedElement) {
+          // "class" attribute does not partcipate in building of the inheritance tree, and so we're
+          // only considering it if it's defined on the very element we're trying to modify.
+          className = element.GetStringAttribute("class", className);
+        }
+        if (!string.IsNullOrEmpty(className) && !inheritance.Contains(className)) {
+          inheritance.Add(className);
+        }
+        element = element.ParentNode as XmlElement;
+      }
+      return inheritance;
+    }
+
+    private static string GetElementClass(XmlElement element) {
+      var elementClass = element.GetStringAttribute("class", string.Empty);
+      if (string.IsNullOrEmpty(elementClass)) {
+        elementClass = element.GetStringAttribute("childclass", string.Empty);
+      }
+      return elementClass;
+    }
+
+    public static void CopyAttributes(XmlElement from, XmlElement to) {
+      foreach (XmlAttribute attribute in from.Attributes) {
+        if (to.HasAttribute(attribute.Name) == false) {
+          to.SetAttribute(attribute.Name, attribute.Value);
+        }
+      }
+    }
+
+    public static void CopyAttributesOverwriteExisting(XmlElement from, XmlElement to) {
+      foreach (XmlAttribute attribute in from.Attributes) {
+        to.SetAttribute(attribute.Name, attribute.Value);
+      }
+    }
+  }
+}
diff --git a/unity/Runtime/Importer/MjXmlModifiers.cs.meta b/unity/Runtime/Importer/MjXmlModifiers.cs.meta
new file mode 100644
index 00000000..f269fb84
--- /dev/null
+++ b/unity/Runtime/Importer/MjXmlModifiers.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 41357c10b9c0b2fcfaab18600e467579
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Importer/MjcfImporter.cs b/unity/Runtime/Importer/MjcfImporter.cs
new file mode 100644
index 00000000..8af4ea29
--- /dev/null
+++ b/unity/Runtime/Importer/MjcfImporter.cs
@@ -0,0 +1,435 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+// API for importing Mujoco XML files into Unity scenes.
+public class MjcfImporter {
+  // Any materials created at runtime will only be automatically cleaned up if no other objects
+  // reference it AND Unity changes scenes. In long-running worlds with no scene resets, this means
+  // those materials are never cleaned even after their MjBodies are destroyed, so we cache a
+  // single shared material to use for all generated meshes.
+  public static Material DefaultMujocoMaterial {
+    get {
+      if (_DefaultMujocoMaterial == null) {
+        _DefaultMujocoMaterial = new Material(Shader.Find("Standard"));
+      }
+
+      return _DefaultMujocoMaterial;
+    }
+    set {
+      _DefaultMujocoMaterial = value;
+    }
+  }
+
+  // Modifiers that change the settings of parsed nodes. They're limited to the scope of ParseRoot
+  // method.
+  protected MjXmlModifiers _modifiers;
+
+  private static Material _DefaultMujocoMaterial;
+
+  private const string _angleTypeDegree = "degree";
+
+  private int _numGeneratedNames = 0;
+
+  // A list of callbacks on how to handle custom node types.
+  private IDictionary<string, Action<XmlElement, GameObject>> _customNodeHandlers =
+      new Dictionary<string, Action<XmlElement, GameObject>>();
+
+  public void AddNodeHandler(string name, Action<XmlElement, GameObject> handler) {
+    _customNodeHandlers[name] = handler;
+  }
+
+  public MjcfImporter() {}
+
+  public GameObject ImportString(string mjcfString, string name = null) {
+    var mjcfXml = new XmlDocument();
+    mjcfXml.LoadXml(mjcfString);
+    return ImportXml(mjcfXml, name);
+  }
+
+  // A generic version of CreateGameObjectWithUniqueName.
+  public GameObject CreateGameObjectWithUniqueName<T>(
+      GameObject parentObject, XmlElement parentNode) where T : MjComponent {
+    return CreateGameObjectWithUniqueName(parentObject, parentNode, typeof(T));
+  }
+
+  public string GenerateUniqueName(XmlElement parentNode) {
+    var name = string.Empty;
+    if (parentNode.HasAttribute("name")) {
+      name = parentNode.GetAttribute("name");
+    }
+    if (string.IsNullOrEmpty(name)) {
+      name = parentNode.Name + "_" + _numGeneratedNames++;
+    }
+    return name;
+  }
+
+  public unsafe GameObject ImportXml(XmlDocument mjcfXml, string name = null) {
+    // Reset the numbering of anonymous nodes to ensure deterministic naming of loaded scenes.
+    _numGeneratedNames = 0;
+
+    _modifiers = new MjXmlModifiers(mjcfXml);
+
+    ConfigureAngleType(mjcfXml);
+
+    // We're adopting the approach of building the scene hierarchy as we parse the Mjcf.
+    // Should we encounter any error, we'll terminate and clean it immediately.
+    // Having a single root object for that will be very helpful, since we only need to delete that
+    // object.
+    var sceneRoot = new GameObject(name ?? "default");
+
+    // We'll use Exceptions as a way to communicate errors encountered during parsing.
+    try {
+      ParseRoot(sceneRoot, mjcfXml.SelectSingleNode("/mujoco") as XmlElement);
+    } catch (Exception ex) {
+      // We consider any error as critical, and end the import process immediately, cleaning up
+      // what we have already built.
+      Debug.LogException(ex);
+      GameObject.DestroyImmediate(sceneRoot);
+      throw ex;
+    } finally {
+      _modifiers = null;
+    }
+
+    return sceneRoot;
+  }
+
+  // Creates a new GameObject, assigns it a unique name, and attaches a component of the specified
+  // type.  If the requested component type is abstract, the method will attempt to instantiate one
+  // of its implementations that passes the parser test.
+  protected GameObject CreateGameObjectWithUniqueName(
+      GameObject parentObject, XmlElement parentNode, Type componentType) {
+    var name = GenerateUniqueName(parentNode);
+    var gameObject = new GameObject(name);
+    gameObject.transform.parent = parentObject.transform;
+    var component = gameObject.AddComponent(componentType) as MjComponent;
+    component.ParseMjcf(parentNode);
+    return gameObject;
+  }
+
+  protected void ConfigureAngleType(XmlDocument mjcfXml) {
+    var compilerNode = mjcfXml.SelectSingleNode("/mujoco/compiler") as XmlElement;
+    if (compilerNode != null) {
+      // Parse the angle type.
+      var angleSetting = compilerNode.GetStringAttribute("angle", defaultValue: _angleTypeDegree);
+      MjSceneImportSettings.AnglesInDegrees = angleSetting == _angleTypeDegree;
+    }
+  }
+
+  protected virtual void ParseRoot(GameObject parentObject, XmlElement parentNode) {
+
+    // This makes no references nor being referred into, so it can be parsed whenever.
+    var optionNode = parentNode.SelectSingleNode("option") as XmlElement;
+    var sizeNode = parentNode.SelectSingleNode("size") as XmlElement;
+    if (optionNode != null || sizeNode != null) {
+      var globalsObject = CreateGameObjectInParent("Global Settings", parentObject);
+      var settingsComponent = globalsObject.AddComponent<MjGlobalSettings>();
+      settingsComponent.ParseOptionSizeMjcf(optionNode, sizeNode);
+    }
+
+    // This makes references to assets.
+    var worldBodyNode = parentNode.SelectSingleNode("worldbody") as XmlElement;
+    ParseBodyChildren(parentObject, worldBodyNode);
+
+    // This section references bodies, must be parsed after worldbody.
+    var excludeNode = parentNode.SelectSingleNode("contact") as XmlElement;
+    if (excludeNode != null) {
+      var excludesParentObject = CreateGameObjectInParent("excludes", parentObject);
+      foreach (var child in excludeNode.OfType<XmlElement>()) {
+        if (child.Name != "exclude") {
+          Debug.LogWarning(
+              $"Only 'exclude' is supported - {child.Name} isn't supported yet.",
+              parentObject);
+        } else {
+          _modifiers.ApplyModifiersToElement(child);
+          CreateGameObjectWithUniqueName<MjExclude>(excludesParentObject, child);
+        }
+      }
+    }
+
+    // This section references joints/sites/geoms, must be parsed after worldbody.
+    var tendonNode = parentNode.SelectSingleNode("tendon") as XmlElement;
+    if (tendonNode != null) {
+      var tendonsParentObject = CreateGameObjectInParent("tendons", parentObject);
+      foreach (var child in tendonNode.OfType<XmlElement>()) {
+        if (child.Name == "fixed") {
+          CreateGameObjectWithUniqueName<MjFixedTendon>(tendonsParentObject, child);
+        } else if (child.Name == "spatial") {
+          CreateGameObjectWithUniqueName<MjSpatialTendon>(tendonsParentObject, child);
+        } else {
+          Debug.Log($"Tendon type {child.Name} not supported.");
+        }
+      }
+    }
+
+    // This section references worldbody elements + tendons, must be parsed after them.
+    var equalityNode = parentNode.SelectSingleNode("equality") as XmlElement;
+    if (equalityNode != null) {
+      var equalitiesParentObject = CreateGameObjectInParent("equality constraints", parentObject);
+      foreach (var child in equalityNode.OfType<XmlElement>()) {
+        var equalityType = ParseEqualityType(child);
+        _modifiers.ApplyModifiersToElement(child);
+        CreateGameObjectWithUniqueName(equalitiesParentObject, child, equalityType);
+      }
+    }
+
+    // This section references joints and tendons, must be parsed after worldbody and tendon.
+    var actuatorNode = parentNode.SelectSingleNode("actuator") as XmlElement;
+    if (actuatorNode != null) {
+      var actuatorsParentObject = CreateGameObjectInParent("actuators", parentObject);
+      foreach (var child in actuatorNode.OfType<XmlElement>()) {
+        _modifiers.ApplyModifiersToElement(child);
+        CreateGameObjectWithUniqueName<MjActuator>(actuatorsParentObject, child);
+      }
+    }
+
+    // This section references tendons, actuators and worldbody elements, must be parsed last.
+    var sensorNode = parentNode.SelectSingleNode("sensor") as XmlElement;
+    if (sensorNode != null) {
+      var sensorParentObject = CreateGameObjectInParent("sensors", parentObject);
+      foreach (var child in sensorNode.OfType<XmlElement>()) {
+        _modifiers.ApplyModifiersToElement(child);
+        var sensorType = ParseSensorType(child);
+        if (sensorType != null) {
+          CreateGameObjectWithUniqueName(sensorParentObject, child, sensorType);
+        }
+      }
+    }
+  }
+
+  protected virtual void ParseGeom(GameObject parentObject, XmlElement child) {
+    var gameObject = CreateGameObjectWithUniqueName<MjGeom>(parentObject, child);
+    // Add the visuals.
+    gameObject.AddComponent<MjMeshFilter>();
+    var renderer = gameObject.AddComponent<MeshRenderer>();
+    renderer.sharedMaterial = DefaultMujocoMaterial;
+  }
+
+  private GameObject CreateGameObjectInParent(string name, GameObject parentObject) {
+    var createdObject = new GameObject(name);
+    createdObject.transform.parent = parentObject.transform;
+    return createdObject;
+  }
+
+  private void ParseBodyChildren(GameObject parentObject, XmlElement parentNode) {
+    foreach (var child in parentNode.Cast<XmlNode>().OfType<XmlElement>()) {
+      _modifiers.ApplyModifiersToElement(child);
+
+      if (_customNodeHandlers.TryGetValue(child.Name, out var handler)) {
+        handler?.Invoke(child, parentObject);
+      } else {
+        ParseBodyChild(child, parentObject);
+      }
+    }
+  }
+
+  // Called by ParseBodyChildren for each XML node, overridable by inheriting claases.
+  private void ParseBodyChild(XmlElement child, GameObject parentObject) {
+    switch (child.Name) {
+      case "geom": {
+        // this one's different because it's overwritten in MjImporterWithAssets.
+        ParseGeom(parentObject, child);
+        break;
+      }
+      case "inertial": {
+        CreateGameObjectWithUniqueName<MjInertial>(parentObject, child);
+        break;
+      }
+      case "body": {
+        var childObject = CreateGameObjectWithUniqueName<MjBody>(parentObject, child);
+        ParseBodyChildren(childObject, child);
+        break;
+      }
+      case "joint": {
+        var jointType = ParseJointType(child);
+        CreateGameObjectWithUniqueName(parentObject, child, jointType);
+        break;
+      }
+      case "freejoint": {
+        CreateGameObjectWithUniqueName<MjFreeJoint>(parentObject, child);
+        break;
+      }
+      case "site": {
+        CreateGameObjectWithUniqueName<MjSite>(parentObject, child);
+        break;
+      }
+      case "camera": {
+        CreateGameObjectWithCamera(parentObject, child);
+        break;
+      }
+      default: {
+        Debug.Log($"The importer does not yet support tags <{child.Name}>.");
+        break;
+      }
+    }
+  }
+
+  private static Type ParseEqualityType(XmlElement node) {
+    Type equalityType = null;
+    switch (node.Name) {
+      case "connect":
+        equalityType = typeof(MjConnect);
+        break;
+      case "weld":
+        equalityType = typeof(MjWeld);
+        break;
+      case "joint":
+        equalityType = typeof(MjJointConstraint);
+        break;
+      case "tendon":
+        equalityType = typeof(MjTendonConstraint);
+        break;
+      case "distance":
+        equalityType = typeof(MjDistance);
+        break;
+      default:
+        Debug.Log($"The importer does not yet support equality <{node.Name}>.");
+        break;
+    }
+    return equalityType;
+  }
+
+  private static Type ParseSensorType(XmlElement node) {
+    Type sensorType = null;
+    switch (node.Name) {
+      case "actuatorpos":
+      case "actuatorvel":
+      case "actuatorfrc":
+        sensorType = typeof(MjActuatorScalarSensor);
+        break;
+      case "subtreecom":
+      case "subtreelinvel":
+      case "subtreeangmom":
+        sensorType = typeof(MjBodyVectorSensor);
+        break;
+      case "jointpos":
+      case "jointvel":
+      case "jointlimitpos":
+      case "jointlimitvel":
+      case "jointlimitfrc":
+        sensorType = typeof(MjJointScalarSensor);
+        break;
+      case "touch":
+      case "rangefinder":
+        sensorType = typeof(MjSiteScalarSensor);
+        break;
+      case "accelerometer":
+      case "velocimeter":
+      case "force":
+      case "torque":
+      case "gyro":
+      case "magnetometer":
+        sensorType = typeof(MjSiteVectorSensor);
+        break;
+      case "framequat":
+        switch (node.GetAttribute("objtype")) {
+          case "body":
+          case "xbody":
+            sensorType = typeof(MjBodyQuaternionSensor);
+            break;
+          case "geom":
+            sensorType = typeof(MjGeomQuaternionSensor);
+            break;
+          case "site":
+            sensorType = typeof(MjSiteQuaternionSensor);
+            break;
+          default:
+            Debug.Log($"camera sensors unsupported <{node.Name}>.");
+            break;
+        }
+        break;
+      case "framepos":
+      case "framexaxis":
+      case "frameyaxis":
+      case "framezaxis":
+      case "framelinvel":
+      case "frameangvel":
+      case "framelinacc":
+      case "frameangacc":
+        switch (node.GetAttribute("objtype")) {
+          case "body":
+          case "xbody":
+            sensorType = typeof(MjBodyVectorSensor);
+            break;
+          case "geom":
+            sensorType = typeof(MjGeomVectorSensor);
+            break;
+          case "site":
+            sensorType = typeof(MjSiteVectorSensor);
+            break;
+          default:
+            Debug.Log($"camera sensors unsupported <{node.Name}>.");
+            break;
+        }
+        break;
+      default:
+        Debug.Log($"The importer does not yet support sensor <{node.Name}>.");
+        break;
+    }
+    return sensorType;
+  }
+
+  private Type ParseJointType(XmlElement parentNode) {
+    Type jointType = null;
+    switch (parentNode.GetStringAttribute("type", defaultValue: string.Empty)) {
+      case "hinge":
+        jointType = typeof(MjHingeJoint);
+        break;
+      case "ball":
+        jointType = typeof(MjBallJoint);
+        break;
+      case "slide":
+        jointType = typeof(MjSlideJoint);
+        break;
+      case "free":
+        jointType = typeof(MjFreeJoint);
+        break;
+      default:
+        // According to http://mujoco.org/book/XMLreference.html#joint, the default type for a joint
+        // is Hinge.
+        jointType = typeof(MjHingeJoint);
+        break;
+    }
+    return jointType;
+  }
+
+  private GameObject CreateGameObjectWithCamera(
+      GameObject parentObject, XmlElement parentNode) {
+    var name = GenerateUniqueName(parentNode);
+    var gameObject = new GameObject(name);
+    gameObject.transform.parent = parentObject.transform;
+    MjEngineTool.ParseTransformMjcf(parentNode, gameObject.transform);
+    if (parentNode.GetStringAttribute("mode") == "targetbody") {
+      // Look at the parent body:
+      gameObject.transform.localRotation = Quaternion.LookRotation(
+          gameObject.transform.InverseTransformPoint(parentObject.transform.position));
+    } else {
+      // MuJoCo's camera convention is to look down the negative z, which post-swizzle became
+      // negative y, while Unity looks down positive z:
+      gameObject.transform.localRotation *=
+        Quaternion.FromToRotation(Vector3.forward, -Vector3.up);
+    }
+    var camera = gameObject.AddComponent<Camera>();
+    camera.fieldOfView = parentNode.GetFloatAttribute("fovy", defaultValue: 45.0f);
+    camera.nearClipPlane = 0.01f;  // MuJoCo default, TODO(etom): get from visual/map/znear
+    return gameObject;
+  }
+}
+}
diff --git a/unity/Runtime/Importer/MjcfImporter.cs.meta b/unity/Runtime/Importer/MjcfImporter.cs.meta
new file mode 100644
index 00000000..be11814b
--- /dev/null
+++ b/unity/Runtime/Importer/MjcfImporter.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f80b94c6ee938d716af9c3bc5d83b8f2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Mujoco.asmdef b/unity/Runtime/Mujoco.asmdef
new file mode 100644
index 00000000..e2ec1621
--- /dev/null
+++ b/unity/Runtime/Mujoco.asmdef
@@ -0,0 +1,14 @@
+{
+    "name": "Mujoco",
+    "rootNamespace": "",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/unity/Runtime/Mujoco.asmdef.meta b/unity/Runtime/Mujoco.asmdef.meta
new file mode 100644
index 00000000..58b5265d
--- /dev/null
+++ b/unity/Runtime/Mujoco.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 62e270fc6ccbe61c59f510a8e31d067c
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Resources.meta b/unity/Runtime/Resources.meta
new file mode 100644
index 00000000..bf6dced7
--- /dev/null
+++ b/unity/Runtime/Resources.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d9534744b42fab97fa6fb3775f4aab0e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Resources/mujoco_semitransparent_template.mat b/unity/Runtime/Resources/mujoco_semitransparent_template.mat
new file mode 100644
index 00000000..cc5cb0de
--- /dev/null
+++ b/unity/Runtime/Resources/mujoco_semitransparent_template.mat
@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: mujoco_semitransparent_template
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
diff --git a/unity/Runtime/Resources/mujoco_semitransparent_template.mat.meta b/unity/Runtime/Resources/mujoco_semitransparent_template.mat.meta
new file mode 100644
index 00000000..16ec73d3
--- /dev/null
+++ b/unity/Runtime/Resources/mujoco_semitransparent_template.mat.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4daefe8934610e978b13f883bfb904cf
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Tools.meta b/unity/Runtime/Tools.meta
new file mode 100644
index 00000000..e4a89eb0
--- /dev/null
+++ b/unity/Runtime/Tools.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2adb78503ff310ba2b825230f69bd863
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Tools/AbsoluteValueAttribute.cs b/unity/Runtime/Tools/AbsoluteValueAttribute.cs
new file mode 100644
index 00000000..7e1392c6
--- /dev/null
+++ b/unity/Runtime/Tools/AbsoluteValueAttribute.cs
@@ -0,0 +1,24 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Use to annotate a float field that should only assume absolute values.
+[AttributeUsage(AttributeTargets.Field)]
+public class AbsoluteValueAttribute : PropertyAttribute {
+}
+}
diff --git a/unity/Runtime/Tools/AbsoluteValueAttribute.cs.meta b/unity/Runtime/Tools/AbsoluteValueAttribute.cs.meta
new file mode 100644
index 00000000..dd9a51bb
--- /dev/null
+++ b/unity/Runtime/Tools/AbsoluteValueAttribute.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: deb86daf07f8f4e4a97fabbb0f9f6c2e
+timeCreated: 1538126279
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Tools/MjEngineTool.cs b/unity/Runtime/Tools/MjEngineTool.cs
new file mode 100644
index 00000000..e27dcd08
--- /dev/null
+++ b/unity/Runtime/Tools/MjEngineTool.cs
@@ -0,0 +1,361 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Mujoco engine helper methods.
+public static class MjEngineTool {
+  private const int _elementsPerPosition = 3;
+  private const int _elementsPerRotation = 4;
+  private const int _elementsPerTransform = 7;
+  private static double[] _mjQuat = new double[4];
+  private static double[] _mjMat = new double[9];
+  private const int _MjSuccess = 1;
+
+  public static string Sanitize(string name) {
+    return name.Replace('/', '_');
+  }
+
+  // Loads a model from the specified file.
+  // `filename` should contain an absolute path to the file.
+  public static unsafe MujocoLib.mjModel_* LoadModelFromFile(string fileName) {
+    var errorBuf = new StringBuilder(1024);
+    MujocoLib.mjModel_* model = MujocoLib.mj_loadXML(fileName, null, errorBuf, 1024);
+    if (model == null || errorBuf.Length > 0) {
+      throw new IOException(string.Format("Error loading the model: {0}", errorBuf));
+    }
+    return model;
+  }
+
+  // Saves a model to the specified file.
+  // `filename` should contain an absolute path to the file.
+  public static unsafe void SaveModelToFile(string fileName, MujocoLib.mjModel_* model) {
+    var errorBuf = new StringBuilder(1024);
+    MujocoLib.mj_saveLastXML(fileName, model, errorBuf, 1024);
+    if (errorBuf.Length > 0) {
+      throw new IOException(string.Format("Error saving the model: {0}", errorBuf));
+    }
+  }
+
+  // Loads a model from a string.
+  // It allows to perform diskless instantiation of Mujoco models.
+  public static unsafe MujocoLib.mjModel_* LoadModelFromString(string contents) {
+    using (var vfs = new MjVfs()) {
+      var filename = "filename";
+      vfs.AddFile(filename, contents);
+      return vfs.LoadXML(filename);
+    }
+  }
+
+  // Stores a unity vector in a Mujoco target buffer.
+  // The vector coordinates will be stored at the 'entryIndex * 3' of the 'mjTarget' array.
+  public static unsafe void SetMjVector3(double* mjTarget, Vector3 unityVec, int entryIndex) {
+    var startOffset = entryIndex * _elementsPerPosition;
+    var mjVec = MjVector3(unityVec);
+    mjTarget[startOffset] = mjVec[0];
+    mjTarget[startOffset + 1] = mjVec[1];
+    mjTarget[startOffset + 2] = mjVec[2];
+  }
+
+  // Stores a unity quaternion in a Mujoco target buffer.
+  // The vector coordinates will be stored at the 'entryIndex * 4' of the 'mjTarget' array.
+  public static unsafe void SetMjQuaternion(
+    double* mjTarget, Quaternion unityQuat, int entryIndex) {
+    var startOffset = entryIndex * _elementsPerRotation;
+    var mjQuat = MjQuaternion(unityQuat);
+    mjTarget[startOffset] = mjQuat.w;
+    mjTarget[startOffset + 1] = mjQuat.x;
+    mjTarget[startOffset + 2] = mjQuat.y;
+    mjTarget[startOffset + 3] = mjQuat.z;
+  }
+
+  // Stores a unity transform (position+rotation) in a Mujoco target buffer.
+  // The vector coordinates will be stored at the 'entryIndex * 7' of the 'mjTarget' array.
+  public static unsafe void SetMjTransform(
+    double* mjTarget, Vector3 unityVec, Quaternion unityQuat, int entryIndex) {
+    var startOffset = entryIndex * _elementsPerTransform;
+    var mjVec = MjVector3(unityVec);
+    var mjQuat = MjQuaternion(unityQuat);
+    mjTarget[startOffset] = mjVec[0];
+    mjTarget[startOffset + 1] = mjVec[1];
+    mjTarget[startOffset + 2] = mjVec[2];
+    mjTarget[startOffset + 3] = mjQuat.w;
+    mjTarget[startOffset + 4] = mjQuat.x;
+    mjTarget[startOffset + 5] = mjQuat.y;
+    mjTarget[startOffset + 6] = mjQuat.z;
+  }
+
+  // Converts a Unity Vector3 to a Mujoco vector.
+  public static Vector3 MjVector3(Vector3 unityVec) {
+    return new Vector3(unityVec.x, unityVec.z, unityVec.y);
+  }
+
+  // Converts a Mujoco vector to a Unity vector.
+  public static unsafe Vector3 UnityVector3(double* coords, int entryIndex) {
+    var startOffset = entryIndex * _elementsPerPosition;
+    return new Vector3(
+        (float)coords[startOffset], (float)coords[startOffset + 2], (float)coords[startOffset + 1]);
+  }
+
+  // Converts a Mujoco vector to a Unity vector.
+  // The vector coordinates are expected to be stored at the 'entryIndex * 3' of the 'coords'
+  // array.
+  public static unsafe Vector3 UnityVector3(float[] coords, int entryIndex) {
+    var startOffset = entryIndex * _elementsPerPosition;
+    return new Vector3(coords[startOffset], coords[startOffset + 2], coords[startOffset + 1]);
+  }
+
+  // Converts a Mujoco vector to a Unity vector.
+  public static Vector3 UnityVector3(Vector3 mjVector) {
+    return new Vector3(mjVector.x, mjVector.z, mjVector.y);
+  }
+
+  // Converts a Unity Quaternion to a Mujoco Quaternion
+  public static Quaternion MjQuaternion(Quaternion unityQuat) {
+    return new Quaternion(w:-unityQuat.w, x:unityQuat.x, y:unityQuat.z, z:unityQuat.y);
+  }
+
+  // Converts a Mujoco quaternion to a Unity quaternion.
+  // The quaternions is read starting at 'entryIndex * 4' of the 'coords' array.
+  public static Quaternion UnityQuaternion(double[] coords, int entryIndex) {
+    var startOffset = entryIndex * _elementsPerRotation;
+    return new Quaternion(
+        x:(float)coords[startOffset + 1], y:(float)coords[startOffset + 3],
+        z:(float)coords[startOffset + 2], w:(float)-coords[startOffset]);
+  }
+
+  // Converts a Mujoco quaternion to a Unity quaternion.
+  // The quaternion is read starting at 'entryIndex * 4' of the 'coords' array.
+  public static unsafe Quaternion UnityQuaternion(double* coords, int entryIndex) {
+    var startOffset = entryIndex * _elementsPerRotation;
+    return new Quaternion(
+        x:(float)coords[startOffset + 1], y:(float)coords[startOffset + 3],
+        z:(float)coords[startOffset + 2], w:(float)-coords[startOffset]);
+  }
+
+  // Converts a Mujoco quaternion to a Unity quaternion.
+  public static Quaternion UnityQuaternion(Quaternion mjQuat) {
+    // This is simply the inverse permutation of the one in MjQuaternion
+    return new Quaternion(x:mjQuat.x, y:mjQuat.z, z:mjQuat.y, w:-mjQuat.w);
+  }
+
+  // Converts a Mujoco matrix to a Unity quaternion.
+  // The matrix coordinates are at the 'entryIndex * 9' of the 'coords' array.
+  public static unsafe Quaternion UnityQuaternionFromMatrix(double* coords, int entryIndex) {
+    var startOffset = entryIndex * _mjMat.Length;
+    for (var j = 0; j < _mjMat.Length; ++j) {
+      _mjMat[j] = coords[startOffset + j];
+    }
+    fixed (double* a = _mjQuat)
+    fixed (double* b = _mjMat) {
+      MujocoLib.mju_mat2Quat(a, b);
+    }
+    return UnityQuaternion(_mjQuat, 0);
+  }
+
+  // Converts a Unity extents Vector3 to a Mujoco extents vector.
+  // Use to convert size vectors that should contain only absolute values.
+  public static Vector3 MjExtents(Vector3 unityExtents) {
+    return new Vector3(unityExtents.x, unityExtents.z, unityExtents.y);
+  }
+
+  // Converts a Mujoco extents vector to a Unity extents Vector3.
+  // Use to convert size vectors that should contain only absolute values.
+  public static Vector3 UnityExtents(Vector3 mjExtents) {
+    return new Vector3(mjExtents.x, mjExtents.z, mjExtents.y);
+  }
+
+  // Converts a vector containing Mujoco Euler angles to a Unity representation.
+  public static Vector3 UnityEuler(Vector3 mjEuler) {
+    return new Vector3(mjEuler.x, mjEuler.z, -mjEuler.y);
+  }
+
+  public static string Vector3ToMjcf(Vector3 vec) {
+    return $"{vec.x} {vec.y} {vec.z}";
+  }
+
+  public static string QuaternionToMjcf(Quaternion quat) {
+    return $"{quat.w} {quat.x} {quat.y} {quat.z}";
+  }
+
+  // We can't use transform.localPosition because we allow arbitrary deep gameObject hierarchies
+  // between MuJoCo parent and child entities.  Therefore, the method takes into account extra
+  // transforms that may be present in the chain separating the component from its parent body.
+  public static MjTransformation LocalTransformInParentBody(MjComponent component) {
+    var MjParent = MjHierarchyTool.FindParentComponent<MjBaseBody>(component);
+    var parentGlobalPosition = Vector3.zero;
+    var parentGlobalRotation = Quaternion.identity;
+    if (MjParent != null) {
+      parentGlobalPosition = MjParent.transform.position;
+      parentGlobalRotation = MjParent.transform.rotation;
+    }
+
+    var invParentGlobalRotation = Quaternion.Inverse(parentGlobalRotation);
+
+    var localPosition =
+        invParentGlobalRotation * (component.transform.position - parentGlobalPosition);
+    var localRotation = invParentGlobalRotation * component.transform.rotation;
+    return new MjTransformation(localPosition, localRotation);
+  }
+
+  // Identity quaternion in MujocoLib.
+  public static readonly Quaternion MjQuaternionIdentity = new Quaternion(w:-1, x:0, y:0, z:0);
+
+  // Mujoco's Z-axis corresponds to Unity's up (Y) axis.
+  public static readonly Vector3 MjVector3Up = new Vector3(0, 0, 1);
+
+  // Sorts the components of a Vector2. Doesn't modify the original vector.
+  public static Vector2 GetSorted(Vector2 vec) {
+    return new Vector2(Math.Min(vec.x, vec.y), Math.Max(vec.x, vec.y));
+  }
+
+  // Converts an array of floats to an Mjcf.
+  public static string ArrayToMjcf(float[] array) {
+    return String.Join(" ", array);
+  }
+
+  // Converts a list of floats to an Mjcf.
+  public static string ListToMjcf(List<float> list) {
+    return String.Join(" ", list);
+  }
+
+  // Generates an Mjcf of the specified component's transform.
+  //
+  // It will use the component's position (Vector3) and rotation (Quaternion), relative to its
+  // MjComponent parent, and save them in "pos" and "quat" attributes.
+  //
+  // The method takes into account extra transforms that may be present in the chain separating
+  // the component from its MjComponent parent.
+  public static void PositionRotationToMjcf(XmlElement mjcf, MjComponent component) {
+    var localTransform = LocalTransformInParentBody(component);
+    mjcf.SetAttribute(
+        "pos",
+        MjEngineTool.Vector3ToMjcf(MjEngineTool.MjVector3(localTransform.Translation)));
+    mjcf.SetAttribute(
+        "quat",
+        MjEngineTool.QuaternionToMjcf(MjEngineTool.MjQuaternion(localTransform.Rotation)));
+  }
+
+  // Generates an Mjcf of the specified component's transform.
+  //
+  // It will use the component's position (Vector3) and forward direction (Vector3), relative to
+  // its MjComponent parent, and save them in "pos" and "axis" attributes. Designed to work
+  // with Joints, it will set the "ref" attribute to 0, indicating that the joint is in its
+  // reference pose frame.
+  //
+  // The method takes into account extra transforms that may be present in the chain separating
+  // the component from its MjComponent parent.
+  public static void PositionAxisToMjcf(XmlElement mjcf, MjComponent component) {
+    var localTransform = LocalTransformInParentBody(component);
+    var axis = (localTransform.Rotation * Vector3.right).normalized;
+
+    mjcf.SetAttribute(
+        "pos",
+        MjEngineTool.Vector3ToMjcf(MjEngineTool.MjVector3(localTransform.Translation)));
+    mjcf.SetAttribute("axis", MjEngineTool.Vector3ToMjcf(MjEngineTool.MjVector3(axis)));
+    mjcf.SetAttribute("ref", "0");
+  }
+
+  public static void PositionToMjcf(XmlElement mjcf, MjComponent component) {
+    var localTransform = LocalTransformInParentBody(component);
+    mjcf.SetAttribute(
+        "pos",
+        MjEngineTool.Vector3ToMjcf(MjEngineTool.MjVector3(localTransform.Translation)));
+  }
+
+  private const int _fromOffset = 0;
+  private const int _toOffset = 1;
+  private const float _fromToValidityTolerance = 1e-3f;
+
+  public static bool ParseFromToMjcf(XmlElement mjcf, out Vector3 fromPoint, out Vector3 toPoint) {
+    var fromto = mjcf.GetFloatArrayAttribute("fromto", defaultValue: null);
+    if (fromto != null) {
+      fromPoint = MjEngineTool.UnityVector3(fromto, _fromOffset);
+      toPoint = MjEngineTool.UnityVector3(fromto, _toOffset);
+      var nodeName = mjcf.GetStringAttribute("name", mjcf.Name);
+      if ((toPoint - fromPoint).magnitude < _fromToValidityTolerance) {
+        throw new ArgumentException(
+            $"{nodeName}: 'fromto' produces a vector that's too short. {fromto} has magnitude " +
+            "{fromto.magnitude} lower than the tolerance {_fromToValidityTolerance}");
+      }
+      return true;
+    } else {
+      fromPoint = Vector3.zero;
+      toPoint = Vector3.zero;
+      return false;
+    }
+  }
+
+  // Parses the transform-shape specifications, shared by the Geom and Site Mjcfs.
+  public static void ParseTransformMjcf(XmlElement mjcf, Transform transform) {
+    Vector3 fromPoint, toPoint;
+    if (ParseFromToMjcf(mjcf, out fromPoint, out toPoint)) {
+      transform.localPosition = Vector3.Lerp(toPoint, fromPoint, 0.5f);
+      transform.localRotation = Quaternion.FromToRotation(
+          Vector3.up, (toPoint - fromPoint).normalized);
+    } else {
+      // Parse the regular transform.
+      transform.localPosition = MjEngineTool.UnityVector3(
+          mjcf.GetVector3Attribute("pos", defaultValue: Vector3.zero));
+      transform.localRotation = Quaternion.identity;
+
+      if (mjcf.HasAttribute("quat")) {
+        transform.localRotation = MjEngineTool.UnityQuaternion(
+            mjcf.GetQuaternionAttribute("quat",
+                                        defaultValue: MjEngineTool.MjQuaternionIdentity));
+      } else if (mjcf.HasAttribute("zaxis")) {
+        var upAxis = MjEngineTool.UnityVector3(
+            mjcf.GetVector3Attribute("zaxis", defaultValue: MjEngineTool.MjVector3Up));
+        transform.localRotation = Quaternion.FromToRotation(
+            Vector3.up, upAxis);
+      } else if (mjcf.HasAttribute("xyaxes")) {
+        var xyaxes = mjcf.GetFloatArrayAttribute(
+            "xyaxes", defaultValue: new float[] { 1, 0, 0, 0, 1, 0 });
+        var xAxis = MjEngineTool.UnityVector3(xyaxes, 0);
+        var yAxis = MjEngineTool.UnityVector3(xyaxes, 1);
+        var zAxis = Vector3.Cross(xAxis, yAxis);
+        transform.localRotation = Quaternion.LookRotation(zAxis, yAxis);
+      } else if (mjcf.HasAttribute("axisangle")) {
+        var axisAngle = mjcf.GetFloatArrayAttribute(
+            "axisangle", defaultValue: new float[] { 0, 0, 1, 0 });
+        var axis = MjEngineTool.UnityVector3(axisAngle, 0);
+        var angle = axisAngle[3];
+        if (MjSceneImportSettings.AnglesInDegrees == false) {
+          angle *= Mathf.Rad2Deg;
+        }
+        transform.localRotation = Quaternion.AngleAxis(angle, axis);
+      } else if (mjcf.HasAttribute("euler")) {
+        var euler = MjEngineTool.UnityEuler(
+            mjcf.GetVector3Attribute("euler", defaultValue: Vector3.zero));
+        if (MjSceneImportSettings.AnglesInDegrees == false) {
+          euler = euler * Mathf.Rad2Deg;
+        }
+        transform.localRotation = Quaternion.Euler(euler);
+      }
+    }
+  }
+}
+
+public static class MjSceneImportSettings {
+  public static bool AnglesInDegrees = true;
+}
+}
diff --git a/unity/Runtime/Tools/MjEngineTool.cs.meta b/unity/Runtime/Tools/MjEngineTool.cs.meta
new file mode 100644
index 00000000..c236f7e5
--- /dev/null
+++ b/unity/Runtime/Tools/MjEngineTool.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 957bf8e1dc4af40c2a42dd1a33fe10d2
+timeCreated: 1536920023
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Tools/MjHierarchyTool.cs b/unity/Runtime/Tools/MjHierarchyTool.cs
new file mode 100644
index 00000000..8be41966
--- /dev/null
+++ b/unity/Runtime/Tools/MjHierarchyTool.cs
@@ -0,0 +1,87 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Mujoco {
+
+// A set of helper methods for working with hierarchies of components.
+public static class MjHierarchyTool {
+
+  public static IEnumerable<MjComponent> LinearizeHierarchyBFS(Transform start) {
+    var open = new Queue<Transform>();
+    open.Enqueue(start);
+    while (open.Count > 0) {
+      var transform = open.Dequeue();
+
+      var components = transform.GetComponents<MjComponent>();
+      foreach (var component in components) {
+        if (component.isActiveAndEnabled) {
+          yield return component;
+        }
+      }
+
+      foreach (Transform child in transform) {
+        open.Enqueue(child);
+      }
+    }
+  }
+
+  // Recurses up the tree (excluding self) and returns the first instance of a MjComponent.
+  public static MjComponent FindParentComponent(MonoBehaviour start) {
+    return FindParentComponent<MjComponent>(start);
+  }
+
+  // This is not equivalent to Unity's GetComponentInParent as it excludes self from the search.
+  public static T FindParentComponent<T>(MonoBehaviour start) where T : MonoBehaviour {
+    if (start.transform.parent == null) {
+      return null;
+    }
+    var loopTransform = start.transform.parent;
+    T result = loopTransform.GetComponent<T>();
+    while (result == null && loopTransform.parent != null) {
+      loopTransform = loopTransform.parent;
+      result = loopTransform.GetComponent<T>();
+    }
+    return result;
+  }
+
+  public static List<T> GetComponentsInImmediateChildren<T>(Transform parent)
+      where T : MonoBehaviour {
+    var components = new List<T>();
+    foreach (Transform child in parent) {
+      components.AddRange(child.gameObject.GetComponents<T>());
+    }
+    return components;
+  }
+
+  // Finds a single component that matches both the type and the name criteria.
+  public static T FindComponentOfTypeAndName<T>(string name) where T : MjComponent {
+    var components = UnityEngine.Object.FindObjectsOfType<T>().Where(
+        component => component.gameObject.name == name);
+    var numComponents = components.Count();
+    if (components == null || numComponents == 0) {
+      throw new ArgumentException($"No components named '{name}' were found.");
+    }
+    if (numComponents > 1) {
+      throw new ArgumentException($"More than one component named '{name}' was found.");
+    }
+    return components.FirstOrDefault() as T;
+  }
+}
+}
diff --git a/unity/Runtime/Tools/MjHierarchyTool.cs.meta b/unity/Runtime/Tools/MjHierarchyTool.cs.meta
new file mode 100644
index 00000000..c39e15d9
--- /dev/null
+++ b/unity/Runtime/Tools/MjHierarchyTool.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: e246736c791384d918a7781a04225eee
+timeCreated: 1537463659
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Tools/MjTransformation.cs b/unity/Runtime/Tools/MjTransformation.cs
new file mode 100644
index 00000000..e1163383
--- /dev/null
+++ b/unity/Runtime/Tools/MjTransformation.cs
@@ -0,0 +1,84 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using UnityEngine;
+
+namespace Mujoco {
+
+// Utility class that represents a translation and rotation.
+// Used for converting between MuJoCo and Unity spaces.
+public struct MjTransformation {
+  public Vector3 Translation;
+  public Quaternion Rotation;
+
+  public MjTransformation(Vector3 translation, Quaternion rotation) {
+    Translation = translation;
+    Rotation = rotation;
+  }
+
+  public void Set(Vector3 translation, Quaternion rotation) {
+    Translation = translation;
+    Rotation = rotation;
+  }
+
+  // Initializes MjTransformation from the specified Transform's local coordinates.
+  public static MjTransformation LoadGlobal(Transform transform) {
+    if (transform != null) {
+      return new MjTransformation(transform.position, transform.rotation);
+    } else {
+      return new MjTransformation(Vector3.zero, Quaternion.identity);
+    }
+  }
+
+  // Initializes MjTransformation from the specified Transform's global coordinates.
+  public static MjTransformation LoadLocal(Transform transform) {
+    if (transform != null) {
+      return new MjTransformation(transform.localPosition, transform.localRotation);
+    } else {
+      return new MjTransformation(Vector3.zero, Quaternion.identity);
+    }
+  }
+
+  // Stores the transform coordinates in the specified Transform's global coordinates.
+  public void StoreGlobal(Transform transform) {
+    transform.position = Translation;
+    transform.rotation = Rotation;
+  }
+
+  // Stores the transform coordinates in the specified Transform's local coordinates.
+  public void StoreLocal(Transform transform) {
+    transform.localPosition = Translation;
+    transform.localRotation = Rotation;
+  }
+
+  // Concatenates two transforms.
+  // Equivalent of a matrix multiplication. This operation is not transitive.
+  public static MjTransformation operator *(
+      MjTransformation lhs, MjTransformation rhs) {
+    return new MjTransformation(
+        lhs.Translation + lhs.Rotation * rhs.Translation, lhs.Rotation * rhs.Rotation);
+  }
+
+  // Returns an inverse of this transform.
+  public MjTransformation Inverse() {
+    var inverseRotation = Quaternion.Inverse(Rotation);
+    return new MjTransformation(inverseRotation * Translation * -1.0f, inverseRotation);
+  }
+
+  public override string ToString() {
+    return $"[{Translation}, {Rotation}]";
+  }
+}
+}
diff --git a/unity/Runtime/Tools/MjTransformation.cs.meta b/unity/Runtime/Tools/MjTransformation.cs.meta
new file mode 100644
index 00000000..04ed6ab9
--- /dev/null
+++ b/unity/Runtime/Tools/MjTransformation.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 69065be4c455640e8ab0a9d346646be5
+timeCreated: 1551107971
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Tools/MjVfs.cs b/unity/Runtime/Tools/MjVfs.cs
new file mode 100644
index 00000000..2449b1f6
--- /dev/null
+++ b/unity/Runtime/Tools/MjVfs.cs
@@ -0,0 +1,119 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using UnityEngine;
+
+namespace Mujoco {
+
+using static MujocoLib;
+
+// A wrapper around Mujoco's native _mjVFS that simplifies the process of creating memory files.
+public sealed class MjVfs : IDisposable {
+
+  private _mjVFS _managedVfs;
+  private IntPtr _unmanagedVfs;
+
+  // Managed version of the underlying _mjVFS structure.
+  public _mjVFS Data {
+    get {
+      _managedVfs = (_mjVFS)Marshal.PtrToStructure(_unmanagedVfs, typeof(_mjVFS));
+      return _managedVfs;
+    }
+    set {
+      _managedVfs = value;
+      Marshal.StructureToPtr(_managedVfs, _unmanagedVfs, fDeleteOld: false);
+    }
+  }
+
+  // Number of files added to the filesystem.
+  public int FilesCount {
+    get { return Data.nfile; }
+  }
+
+  // Adds a new file to the virtual filesystem.
+  public unsafe void AddFile(string filename, string contents) {
+    var result = mj_makeEmptyFileVFS(_unmanagedVfs.ToPointer(), filename, contents.Length);
+    if (result != 0) {
+      throw new Exception(
+          "VFS error (" + result + ") encountered while creating an empty file");
+    }
+    var fileIndex = mj_findFileVFS(_unmanagedVfs.ToPointer(), filename);
+    if (fileIndex < 0) {
+      throw new IndexOutOfRangeException("VFS didn't properly create the empty file.");
+    }
+    SetFileContents(fileIndex, contents);
+  }
+
+  // Searches the VFS for the specified file and returns its index.
+  // The index then can be used to retrieve the file contents from Data.filedata array.
+  public unsafe int FindFile(string filename) {
+    return mj_findFileVFS(_unmanagedVfs.ToPointer(), filename);
+  }
+
+  // Loads a model from the specified file.
+  // The file is assumed to be located in the filesystem. If it's not found, the method will throw
+  // an ArgumentException.
+  public unsafe MujocoLib.mjModel_* LoadXML(string filename) {
+    if (FindFile(filename) < 0) {
+      throw new ArgumentException($"File {filename} was not added to the VFS.");
+    }
+
+    var errorBuf = new StringBuilder(1024);
+    MujocoLib.mjModel_* model = MujocoLib.mj_loadXML(
+      filename, _unmanagedVfs.ToPointer(), errorBuf, errorBuf.Capacity);
+    if (model == null || errorBuf.Length > 0) {
+      throw new IOException($"Error loading the model: {errorBuf}");
+    }
+    return model;
+  }
+
+  private unsafe void SetFileContents(int fileIndex, string contents) {
+    var data = Data;
+    Marshal.FreeHGlobal(data.filedata[fileIndex]);
+    data.filedata[fileIndex] = Marshal.StringToHGlobalAnsi(contents);
+    Data = data;
+  }
+
+  public MjVfs() {
+    _managedVfs = new _mjVFS();
+    _unmanagedVfs = Marshal.AllocHGlobal(Marshal.SizeOf(_managedVfs));
+    Marshal.StructureToPtr(_managedVfs, _unmanagedVfs, true);
+  }
+
+  ~MjVfs() {
+    ReleaseUnmanagedMemory();
+  }
+
+  public void Dispose() {
+    GC.SuppressFinalize(this);
+    ReleaseUnmanagedMemory();
+  }
+
+  private void ReleaseUnmanagedMemory() {
+    if (_unmanagedVfs != IntPtr.Zero) {
+      var data = Data;
+      for (var fileIndex = 0; fileIndex < data.nfile; ++fileIndex) {
+        Marshal.FreeHGlobal(data.filedata[fileIndex]);
+      }
+
+      Marshal.FreeHGlobal(_unmanagedVfs);
+      _unmanagedVfs = IntPtr.Zero;
+    }
+  }
+}
+}
diff --git a/unity/Runtime/Tools/MjVfs.cs.meta b/unity/Runtime/Tools/MjVfs.cs.meta
new file mode 100644
index 00000000..664e8bac
--- /dev/null
+++ b/unity/Runtime/Tools/MjVfs.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 3cf049acadd3a4c8eb75f2a5a72ba589
+timeCreated: 1535566910
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Tools/MjcfGenerationContext.cs b/unity/Runtime/Tools/MjcfGenerationContext.cs
new file mode 100644
index 00000000..6a6f2715
--- /dev/null
+++ b/unity/Runtime/Tools/MjcfGenerationContext.cs
@@ -0,0 +1,104 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+
+// An instance of this class will be used to collect dynamic dependencies produced by a Mujoco model
+// during scene generation.
+public class MjcfGenerationContext {
+
+  public int NUserSensor {
+    get { return _nuserSensor; }
+    set { _nuserSensor = Math.Max(_nuserSensor, value); }
+  }
+
+  private int _nuserSensor;
+  private int _numGeneratedNames = 0;
+  private Dictionary<Mesh, string> _meshAssets = new Dictionary<Mesh, string>();
+
+  public void GenerateMjcf(XmlElement mjcf) {
+    GenerateConfigurationMjcf(mjcf);
+    GenerateAssetsMjcf(mjcf);
+  }
+
+  // Adds a mesh to the list of assets that will be added to the generated MJCF.
+  // Returns the unique name that identifies this new asset.
+  public string AddMeshAsset(Mesh mesh) {
+    if (!_meshAssets.ContainsKey(mesh)) {
+      var uniqueName = $"mesh_{_numGeneratedNames}";
+      _numGeneratedNames++;
+      _meshAssets.Add(mesh, uniqueName);
+    }
+    return _meshAssets[mesh];
+  }
+
+  // Generates a Unique name for the specified component.
+  // Uniqueness of names is required for every type independently.
+  // The per-type uniqueness will be guaranteed by the combination of information used:
+  // - name of the host GameObject.
+  // - number of names that have been generated to date.
+  public string GenerateName(Component comp) {
+    var name = $"{comp.gameObject.name}_{_numGeneratedNames}";
+    _numGeneratedNames++;
+    return name;
+  }
+
+  private void GenerateConfigurationMjcf(XmlElement mjcf) {
+    var doc = mjcf.OwnerDocument;
+    var compilerMjcf = (XmlElement)mjcf.AppendChild(doc.CreateElement("compiler"));
+    compilerMjcf.SetAttribute("coordinate", "local");
+
+    var optionMjcf = (XmlElement)mjcf.AppendChild(doc.CreateElement("option"));
+    optionMjcf.SetAttribute(
+        "gravity", MjEngineTool.Vector3ToMjcf(MjEngineTool.MjVector3(Physics.gravity)));
+    optionMjcf.SetAttribute("timestep", $"{Time.fixedDeltaTime}");
+
+    var sizeMjcf = (XmlElement)mjcf.AppendChild(doc.CreateElement("size"));
+    sizeMjcf.SetAttribute("nuser_sensor", $"{_nuserSensor}");
+
+    var settings = MjGlobalSettings.Instance;
+    if (settings) {
+      settings.OptionSizeToMjcf(optionMjcf, sizeMjcf);
+    }
+  }
+
+  private void GenerateAssetsMjcf(XmlElement mjcf) {
+    var doc = mjcf.OwnerDocument;
+    var assetMjcf = (XmlElement)mjcf.AppendChild(doc.CreateElement("asset"));
+    foreach (var asset in _meshAssets) {
+      var meshMjcf = (XmlElement)assetMjcf.AppendChild(doc.CreateElement("mesh"));
+      meshMjcf.SetAttribute("name", asset.Value);
+      GenerateMeshMjcf(asset.Key, meshMjcf);
+    }
+  }
+
+  private static void GenerateMeshMjcf(Mesh mesh, XmlElement mjcf) {
+    var vertexPositionsStr = new StringBuilder();
+    foreach (var unityVertex in mesh.vertices) {
+      var mjVertex = MjEngineTool.MjVector3(unityVertex);
+      vertexPositionsStr.Append(MjEngineTool.Vector3ToMjcf(mjVertex));
+      vertexPositionsStr.Append(" ");
+    }
+    mjcf.SetAttribute("vertex", vertexPositionsStr.ToString());
+  }
+}
+}
diff --git a/unity/Runtime/Tools/MjcfGenerationContext.cs.meta b/unity/Runtime/Tools/MjcfGenerationContext.cs.meta
new file mode 100644
index 00000000..d66c9354
--- /dev/null
+++ b/unity/Runtime/Tools/MjcfGenerationContext.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c6b8eb0cef9a04e2d92bb573828f1be8
+timeCreated: 1550078178
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Runtime/Tools/XmlElementExtensions.cs b/unity/Runtime/Tools/XmlElementExtensions.cs
new file mode 100644
index 00000000..13a39ab4
--- /dev/null
+++ b/unity/Runtime/Tools/XmlElementExtensions.cs
@@ -0,0 +1,167 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Linq;
+using System.Xml;
+using UnityEngine;
+
+namespace Mujoco {
+// This class helps us manipulate MuJoCo-bound XML files. It is only intended to be used
+// within the context of MuJoCo - elsewhere the preferred format is JSON.
+public static class XmlElementExtensions {
+
+  public static bool GetBoolAttribute(
+      this XmlElement element, string name, bool defaultValue = false) {
+    if (!element.HasAttribute(name)) {
+      return defaultValue;
+    }
+    var strValue = element.GetAttribute(name);
+    bool parsedValue;
+    if (bool.TryParse(strValue, out parsedValue)) {
+      return parsedValue;
+    } else {
+      throw new ArgumentException($"'{strValue}' is not a bool.");
+    }
+  }
+
+  public static float GetFloatAttribute(
+      this XmlElement element, string name, float defaultValue = 0.0f) {
+    if (!element.HasAttribute(name)) {
+      return defaultValue;
+    }
+    var strValue = element.GetAttribute(name);
+    float parsedValue;
+    if (float.TryParse(strValue, out parsedValue)) {
+      return parsedValue;
+    } else {
+      throw new ArgumentException($"'{strValue}' is not a float.");
+    }
+  }
+
+  // The MuJoCo parser is case-sensitive.
+  public static T GetEnumAttribute<T>(
+      this XmlElement element, string name, T defaultValue,
+      bool ignoreCase = false) where T : struct, IConvertible {
+    if (!typeof(T).IsEnum) {
+      throw new ArgumentException("T must be an enumerated type.");
+    }
+    if (!element.HasAttribute(name)) {
+      return defaultValue;
+    }
+    var strValue = element.GetAttribute(name);
+    T parsedValue;
+    if (Enum.TryParse<T>(strValue, ignoreCase, out parsedValue)) {
+      return parsedValue;
+    } else {
+      throw new ArgumentException(
+        $"Reading attribute {name}: '{strValue}' is not a value of enum {typeof(T)}.");
+    }
+  }
+
+  public static string GetStringAttribute(
+      this XmlElement element, string name, string defaultValue = null) {
+    if (!element.HasAttribute(name)) {
+      return defaultValue;
+    }
+    return element.GetAttribute(name);
+  }
+
+  public static T GetObjectReferenceAttribute<T>(
+    this XmlElement mjcf, string attributeName) where T : MjComponent {
+    var objectName = mjcf.GetStringAttribute(attributeName);
+    if (string.IsNullOrEmpty(objectName)) {
+      return null;
+    }
+    T foundObject = MjHierarchyTool.FindComponentOfTypeAndName<T>(objectName);
+    if (foundObject == null) {
+      throw new ArgumentException(
+        $"Object {objectName} of type {typeof(T).ToString()} referred by {attributeName} " +
+        "doesn't exist.");
+    }
+    return foundObject;
+  }
+
+  public static Vector2 GetVector2Attribute(
+      this XmlElement element, string name, Vector2 defaultValue) {
+    var defaultValues = new float[] {defaultValue.x, defaultValue.y};
+    var components = element.GetFloatArrayAttribute(name, defaultValues, fillMissingValues: false);
+    if (components.Length != 2) {
+      throw new ArgumentException("Invalid Vector2 string representation.");
+    }
+    return new Vector2(components[0], components[1]);
+  }
+
+  public static Vector3 GetVector3Attribute(
+      this XmlElement element, string name, Vector3 defaultValue) {
+    var defaultValues = new float[] {
+        defaultValue.x, defaultValue.y, defaultValue.z};
+    var components = element.GetFloatArrayAttribute(name, defaultValues, fillMissingValues: false);
+    if (components.Length != 3) {
+      throw new ArgumentException("Invalid Vector3 string representation.");
+    }
+    return new Vector3(components[0], components[1], components[2]);
+  }
+
+  public static Quaternion GetQuaternionAttribute(
+      this XmlElement element, string name, Quaternion defaultValue) {
+    var mjDefault = new float[] {
+        defaultValue.w, defaultValue.x, defaultValue.y, defaultValue.z };
+    var components = element.GetFloatArrayAttribute(name, mjDefault, fillMissingValues: false);
+    if (components.Length != 4) {
+      throw new ArgumentException("Invalid Quaternion string representation.");
+    }
+    return new Quaternion(w:components[0], x:components[1], y:components[2], z:components[3]);
+  }
+
+  // Parses an array of whitespace separated floating points.
+  //
+  // Args:
+  // . element: XmlElement that contains the attribute to be parsed.
+  // . name: Name of the attribute to be parsed.
+  // . defaultValue: An array of floats, or null. A default value to be returned in case the
+  // the attribute is missing.
+  // . fillMissingValues: If a default value was provided, and it has more components than the value
+  // parsed from the attribute, the missing components will be copied from the defaultValue.
+  public static float[] GetFloatArrayAttribute(
+      this XmlElement element, string name, float[] defaultValue, bool fillMissingValues = true) {
+    if (!element.HasAttribute(name)) {
+      return defaultValue;
+    }
+    var strValue = element.GetAttribute(name);
+    var components = strValue.Split(new char[] {' '}, StringSplitOptions.RemoveEmptyEntries);
+    var resultLength = components.Length;
+    if (fillMissingValues && defaultValue != null) {
+      // If filling of the missing values was enabled, and a default value was provided,
+      // allocate an array large enough to store a value of this length, in case when the parsed
+      // value has fewer components.
+      resultLength = Math.Max(resultLength, defaultValue.Length);
+    }
+    var result = new float[resultLength];
+    for (var i = 0; i < components.Length; ++i) {
+      float componentValue;
+      if (float.TryParse(components[i], out componentValue)) {
+        result[i] = componentValue;
+      } else {
+        throw new ArgumentException($"'{components[i]}' is not a float.");
+      }
+    }
+    for (var i = components.Length; i < resultLength; ++i) {
+      // Fill the missing values with defaults.
+      result[i] = defaultValue[i];
+    }
+    return result;
+  }
+}
+}
diff --git a/unity/Runtime/Tools/XmlElementExtensions.cs.meta b/unity/Runtime/Tools/XmlElementExtensions.cs.meta
new file mode 100644
index 00000000..5a9b7703
--- /dev/null
+++ b/unity/Runtime/Tools/XmlElementExtensions.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 783a359f292c1477caf7e242023ed32c
+timeCreated: 1538658945
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests.meta b/unity/Tests.meta
new file mode 100644
index 00000000..cdeecae9
--- /dev/null
+++ b/unity/Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 91df43b57443b08199a7760600f269c0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor.meta b/unity/Tests/Editor.meta
new file mode 100644
index 00000000..c8776047
--- /dev/null
+++ b/unity/Tests/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3aaa99a2ff0c81fecb23640fb3d370c2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/Mujoco.Editor.Tests.asmdef b/unity/Tests/Editor/Mujoco.Editor.Tests.asmdef
new file mode 100644
index 00000000..d7105b41
--- /dev/null
+++ b/unity/Tests/Editor/Mujoco.Editor.Tests.asmdef
@@ -0,0 +1,25 @@
+{
+    "name": "Mujoco.Editor.Tests",
+    "rootNamespace": "",
+    "references": [
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner",
+        "Mujoco",
+        "Mujoco.Editor"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/unity/Tests/Editor/Mujoco.Editor.Tests.asmdef.meta b/unity/Tests/Editor/Mujoco.Editor.Tests.asmdef.meta
new file mode 100644
index 00000000..db342d28
--- /dev/null
+++ b/unity/Tests/Editor/Mujoco.Editor.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3dbed54fed4572890a6f2e1bcf3e4c3f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/bindings.meta b/unity/Tests/Editor/bindings.meta
new file mode 100644
index 00000000..b4cf8917
--- /dev/null
+++ b/unity/Tests/Editor/bindings.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: aa64c2bc8087a12e5a16c032a1e67f63
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/bindings/FixedSizeIListHelperTests.cs b/unity/Tests/Editor/bindings/FixedSizeIListHelperTests.cs
new file mode 100644
index 00000000..af78ce3b
--- /dev/null
+++ b/unity/Tests/Editor/bindings/FixedSizeIListHelperTests.cs
@@ -0,0 +1,171 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class FixedSizeIListHelperTests {
+  public class Example : FixedSizeIListHelper<string> {
+    public override string this[int index] {
+      get {
+        switch (index) {
+          case 0: return _element0;
+          case 1: return _element1;
+        }
+        return "";
+      }
+      set {
+        switch (index) {
+          case 0: _element0 = value; break;
+          case 1: _element1 = value; break;
+        }
+      }
+    }
+
+    public override int Count => 2;
+
+    private string _element0;
+    private string _element1;
+  }
+
+  [Test]
+  public void CanReadThroughIListInterface() {
+    var example = new Example();
+    IList<string> ilist = example;
+    example[0] = "a";
+
+    Assert.That(ilist[0], Is.EqualTo("a"));
+  }
+
+  [Test]
+  public void CanWriteThroughIListInterface() {
+    var example = new Example();
+    IList<string> ilist = example;
+    ilist[1] = "b";
+
+    Assert.That(example[1], Is.EqualTo("b"));
+  }
+
+  [Test]
+  public void EnumeratorWorks() {
+    var example = new Example();
+    example[0] = "a";
+    example[1] = "b";
+
+    var actual = new List<string>();
+    foreach (var element in example) {
+      actual.Add(element);
+    }
+    Assert.That(actual.Count, Is.EqualTo(2));
+    Assert.That(actual[0], Is.EqualTo("a"));
+    Assert.That(actual[1], Is.EqualTo("b"));
+  }
+
+  [Test]
+  public void AddNotSupported() {
+    var example = new Example();
+    Assert.Throws<NotSupportedException>(() => example.Add(""));
+  }
+
+  [Test]
+  public void ClearNotSupported() {
+    var example = new Example();
+    Assert.Throws<NotSupportedException>(() => example.Clear());
+  }
+
+  [Test]
+  public void RemoveNotSupported() {
+    var example = new Example();
+    Assert.Throws<NotSupportedException>(() => example.Remove(""));
+  }
+
+  [Test]
+  public void InsertNotSupported() {
+    var example = new Example();
+    Assert.Throws<NotSupportedException>(() => example.Insert(0, ""));
+  }
+
+  [Test]
+  public void RemoveAtNotSupported() {
+    var example = new Example();
+    Assert.Throws<NotSupportedException>(() => example.RemoveAt(0));
+  }
+
+  [Test]
+  public void ContainsFindsItems() {
+    var example = new Example();
+    example[0] = "a";
+    example[1] = "b";
+    Assert.That(example.Contains("a"));
+    Assert.That(example.Contains("b"));
+  }
+
+  [Test]
+  public void ContainsDoesntFindAbsentItems() {
+    var example = new Example();
+    example[0] = "a";
+    example[1] = "b";
+    Assert.That(!example.Contains("c"));
+  }
+
+  [Test]
+  public void CopyTo() {
+    var example = new Example();
+    example[0] = "a";
+    example[1] = "b";
+
+    var buffer = new string[7];
+    example.CopyTo(buffer, 3);
+
+    var expected = new string[] {
+      null,
+      null,
+      null,
+      "a",
+      "b",
+      null,
+      null,
+    };
+
+    Assert.That(buffer, Is.EqualTo(expected));
+  }
+
+  [Test]
+  public void IndexOfFindsItems() {
+    var example = new Example();
+    example[0] = "a";
+    example[1] = "b";
+    Assert.That(0, Is.EqualTo(example.IndexOf("a")));
+    Assert.That(1, Is.EqualTo(example.IndexOf("b")));
+  }
+
+  [Test]
+  public void IndexOfDoesntFindAbsentItems() {
+    var example = new Example();
+    example[0] = "a";
+    example[1] = "b";
+    Assert.That(-1, Is.EqualTo(example.IndexOf("c")));
+  }
+}
+}
diff --git a/unity/Tests/Editor/bindings/FixedSizeIListHelperTests.cs.meta b/unity/Tests/Editor/bindings/FixedSizeIListHelperTests.cs.meta
new file mode 100644
index 00000000..eb9aee89
--- /dev/null
+++ b/unity/Tests/Editor/bindings/FixedSizeIListHelperTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c9ed9c5b0167147beaa7da6310cefa84
+timeCreated: 1538060897
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components.meta b/unity/Tests/Editor/components.meta
new file mode 100644
index 00000000..45566040
--- /dev/null
+++ b/unity/Tests/Editor/components.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 877674f90a69caea99bcdeee0efe7e36
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Bodies.meta b/unity/Tests/Editor/components/Bodies.meta
new file mode 100644
index 00000000..09debac3
--- /dev/null
+++ b/unity/Tests/Editor/components/Bodies.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e45a6008183fa3804aa9daf9b921c48d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Bodies/MjBodyTests.cs b/unity/Tests/Editor/components/Bodies/MjBodyTests.cs
new file mode 100644
index 00000000..ec292026
--- /dev/null
+++ b/unity/Tests/Editor/components/Bodies/MjBodyTests.cs
@@ -0,0 +1,88 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools.Utils;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjBodyTransformTests {
+
+  private GameObject _parent;
+  private MjBody _body;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _parent = new GameObject("parent");
+    _body = new GameObject("body", typeof(MjBody)).GetComponent<MjBody>();
+    _body.transform.parent = _parent.transform;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    GameObject.DestroyImmediate(_body.gameObject);
+    GameObject.DestroyImmediate(_parent);
+  }
+
+  [Test]
+  public void RelativePositionUsedInMjcf() {
+    _parent.transform.position = new Vector3(1, 2, 3);
+    _parent.transform.rotation = Quaternion.AngleAxis(45.0f, (new Vector3(1, 2, 3)).normalized);
+    var element = _doc.AppendChild(_body.GenerateMjcf("name", _doc)) as XmlElement;
+    Assert.That(_doc.OuterXml, Does.Contain(@"pos=""1 3 2"""));
+    Assert.That(
+        element.GetQuaternionAttribute("quat", Quaternion.identity),
+        Is.EqualTo(new Quaternion(w:-0.9238795f, x:0.1022765f, y:0.3068294f, z:0.2045529f))
+        .Using(new Vector4EqualityComparer(1e-4f)));
+  }
+
+  [Test]
+  public void LocalPositionParsing() {
+    var bodyElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("body"));
+    bodyElement.SetAttribute("pos", "1 2 3");
+    _body.ParseMjcf(bodyElement);
+    Assert.That(_body.transform.localPosition, Is.EqualTo(new Vector3(1, 3, 2)));
+  }
+
+  [TestCase(0.866f, 0.5f, 0, 0, 0.5f, 0, 0, -0.866f)]
+  [TestCase(0.866f, 0, 0.5f, 0, 0, 0, 0.5f, -0.866f)]
+  [TestCase(0.866f, 0, 0, 0.5f, 0, 0.5f, 0, -0.866f)]
+  [TestCase(0, 0.866f, 0.5f, 0, 0.866f, 0, 0.5f, 0)]
+  [TestCase(0, 0.866f, 0, 0.5f, 0.866f, 0.5f, 0, 0)]
+  [TestCase(0, 0, 0.866f, 0.5f, 0, 0.5f, 0.866f, 0)]
+  public void BodyLocalRotationParsing(
+      float ix, float iy, float iz, float iw, float ex, float ey, float ez, float ew) {
+    var bodyElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("body"));
+    bodyElement.SetAttribute("quat", $"{ix} {iy} {iz} {iw}");
+    _body.ParseMjcf(bodyElement);
+    var angle = Quaternion.Angle(_body.transform.localRotation, new Quaternion(ex, ey, ez, ew));
+    Assert.That(angle, Is.EqualTo(0).Within(3));
+  }
+
+  [Test]
+  public void ParsingDefaultRotation() {
+    var bodyElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("body"));
+    _body.ParseMjcf(bodyElement);
+    Assert.That(_body.transform.localRotation, Is.EqualTo(Quaternion.identity));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Bodies/MjBodyTests.cs.meta b/unity/Tests/Editor/components/Bodies/MjBodyTests.cs.meta
new file mode 100644
index 00000000..63b9f21d
--- /dev/null
+++ b/unity/Tests/Editor/components/Bodies/MjBodyTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: d682a3aa23e0740fe8fc6e00ba1b0e53
+timeCreated: 1537462858
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Equality.meta b/unity/Tests/Editor/components/Equality.meta
new file mode 100644
index 00000000..0ee4d23c
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3483f37c29faced05bc1ddd810a7911d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Equality/MjConnectTests.cs b/unity/Tests/Editor/components/Equality/MjConnectTests.cs
new file mode 100644
index 00000000..5308e23f
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjConnectTests.cs
@@ -0,0 +1,80 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+  [TestFixture]
+  public class MjConnectTests {
+    private MjBody _body1;
+    private MjBody _body2;
+    private MjConnect _constraint;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _body1 = new GameObject("body1").AddComponent<MjBody>();
+      _body2 = new GameObject("body2").AddComponent<MjBody>();
+      _constraint = new GameObject("connect").AddComponent<MjConnect>();
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_constraint.gameObject);
+      UnityEngine.Object.DestroyImmediate(_body1.gameObject);
+      UnityEngine.Object.DestroyImmediate(_body2.gameObject);
+    }
+
+    [Test]
+    public void ErrorThrownWhenBody1Empty() {
+      // This is an illegal MJCF, but the purpose of this test is to verify that if
+      // the user didn't assign the body in the editor, an error will be thrown when play is hit.
+      _doc.LoadXml("<body/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("body")[0] as XmlElement);
+      Assert.That(() => { _constraint.GenerateMjcf("name", _doc); }, Throws.Exception);
+    }
+
+    // In this constraint both elements are required.
+    [Test]
+    public void ErrorThrownWhenBody2Empty() {
+      _doc.LoadXml("<body body1='body1'/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("body")[0] as XmlElement);
+      Assert.That(() => { _constraint.GenerateMjcf("name", _doc); }, Throws.Exception);
+    }
+
+    [Test]
+    public void ParseXML() {
+      _doc.LoadXml("<connect body1='body1' body2='body2'/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("connect")[0] as XmlElement);
+      Assert.That(_constraint.Body1, Is.EqualTo(_body1));
+      Assert.That(_constraint.Body2, Is.EqualTo(_body2));
+    }
+
+    [Test]
+    public void GenerateXML() {
+      _constraint.Body1 = _body1;
+      _constraint.Body2 = _body2;
+      var mjcf = _constraint.GenerateMjcf("name", _doc);
+      Assert.That(mjcf.OuterXml, Does.Contain("<connect"));
+      Assert.That(mjcf.OuterXml, Does.Contain("body1=\""));
+      Assert.That(mjcf.OuterXml, Does.Contain("body2=\""));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Equality/MjConnectTests.cs.meta b/unity/Tests/Editor/components/Equality/MjConnectTests.cs.meta
new file mode 100644
index 00000000..8bde3b21
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjConnectTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9953e9b7dff0c4779b541fb6f198daf1
+timeCreated: 1554295202
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Equality/MjDistanceTests.cs b/unity/Tests/Editor/components/Equality/MjDistanceTests.cs
new file mode 100644
index 00000000..466b1965
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjDistanceTests.cs
@@ -0,0 +1,74 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+  [TestFixture]
+  public class MjDistanceTests {
+    private MjGeom _geom1;
+    private MjGeom _geom2;
+    private MjDistance _distance;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _geom1 = new GameObject("geom1").AddComponent<MjGeom>();
+      _geom2 = new GameObject("geom2").AddComponent<MjGeom>();
+      _distance = new GameObject("distance").AddComponent<MjDistance>();
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_distance.gameObject);
+      UnityEngine.Object.DestroyImmediate(_geom1.gameObject);
+      UnityEngine.Object.DestroyImmediate(_geom2.gameObject);
+    }
+
+    [Test]
+    public void ErrorThrownWhenGeom1Empty() {
+      // This is an illegal MJCF, but the purpose of this test is to verify that if
+      // the user didn't assign the geom in the editor, an error will be thrown when play is hit.
+      _doc.LoadXml("<geom/>");
+      _distance.ParseMjcf(_doc.GetElementsByTagName("geom")[0] as XmlElement);
+      Assert.That(() => { _distance.GenerateMjcf("name", _doc); }, Throws.Exception);
+    }
+
+    // In this constraint both elements are required.
+    [Test]
+    public void ErrorThrownWhenGeom2Empty() {
+      _doc.LoadXml("<geom geom1='geom1'/>");
+      _distance.ParseMjcf(_doc.GetElementsByTagName("geom")[0] as XmlElement);
+      Assert.That(() => { _distance.GenerateMjcf("name", _doc); }, Throws.Exception);
+    }
+
+    [Test]
+    public void ParseAndGenerate() {
+      _doc.LoadXml("<distance geom1='geom1' geom2='geom2'/>");
+      _distance.ParseMjcf(_doc.GetElementsByTagName("distance")[0] as XmlElement);
+      Assert.That(_distance.Geom1, Is.EqualTo(_geom1));
+      Assert.That(_distance.Geom2, Is.EqualTo(_geom2));
+      var mjcf = _distance.GenerateMjcf("name", _doc);
+      Assert.That(mjcf.OuterXml, Does.Contain("<distance"));
+      Assert.That(mjcf.OuterXml, Does.Contain("geom1=\""));
+      Assert.That(mjcf.OuterXml, Does.Contain("geom2=\""));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Equality/MjDistanceTests.cs.meta b/unity/Tests/Editor/components/Equality/MjDistanceTests.cs.meta
new file mode 100644
index 00000000..e9846d81
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjDistanceTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 528955688a5574fa5ba1433088808a1b
+timeCreated: 1552313909
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Equality/MjJointConstraintTests.cs b/unity/Tests/Editor/components/Equality/MjJointConstraintTests.cs
new file mode 100644
index 00000000..fedf992a
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjJointConstraintTests.cs
@@ -0,0 +1,69 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+  [TestFixture]
+  public class MjJointConstraintTests {
+    private MjHingeJoint _joint1;
+    private MjHingeJoint _joint2;
+    private MjJointConstraint _constraint;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _joint1 = new GameObject("joint1").AddComponent<MjHingeJoint>();
+      _joint2 = new GameObject("joint2").AddComponent<MjHingeJoint>();
+      _constraint = new GameObject("joint").AddComponent<MjJointConstraint>();
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_constraint.gameObject);
+      UnityEngine.Object.DestroyImmediate(_joint1.gameObject);
+      UnityEngine.Object.DestroyImmediate(_joint2.gameObject);
+    }
+
+    [Test]
+    public void ErrorThrownWhenJoint1Empty() {
+      // This is an illegal MJCF, but the purpose of this test is to verify that if
+      // the user didn't assign the joint in the editor, an error will be thrown when play is hit.
+      _doc.LoadXml("<joint/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("joint")[0] as XmlElement);
+      Assert.That(() => { _constraint.GenerateMjcf("name", _doc); }, Throws.Exception);
+    }
+
+    [Test]
+    public void Joint2Empty() {
+      _doc.LoadXml("<joint joint1='joint1'/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("joint")[0] as XmlElement);
+      _constraint.GenerateMjcf("name", _doc);
+    }
+
+    [Test]
+    public void ParseAllSettings() {
+      _doc.LoadXml("<joint joint1='joint1' joint2='joint2'/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("joint")[0] as XmlElement);
+      Assert.That(_constraint.Joint1, Is.EqualTo(_joint1));
+      Assert.That(_constraint.Joint2, Is.EqualTo(_joint2));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Equality/MjJointConstraintTests.cs.meta b/unity/Tests/Editor/components/Equality/MjJointConstraintTests.cs.meta
new file mode 100644
index 00000000..26872f7c
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjJointConstraintTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: f27eef27742fe44898f332fc7bff870e
+timeCreated: 1552309373
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Equality/MjTendonConstraintTests.cs b/unity/Tests/Editor/components/Equality/MjTendonConstraintTests.cs
new file mode 100644
index 00000000..3d648e9c
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjTendonConstraintTests.cs
@@ -0,0 +1,69 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+  [TestFixture]
+  public class MjTendonConstraintTests {
+    private MjFixedTendon _tendon1;
+    private MjFixedTendon _tendon2;
+    private MjTendonConstraint _constraint;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _tendon1 = new GameObject("tendon1").AddComponent<MjFixedTendon>();
+      _tendon2 = new GameObject("tendon2").AddComponent<MjFixedTendon>();
+      _constraint = new GameObject("tendon").AddComponent<MjTendonConstraint>();
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_constraint.gameObject);
+      UnityEngine.Object.DestroyImmediate(_tendon1.gameObject);
+      UnityEngine.Object.DestroyImmediate(_tendon2.gameObject);
+    }
+
+    [Test]
+    public void ErrorThrownWhenTendon1Empty() {
+      // This is an illegal MJCF, but the purpose of this test is to verify that if
+      // the user didn't assign the tendon in the editor, an error will be thrown when play is hit.
+      _doc.LoadXml("<tendon/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("tendon")[0] as XmlElement);
+      Assert.That(() => { _constraint.GenerateMjcf("name", _doc); }, Throws.Exception);
+    }
+
+    [Test]
+    public void Tendon2Empty() {
+      _doc.LoadXml("<tendon tendon1='tendon1'/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("tendon")[0] as XmlElement);
+      _constraint.GenerateMjcf("name", _doc);
+    }
+
+    [Test]
+    public void ParseAllSettings() {
+      _doc.LoadXml("<tendon tendon1='tendon1' tendon2='tendon2'/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("tendon")[0] as XmlElement);
+      Assert.That(_constraint.Tendon1, Is.EqualTo(_tendon1));
+      Assert.That(_constraint.Tendon2, Is.EqualTo(_tendon2));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Equality/MjTendonConstraintTests.cs.meta b/unity/Tests/Editor/components/Equality/MjTendonConstraintTests.cs.meta
new file mode 100644
index 00000000..5798a912
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjTendonConstraintTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: dc3cafd0739674e46a797243aab71e50
+timeCreated: 1552310856
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Equality/MjWeldTests.cs b/unity/Tests/Editor/components/Equality/MjWeldTests.cs
new file mode 100644
index 00000000..61587584
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjWeldTests.cs
@@ -0,0 +1,80 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+  [TestFixture]
+  public class MjWeldTests {
+    private MjBody _body1;
+    private MjBody _body2;
+    private MjWeld _constraint;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _body1 = new GameObject("body1").AddComponent<MjBody>();
+      _body2 = new GameObject("body2").AddComponent<MjBody>();
+      _constraint = new GameObject("weld").AddComponent<MjWeld>();
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_constraint.gameObject);
+      UnityEngine.Object.DestroyImmediate(_body1.gameObject);
+      UnityEngine.Object.DestroyImmediate(_body2.gameObject);
+    }
+
+    [Test]
+    public void ParseXML() {
+      _doc.LoadXml("<weld body1='body1' body2='body2'/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("weld")[0] as XmlElement);
+      Assert.That(_constraint.Body1, Is.EqualTo(_body1));
+      Assert.That(_constraint.Body2, Is.EqualTo(_body2));
+    }
+
+    [Test]
+    public void GenerateXML() {
+      _constraint.Body1 = _body1;
+      _constraint.Body2 = _body2;
+      var mjcf = _constraint.GenerateMjcf("name", _doc);
+      Assert.That(mjcf.OuterXml, Does.Contain("<weld"));
+      Assert.That(mjcf.OuterXml, Does.Contain("body1=\""));
+      Assert.That(mjcf.OuterXml, Does.Contain("body2=\""));
+    }
+
+    [Test]
+    public void ErrorThrownWhenBody1Empty() {
+      // This is an illegal MJCF, but the purpose of this test is to verify that if
+      // the user didn't assign the body in the editor, an error will be thrown when play is hit.
+      _doc.LoadXml("<weld/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("weld")[0] as XmlElement);
+      Assert.That(() => { _constraint.GenerateMjcf("name", _doc); }, Throws.Exception);
+    }
+
+    // In this constraint both elements are required.
+    [Test]
+    public void ErrorThrownWhenBody2Empty() {
+      _doc.LoadXml("<weld body1='body1'/>");
+      _constraint.ParseMjcf(_doc.GetElementsByTagName("weld")[0] as XmlElement);
+      Assert.That(() => { _constraint.GenerateMjcf("name", _doc); }, Throws.Exception);
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Equality/MjWeldTests.cs.meta b/unity/Tests/Editor/components/Equality/MjWeldTests.cs.meta
new file mode 100644
index 00000000..25bddf55
--- /dev/null
+++ b/unity/Tests/Editor/components/Equality/MjWeldTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 1482bf1eedf014e1bb156598b3e32f8e
+timeCreated: 1550663177
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Joints.meta b/unity/Tests/Editor/components/Joints.meta
new file mode 100644
index 00000000..e3e8da13
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 14dbadfe71f022782b39f72eec43ca8f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Joints/MjBallJointTests.cs b/unity/Tests/Editor/components/Joints/MjBallJointTests.cs
new file mode 100644
index 00000000..1c73d0b2
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjBallJointTests.cs
@@ -0,0 +1,74 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjBallJointTests {
+
+  private GameObject _parent;
+  private MjBallJoint _joint;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _parent = new GameObject("parent");
+    _joint = new GameObject("joint").AddComponent<MjBallJoint>();
+    _joint.transform.parent = _parent.transform;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    GameObject.DestroyImmediate(_parent);
+  }
+
+  [Test]
+  public void ComponentWorldPositionConvertedToMjCoordinates() {
+    _joint.transform.position = new Vector3(1, 2, 3);
+    _doc.AppendChild(_joint.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"pos=""1 3 2"""));
+  }
+
+  [Test]
+  public void GenerateLimits() {
+    _joint.RangeUpper = 10;
+    _doc.AppendChild(_joint.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"range=""0 10"""));
+  }
+
+  [Test]
+  public void ParsingPosition() {
+    var jointElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    jointElement.SetAttribute("pos", "1 2 3");
+    _joint.ParseMjcf(jointElement);
+    Assert.That(_joint.transform.localPosition, Is.EqualTo(new Vector3(1, 3, 2)));
+  }
+
+  [Test]
+  public void ParsingJointLimitRangeSettings() {
+    var jointElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    jointElement.SetAttribute("range", "0 10");
+    _joint.ParseMjcf(jointElement);
+    Assert.That(_joint.RangeUpper, Is.EqualTo(10));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Joints/MjBallJointTests.cs.meta b/unity/Tests/Editor/components/Joints/MjBallJointTests.cs.meta
new file mode 100644
index 00000000..a7350a1e
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjBallJointTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 76c34ae488142477588dcd6231bb0386
+timeCreated: 1552057103
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Joints/MjBaseJointTests.cs b/unity/Tests/Editor/components/Joints/MjBaseJointTests.cs
new file mode 100644
index 00000000..5dce7caa
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjBaseJointTests.cs
@@ -0,0 +1,77 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjBaseJointTests {
+
+  public class FakeJoint : MjBaseJoint {
+    protected override void OnParseMjcf(XmlElement mjcf) {}
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      return (XmlElement)doc.CreateElement("joint");
+    }
+  }
+
+  private FakeJoint _joint;
+  private MjBaseBody _parent;
+  private MjBaseBody _grandParent;
+
+  [Test]
+  public void RetrievingBodiesConnectedByTheJoint() {
+    _joint = new GameObject("joint").AddComponent<FakeJoint>();
+    _parent = new GameObject("parent").AddComponent<MjBody>();
+    _grandParent = new GameObject("grandParent").AddComponent<MjBody>();
+
+    _joint.transform.parent = _parent.transform;
+    _parent.transform.parent = _grandParent.transform;
+
+    MjBaseBody grandParent, parent;
+    _joint.GetConnectedBodies(out grandParent, out parent);
+    Assert.That(grandParent, Is.EqualTo(_grandParent));
+    Assert.That(parent, Is.EqualTo(_parent));
+
+    GameObject.DestroyImmediate(_joint.gameObject);
+    GameObject.DestroyImmediate(_parent.gameObject);
+    GameObject.DestroyImmediate(_grandParent.gameObject);
+    GameObject.DestroyImmediate(MjScene.Instance);
+  }
+
+  [Test]
+  public void RetrievingBodiesConnectedToTheWorld() {
+    _joint = new GameObject("joint").AddComponent<FakeJoint>();
+    _parent = new GameObject("parent").AddComponent<MjBody>();
+
+    _joint.transform.parent = _parent.transform;
+
+    MjBaseBody grandParent, parent;
+    _joint.GetConnectedBodies(out grandParent, out parent);
+    Assert.That(grandParent, Is.Null);
+    Assert.That(parent, Is.EqualTo(_parent));
+
+    GameObject.DestroyImmediate(_joint.gameObject);
+    GameObject.DestroyImmediate(_parent.gameObject);
+    GameObject.DestroyImmediate(MjScene.Instance);
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Joints/MjBaseJointTests.cs.meta b/unity/Tests/Editor/components/Joints/MjBaseJointTests.cs.meta
new file mode 100644
index 00000000..ad2e4f21
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjBaseJointTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 61b458a2c0d3a4c54a2ead000ba4b32e
+timeCreated: 1538412731
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Joints/MjHingeJointTests.cs b/unity/Tests/Editor/components/Joints/MjHingeJointTests.cs
new file mode 100644
index 00000000..cff75293
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjHingeJointTests.cs
@@ -0,0 +1,102 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools.Utils;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjHingeJointTests {
+
+  private GameObject _parent;
+  private MjHingeJoint _joint;
+  private XmlDocument _doc;
+  private Vector3EqualityComparer _comparer;
+
+  [SetUp]
+  public void SetUp() {
+    _parent = new GameObject("parent");
+    _joint = new GameObject("joint", typeof(MjHingeJoint)).GetComponent<MjHingeJoint>();
+    _joint.transform.parent = _parent.transform;
+    _doc = new XmlDocument();
+    _comparer = new Vector3EqualityComparer(1e-3f);
+  }
+
+  [TearDown]
+  public void TearDown() {
+    GameObject.DestroyImmediate(_parent);
+  }
+
+  [Test]
+  public void ComponentWorldPositionConvertedToMjCoordinates() {
+    _joint.transform.position = new Vector3(1, 2, 3);
+    _doc.AppendChild(_joint.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"pos=""1 3 2"""));
+  }
+
+  [Test]
+  public void TestingAnOffsetAxis() {
+    _joint.transform.rotation =
+        Quaternion.AngleAxis(45.0f, Vector3.up);
+    var element = _joint.GenerateMjcf("name", _doc);
+    Assert.That(element.GetVector3Attribute("axis", Vector3.zero),
+                Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_comparer));
+  }
+
+  [Test]
+  public void GenerateLimits() {
+    _joint.RangeLower = -20;
+    _joint.RangeUpper = 10;
+    _doc.AppendChild(_joint.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"range=""-20 10"""));
+  }
+
+  [Test]
+  public void ParsingPosition() {
+    var jointElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    jointElement.SetAttribute("pos", "1 2 3");
+    _joint.ParseMjcf(jointElement);
+    Assert.That(_joint.transform.localPosition, Is.EqualTo(new Vector3(1, 3, 2)));
+  }
+
+  [TestCase("1 0 0", 1, 0, 0)]
+  [TestCase("0 1 0", 0, 0, 1)]
+  [TestCase("0 0 1", 0, 1, 0)]
+  public void ParsingTranslatesRotationAxisIntoJointRotation(
+      string setting, float rx, float ry, float rz) {
+    var jointElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    jointElement.SetAttribute("axis", setting);
+    _joint.ParseMjcf(jointElement);
+    Assert.That(_joint.RotationAxis, Is.EqualTo(new Vector3(rx, ry, rz)).Using(_comparer));
+  }
+
+  [TestCase("0 10", 0, 10)]
+  [TestCase("-10 0", -10, 0)]
+  [TestCase("-10 10", -10, 10)]
+  public void ParsingJointLimitRangeSettings(
+      string setting, float expectedLow, float expectedHigh) {
+    var jointElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    jointElement.SetAttribute("range", setting);
+    _joint.ParseMjcf(jointElement);
+    Assert.That(_joint.RangeLower, Is.EqualTo(expectedLow));
+    Assert.That(_joint.RangeUpper, Is.EqualTo(expectedHigh));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Joints/MjHingeJointTests.cs.meta b/unity/Tests/Editor/components/Joints/MjHingeJointTests.cs.meta
new file mode 100644
index 00000000..9b863ef4
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjHingeJointTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 61d44d0160a1c43e38cb0f9eaebbfa92
+timeCreated: 1537527115
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Joints/MjJointSettingsTests.cs b/unity/Tests/Editor/components/Joints/MjJointSettingsTests.cs
new file mode 100644
index 00000000..3e4b16c3
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjJointSettingsTests.cs
@@ -0,0 +1,223 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjJointSettingsGenerationTests {
+
+  private MjJointSettings _settings;
+  private XmlDocument _doc;
+  private XmlElement _mjcf;
+
+  [SetUp]
+  public void SetUp() {
+    _settings = new MjJointSettings();
+    _doc = new XmlDocument();
+    _mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+  }
+
+  [Test]
+  public void DampingMjcf() {
+    _settings.Spring.Damping = 5;
+    _settings.Spring.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"damping=""5"""));
+  }
+
+  [Test]
+  public void FrictionLossMjcf() {
+    _settings.Solver.FrictionLoss = 5;
+    _settings.Solver.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"frictionloss=""5"""));
+  }
+
+  [Test]
+  public void StiffnessMjcf() {
+    _settings.Spring.Stiffness = 5;
+    _settings.Spring.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"stiffness=""5"""));
+  }
+
+  [Test]
+  public void SpringDamperSettingsMjcf() {
+    _settings.Spring.TimeConstant = 5;
+    _settings.Spring.DampingRatio = 6;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"springdamper=""5 6"""));
+  }
+
+  [Test]
+  public void SpringEquilibriumPoseMjcf() {
+    _settings.Spring.EquilibriumPose = 5;
+    _settings.Spring.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"springref=""5"""));
+  }
+
+  [Test]
+  public void ArmatureMjcf() {
+    _settings.Armature = 3;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"armature=""3"""));
+  }
+
+  [Test]
+  public void SolverRefLimitMjcf() {
+    _settings.Solver.RefLimit = new SolverReference() { TimeConst = 5, DampRatio = 6 };
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"solreflimit=""5 6"""));
+  }
+
+  [Test]
+  public void SolverImpLimitMjcf() {
+    _settings.Solver.ImpLimit = new SolverImpedance() {
+        DMin = 5, DMax = 6, Width = 7, Midpoint = 8, Power = 9 };
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"solimplimit=""5 6 7 8 9"""));
+  }
+
+  [Test]
+  public void SolverRefFrictionMjcf() {
+    _settings.Solver.RefFriction = new SolverReference() { TimeConst = 5, DampRatio = 6 };
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"solreffriction=""5 6"""));
+  }
+
+  [Test]
+  public void SolverImpFrictionMjcf() {
+    _settings.Solver.ImpFriction = new SolverImpedance() {
+        DMin = 5, DMax = 6, Width = 7, Midpoint = 8, Power = 9 };
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"solimpfriction=""5 6 7 8 9"""));
+  }
+}
+
+[TestFixture]
+public class MjJointSettingsParsingTests {
+
+  private MjJointSettings _settings;
+  private XmlDocument _doc;
+  private XmlElement _mjcf;
+
+  [SetUp]
+  public void SetUp() {
+    _doc = new XmlDocument();
+    _mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    _settings = new MjJointSettings();
+  }
+
+  [Test]
+  public void DampingMjcf() {
+    _mjcf.SetAttribute("damping", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Spring.Damping, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void ArmatureMjcf() {
+    _mjcf.SetAttribute("armature", "3");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Armature, Is.EqualTo(3));
+  }
+
+  [Test]
+  public void FrictionLossMjcf() {
+    _mjcf.SetAttribute("frictionloss", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.FrictionLoss, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void StiffnessMjcf() {
+    _mjcf.SetAttribute("stiffness", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Spring.Stiffness, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void SpringDamperSettingsMjcf() {
+    _mjcf.SetAttribute("springdamper", "5 6");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Spring.TimeConstant, Is.EqualTo(5));
+    Assert.That(_settings.Spring.DampingRatio, Is.EqualTo(6));
+  }
+
+  [Test]
+  public void SpringEquilibriumPoseMjcf() {
+    _mjcf.SetAttribute("springref", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Spring.EquilibriumPose, Is.EqualTo(5));
+  }
+
+  [TestCase("true", true)]
+  [TestCase("false", false)]
+  public void ParsingJointLimitSettings(string setting, bool expected) {
+    _mjcf.SetAttribute("limited", setting);
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.Limited, Is.EqualTo(expected));
+  }
+
+  [TestCase("1", 1)]
+  [TestCase("-5", -5)]
+  public void ParsingJointLimitMarginSettings(string setting, float expected) {
+    _mjcf.SetAttribute("margin", setting);
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.Margin, Is.EqualTo(expected));
+  }
+
+  [Test]
+  public void SolverRefLimitMjcf() {
+    _mjcf.SetAttribute("solreflimit", "5 6");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.RefLimit.TimeConst, Is.EqualTo(5));
+    Assert.That(_settings.Solver.RefLimit.DampRatio, Is.EqualTo(6));
+  }
+
+  [Test]
+  public void SolverImpLimitMjcf() {
+    _mjcf.SetAttribute("solimplimit", "5 6 7 8 9");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.ImpLimit.DMin, Is.EqualTo(5));
+    Assert.That(_settings.Solver.ImpLimit.DMax, Is.EqualTo(6));
+    Assert.That(_settings.Solver.ImpLimit.Width, Is.EqualTo(7));
+    Assert.That(_settings.Solver.ImpLimit.Midpoint, Is.EqualTo(8));
+    Assert.That(_settings.Solver.ImpLimit.Power, Is.EqualTo(9));
+  }
+
+  [Test]
+  public void SolverRefFrictionMjcf() {
+    _mjcf.SetAttribute("solreffriction", "5 6");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.RefFriction.TimeConst, Is.EqualTo(5));
+    Assert.That(_settings.Solver.RefFriction.DampRatio, Is.EqualTo(6));
+  }
+
+  [Test]
+  public void SolverImpFrictionMjcf() {
+    _mjcf.SetAttribute("solimpfriction", "5 6 7 8 9");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.ImpFriction.DMin, Is.EqualTo(5));
+    Assert.That(_settings.Solver.ImpFriction.DMax, Is.EqualTo(6));
+    Assert.That(_settings.Solver.ImpFriction.Width, Is.EqualTo(7));
+    Assert.That(_settings.Solver.ImpFriction.Midpoint, Is.EqualTo(8));
+    Assert.That(_settings.Solver.ImpFriction.Power, Is.EqualTo(9));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Joints/MjJointSettingsTests.cs.meta b/unity/Tests/Editor/components/Joints/MjJointSettingsTests.cs.meta
new file mode 100644
index 00000000..6174560c
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjJointSettingsTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 05670ca69732c47f58a7a6f61510efad
+timeCreated: 1539945962
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Joints/MjSlideJointTests.cs b/unity/Tests/Editor/components/Joints/MjSlideJointTests.cs
new file mode 100644
index 00000000..82c7c2b1
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjSlideJointTests.cs
@@ -0,0 +1,102 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools.Utils;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjSlideJointTests {
+
+  private GameObject _parent;
+  private MjSlideJoint _joint;
+  private XmlDocument _doc;
+  private Vector3EqualityComparer _comparer;
+
+  [SetUp]
+  public void SetUp() {
+    _parent = new GameObject("parent");
+    _joint = new GameObject("joint", typeof(MjSlideJoint)).GetComponent<MjSlideJoint>();
+    _joint.transform.parent = _parent.transform;
+    _doc = new XmlDocument();
+    _comparer = new Vector3EqualityComparer(1e-3f);
+  }
+
+  [TearDown]
+  public void TearDown() {
+    GameObject.DestroyImmediate(_parent);
+  }
+
+  [Test]
+  public void ComponentWorldPositionConvertedToMjCoordinates() {
+    _joint.transform.position = new Vector3(1, 2, 3);
+    _doc.AppendChild(_joint.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"pos=""1 3 2"""));
+  }
+
+  [Test]
+  public void GenerateLimits() {
+    _joint.RangeLower = -20;
+    _joint.RangeUpper = 10;
+    _doc.AppendChild(_joint.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"range=""-20 10"""));
+  }
+
+  [Test]
+  public void TestingAnOffsetAxis() {
+    _joint.transform.rotation =
+        Quaternion.AngleAxis(45.0f, Vector3.up);
+    var element = _joint.GenerateMjcf("name", _doc);
+    Assert.That(element.GetVector3Attribute("axis", Vector3.zero),
+                Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_comparer));
+  }
+
+  [Test]
+  public void ParsingPosition() {
+    var jointElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    jointElement.SetAttribute("pos", "1 2 3");
+    _joint.ParseMjcf(jointElement);
+    Assert.That(_joint.transform.localPosition, Is.EqualTo(new Vector3(1, 3, 2)));
+  }
+
+  [TestCase("1 0 0", 1, 0, 0)]
+  [TestCase("0 1 0", 0, 0, 1)]
+  [TestCase("0 0 1", 0, 1, 0)]
+  public void ParsingTranslatesSlidexisIntoJointRotation(
+      string setting, float rx, float ry, float rz) {
+    var jointElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    jointElement.SetAttribute("axis", setting);
+    _joint.ParseMjcf(jointElement);
+    Assert.That(_joint.SlideAxis, Is.EqualTo(new Vector3(rx, ry, rz)).Using(_comparer));
+  }
+
+  [TestCase("0 10", 0, 10)]
+  [TestCase("-10 0", -10, 0)]
+  [TestCase("-10 10", -10, 10)]
+  public void ParsingJointLimitRangeSettings(
+      string setting, float expectedLow, float expectedHigh) {
+    var jointElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("joint"));
+    jointElement.SetAttribute("range", setting);
+    _joint.ParseMjcf(jointElement);
+    Assert.That(_joint.RangeLower, Is.EqualTo(expectedLow));
+    Assert.That(_joint.RangeUpper, Is.EqualTo(expectedHigh));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Joints/MjSlideJointTests.cs.meta b/unity/Tests/Editor/components/Joints/MjSlideJointTests.cs.meta
new file mode 100644
index 00000000..5418a083
--- /dev/null
+++ b/unity/Tests/Editor/components/Joints/MjSlideJointTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: dffb7c2e3d1504bfd8830b6c511732ef
+timeCreated: 1537806570
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjActuatorTests.cs b/unity/Tests/Editor/components/MjActuatorTests.cs
new file mode 100644
index 00000000..56df521a
--- /dev/null
+++ b/unity/Tests/Editor/components/MjActuatorTests.cs
@@ -0,0 +1,559 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+[TestFixture]
+public class MjActuatorTests {
+  private MjHingeJoint _joint;
+  private MjActuator _actuator;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.name = "my_joint";
+    _actuator = new GameObject("actuator").AddComponent<MjActuator>();
+    _actuator.Joint = _joint;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_actuator.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+  }
+
+  [TestCase(true, "true")]
+  [TestCase(false, "false")]
+  public void ControlLimitedFlagMjcf(bool value, string expected) {
+    _actuator.CommonParams.CtrlLimited = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"ctrllimited=\"{expected}\""));
+  }
+
+  [TestCase(true, "true")]
+  [TestCase(false, "false")]
+  public void ForceLimitedFlagMjcf(bool value, string expected) {
+    _actuator.CommonParams.ForceLimited = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"forcelimited=\"{expected}\""));
+  }
+
+  [TestCase(0, 1, "0 1")]
+  [TestCase(1, 0, "0 1")]
+  public void ControlRangeSortingForMjcf(float min, float max, string expected) {
+    _actuator.CommonParams.CtrlRange = new Vector2(min, max);
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"ctrlrange=\"{expected}\""));
+  }
+
+  [TestCase(0, 1, "0 1")]
+  [TestCase(1, 0, "0 1")]
+  public void ForceRangeSortingForMjcf(float min, float max, string expected) {
+    _actuator.CommonParams.ForceRange = new Vector2(min, max);
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"forcerange=\"{expected}\""));
+  }
+
+  [TestCase(0, 1, "0 1")]
+  [TestCase(1, 0, "0 1")]
+  public void LengthRangeSortingForMjcf(float min, float max, string expected) {
+    _actuator.CommonParams.LengthRange = new Vector2(min, max);
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"lengthrange=\"{expected}\""));
+  }
+
+  [Test]
+  public void GearMjcf() {
+    _actuator.CommonParams.Gear = new List<float>() { 1, 2, 3, 4, 5, 6 };
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"gear=\"1 2 3 4 5 6\""));
+  }
+
+  [Test]
+  public void JointNameMjcf() {
+    _joint.GenerateMjcf("joint_name", _doc);
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"joint=\"joint_name\""));
+  }
+
+  [Test]
+  public void ParseAllSettings() {
+    _doc.LoadXml(
+        "<general joint=\"my_joint\" ctrllimited=\"true\" forcelimited=\"true\" ctrlrange=\"2 3\" "
+        + "forcerange=\"4 5\" lengthrange=\"6 7\" gear=\"8 9\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("general")[0] as XmlElement);
+    Assert.That(_actuator.CommonParams.CtrlLimited, Is.True);
+    Assert.That(_actuator.CommonParams.ForceLimited, Is.True);
+    Assert.That(_actuator.CommonParams.CtrlRange, Is.EqualTo(new Vector2(2, 3)));
+    Assert.That(_actuator.CommonParams.ForceRange, Is.EqualTo(new Vector2(4, 5)));
+    Assert.That(_actuator.CommonParams.LengthRange, Is.EqualTo(new Vector2(6, 7)));
+    Assert.That(_actuator.CommonParams.Gear, Has.Count.EqualTo(2));
+    Assert.That(_actuator.CommonParams.Gear[0], Is.EqualTo(8));
+    Assert.That(_actuator.CommonParams.Gear[1], Is.EqualTo(9));
+  }
+
+  [Test]
+  public void ParseDefaultSettings() {
+    _doc.LoadXml("<general joint=\"my_joint\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("general")[0] as XmlElement);
+    Assert.That(_actuator.CommonParams.CtrlLimited, Is.False);
+    Assert.That(_actuator.CommonParams.ForceLimited, Is.False);
+    Assert.That(_actuator.CommonParams.CtrlRange, Is.EqualTo(Vector2.zero));
+    Assert.That(_actuator.CommonParams.ForceRange, Is.EqualTo(Vector2.zero));
+    Assert.That(_actuator.CommonParams.LengthRange, Is.EqualTo(Vector2.zero));
+    Assert.That(_actuator.CommonParams.Gear, Has.Count.EqualTo(1));
+    Assert.That(_actuator.CommonParams.Gear[0], Is.EqualTo(1));
+  }
+}
+
+[TestFixture]
+public class MjGeneralActuatorTests {
+  private MjHingeJoint _joint;
+  private MjActuator _actuator;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.name = "my_joint";
+    _actuator = new GameObject("actuator").AddComponent<MjActuator>();
+    _actuator.Type = MjActuator.ActuatorType.General;
+    _actuator.Joint = _joint;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_actuator.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+  }
+
+  [Test]
+  public void ProperTagNameUsed() {
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<general"));
+  }
+
+  [TestCase(MujocoLib.mjtDyn.mjDYN_NONE, "none")]
+  [TestCase(MujocoLib.mjtDyn.mjDYN_INTEGRATOR, "integrator")]
+  [TestCase(MujocoLib.mjtDyn.mjDYN_FILTER, "filter")]
+  [TestCase(MujocoLib.mjtDyn.mjDYN_MUSCLE, "muscle")]
+  [TestCase(MujocoLib.mjtDyn.mjDYN_USER, "user")]
+  public void DynamicsTypeMjcf(MujocoLib.mjtDyn value, string expected) {
+    _actuator.CustomParams.DynType = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"dyntype=\"{expected}\""));
+  }
+
+  [TestCase(MujocoLib.mjtGain.mjGAIN_FIXED, "fixed")]
+  [TestCase(MujocoLib.mjtGain.mjGAIN_MUSCLE, "muscle")]
+  [TestCase(MujocoLib.mjtGain.mjGAIN_USER, "user")]
+  public void GainTypeMjcf(MujocoLib.mjtGain value, string expected) {
+    _actuator.CustomParams.GainType = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"gaintype=\"{expected}\""));
+  }
+
+  [TestCase(MujocoLib.mjtBias.mjBIAS_NONE, "none")]
+  [TestCase(MujocoLib.mjtBias.mjBIAS_AFFINE, "affine")]
+  [TestCase(MujocoLib.mjtBias.mjBIAS_MUSCLE, "muscle")]
+  [TestCase(MujocoLib.mjtBias.mjBIAS_USER, "user")]
+  public void BiasTypeMjcf(MujocoLib.mjtBias value, string expected) {
+    _actuator.CustomParams.BiasType = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"biastype=\"{expected}\""));
+  }
+
+  [Test]
+  public void DynamicsParamsMjcf() {
+    _actuator.CustomParams.DynPrm = new List<float>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"dynprm=\"1 2 3 4 5 6 7 8 9 10\""));
+  }
+
+  [Test]
+  public void GainParamsMjcf() {
+    _actuator.CustomParams.GainPrm = new List<float>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"gainprm=\"1 2 3 4 5 6 7 8 9 10\""));
+  }
+
+  [Test]
+  public void BiasParamsMjcf() {
+    _actuator.CustomParams.BiasPrm = new List<float>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"biasprm=\"1 2 3 4 5 6 7 8 9 10\""));
+  }
+
+  [Test]
+  public void ParseAllSettings() {
+    _doc.LoadXml(
+        "<general joint=\"my_joint\" dyntype=\"integrator\" gaintype=\"muscle\" "
+        + "biastype=\"affine\" dynprm=\"6\" gainprm=\"7 8\" biasprm=\"9 10 11 12\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("general")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.DynType, Is.EqualTo(MujocoLib.mjtDyn.mjDYN_INTEGRATOR));
+    Assert.That(_actuator.CustomParams.GainType, Is.EqualTo(MujocoLib.mjtGain.mjGAIN_MUSCLE));
+    Assert.That(_actuator.CustomParams.BiasType, Is.EqualTo(MujocoLib.mjtBias.mjBIAS_AFFINE));
+    Assert.That(_actuator.CustomParams.DynPrm, Has.Count.EqualTo(3));
+    Assert.That(_actuator.CustomParams.GainPrm, Has.Count.EqualTo(3));
+    Assert.That(_actuator.CustomParams.BiasPrm, Has.Count.EqualTo(4));
+    Assert.That(_actuator.CustomParams.DynPrm[0], Is.EqualTo(6));
+    Assert.That(_actuator.CustomParams.DynPrm[1], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.DynPrm[2], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.GainPrm[0], Is.EqualTo(7));
+    Assert.That(_actuator.CustomParams.GainPrm[1], Is.EqualTo(8));
+    Assert.That(_actuator.CustomParams.GainPrm[2], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.BiasPrm[0], Is.EqualTo(9));
+    Assert.That(_actuator.CustomParams.BiasPrm[1], Is.EqualTo(10));
+    Assert.That(_actuator.CustomParams.BiasPrm[2], Is.EqualTo(11));
+    Assert.That(_actuator.CustomParams.BiasPrm[3], Is.EqualTo(12));
+  }
+
+  [Test]
+  public void ParseDefaultSettings() {
+    _doc.LoadXml("<general joint=\"my_joint\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("general")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.DynType, Is.EqualTo(MujocoLib.mjtDyn.mjDYN_NONE));
+    Assert.That(_actuator.CustomParams.GainType, Is.EqualTo(MujocoLib.mjtGain.mjGAIN_FIXED));
+    Assert.That(_actuator.CustomParams.BiasType, Is.EqualTo(MujocoLib.mjtBias.mjBIAS_NONE));
+    Assert.That(_actuator.CustomParams.DynPrm, Has.Count.EqualTo(3));
+    Assert.That(_actuator.CustomParams.GainPrm, Has.Count.EqualTo(3));
+    Assert.That(_actuator.CustomParams.BiasPrm, Has.Count.EqualTo(3));
+    Assert.That(_actuator.CustomParams.DynPrm[0], Is.EqualTo(1));
+    Assert.That(_actuator.CustomParams.DynPrm[1], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.DynPrm[2], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.GainPrm[0], Is.EqualTo(1));
+    Assert.That(_actuator.CustomParams.GainPrm[1], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.GainPrm[2], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.BiasPrm[0], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.BiasPrm[1], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.BiasPrm[2], Is.EqualTo(0));
+  }
+}
+
+[TestFixture]
+public class MjPositionActuatorTests {
+  private MjHingeJoint _joint;
+  private MjActuator _actuator;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.name = "my_joint";
+    _actuator = new GameObject("actuator").AddComponent<MjActuator>();
+    _actuator.Type = MjActuator.ActuatorType.Position;
+    _actuator.Joint = _joint;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_actuator.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+  }
+
+  [Test]
+  public void ProperTagNameUsed() {
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<position"));
+  }
+
+  [TestCase(3, "3")]
+  [TestCase(-2, "2")]
+  public void BiasParamsMjcf(float value, string expected) {
+    _actuator.CustomParams.Kp = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"kp=\"{expected}\""));
+  }
+
+  [Test]
+  public void ParseAllSettings() {
+    _doc.LoadXml("<position joint=\"my_joint\" kp=\"2\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("position")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.Kp, Is.EqualTo(2));
+  }
+
+  [Test]
+  public void ParseDefaultSettings() {
+    _doc.LoadXml("<position joint=\"my_joint\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("position")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.Kp, Is.EqualTo(1));
+  }
+}
+
+[TestFixture]
+public class MjVelocityActuatorTests {
+  private MjHingeJoint _joint;
+  private MjActuator _actuator;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.name = "my_joint";
+    _actuator = new GameObject("actuator").AddComponent<MjActuator>();
+    _actuator.Type = MjActuator.ActuatorType.Velocity;
+    _actuator.Joint = _joint;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_actuator.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+  }
+
+  [Test]
+  public void ProperTagNameUsed() {
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<velocity"));
+  }
+
+  [TestCase(3, "3")]
+  [TestCase(-2, "2")]
+  public void BiasParamsMjcf(float value, string expected) {
+    _actuator.CustomParams.Kv = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"kv=\"{expected}\""));
+  }
+
+  [Test]
+  public void ParseAllSettings() {
+    _doc.LoadXml("<velocity joint=\"my_joint\" kv=\"2\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("velocity")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.Kv, Is.EqualTo(2));
+  }
+
+  [Test]
+  public void ParseDefaultSettings() {
+    _doc.LoadXml("<velocity joint=\"my_joint\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("velocity")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.Kv, Is.EqualTo(1));
+  }
+}
+
+[TestFixture]
+public class MjCylinderActuatorTests {
+  private MjHingeJoint _joint;
+  private MjActuator _actuator;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.name = "my_joint";
+    _actuator = new GameObject("actuator").AddComponent<MjActuator>();
+    _actuator.Type = MjActuator.ActuatorType.Cylinder;
+    _actuator.Joint = _joint;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_actuator.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+  }
+
+  [Test]
+  public void ProperTagNameUsed() {
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<cylinder"));
+  }
+
+  [Test]
+  public void TimeConstantMjcf() {
+    _actuator.CustomParams.CylinderTimeConst = 2.0f;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"timeconst=\"2\""));
+  }
+
+  [TestCase(3, "3")]
+  [TestCase(-2, "2")]
+  public void AreaMjcf(float value, string expected) {
+    _actuator.CustomParams.Area = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"area=\"{expected}\""));
+  }
+
+  [TestCase(3, "3")]
+  [TestCase(-2, "2")]
+  public void DiameterMjcf(float value, string expected) {
+    _actuator.CustomParams.Diameter = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"diameter=\"{expected}\""));
+  }
+
+  [Test]
+  public void BiasMjcf() {
+    _actuator.CustomParams.Bias = new float[] { 1, 2, 3 };
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"bias=\"1 2 3\""));
+  }
+
+  [Test]
+  public void ParseAllSettings() {
+    _doc.LoadXml("<cylinder joint=\"my_joint\" timeconst=\"1\" area =\"2\" diameter=\"3\" "
+                 + "bias=\"4 5\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("cylinder")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.CylinderTimeConst, Is.EqualTo(1));
+    Assert.That(_actuator.CustomParams.Area, Is.EqualTo(2));
+    Assert.That(_actuator.CustomParams.Diameter, Is.EqualTo(3));
+    Assert.That(_actuator.CustomParams.Bias, Has.Length.EqualTo(3));
+    Assert.That(_actuator.CustomParams.Bias[0], Is.EqualTo(4));
+    Assert.That(_actuator.CustomParams.Bias[1], Is.EqualTo(5));
+    Assert.That(_actuator.CustomParams.Bias[2], Is.EqualTo(0));
+  }
+
+  [Test]
+  public void ParseDefaultSettings() {
+    _doc.LoadXml("<cylinder joint=\"my_joint\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("cylinder")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.CylinderTimeConst, Is.EqualTo(1));
+    Assert.That(_actuator.CustomParams.Area, Is.EqualTo(1));
+    Assert.That(_actuator.CustomParams.Diameter, Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.Bias, Has.Length.EqualTo(3));
+    Assert.That(_actuator.CustomParams.Bias[0], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.Bias[1], Is.EqualTo(0));
+    Assert.That(_actuator.CustomParams.Bias[2], Is.EqualTo(0));
+  }
+}
+
+[TestFixture]
+public class MjMuscleActuatorTests {
+  private MjHingeJoint _joint;
+  private MjActuator _actuator;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.name = "my_joint";
+    _actuator = new GameObject("actuator").AddComponent<MjActuator>();
+    _actuator.Type = MjActuator.ActuatorType.Muscle;
+    _actuator.Joint = _joint;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_actuator.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+  }
+
+  [Test]
+  public void ProperTagNameUsed() {
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<muscle"));
+  }
+
+  [Test]
+  public void TimeConstantMjcf() {
+    _actuator.CustomParams.MuscleTimeConst = new Vector2(1, 2);
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"timeconst=\"1 2\""));
+  }
+
+  [TestCase(1, 2, "1 2")]
+  [TestCase(2, 1, "1 2")]
+  public void RangeMjcf(float x, float y, string expected) {
+    _actuator.CustomParams.Range = new Vector2(x, y);
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"range=\"{expected}\""));
+  }
+
+  [TestCase(-2, "-2")]
+  [TestCase(2, "2")]
+  public void ForceMjcf(float value, string expected) {
+    _actuator.CustomParams.Force = value;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"force=\"{expected}\""));
+  }
+
+  [Test]
+  public void LMinMjcf() {
+    _actuator.CustomParams.LMin = 2.0f;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"lmin=\"2\""));
+  }
+
+  [Test]
+  public void LMaxMjcf() {
+    _actuator.CustomParams.LMin = 3.0f;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"lmin=\"3\""));
+  }
+
+  [Test]
+  public void VMaxMjcf() {
+    _actuator.CustomParams.VMax = 4.0f;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"vmax=\"4\""));
+  }
+
+  [Test]
+  public void FpMaxMjcf() {
+    _actuator.CustomParams.FpMax = 5.0f;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"fpmax=\"5\""));
+  }
+
+  [Test]
+  public void FvMaxMjcf() {
+    _actuator.CustomParams.FvMax = 6.0f;
+    _doc.AppendChild(_actuator.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"fvmax=\"6\""));
+  }
+
+  [Test]
+  public void ParseAllSettings() {
+    _doc.LoadXml(
+        "<muscle joint=\"my_joint\" timeconst=\"1 2\" range =\"3 4\" force=\"5\" scale=\"6\" "
+        + "lmin=\"7\" lmax=\"8\" vmax=\"9\" fpmax=\"10\" fvmax=\"11\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("muscle")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.MuscleTimeConst, Is.EqualTo(new Vector2(1, 2)));
+    Assert.That(_actuator.CustomParams.Range, Is.EqualTo(new Vector2(3, 4)));
+    Assert.That(_actuator.CustomParams.Force, Is.EqualTo(5));
+    Assert.That(_actuator.CustomParams.Scale, Is.EqualTo(6));
+    Assert.That(_actuator.CustomParams.LMin, Is.EqualTo(7));
+    Assert.That(_actuator.CustomParams.LMax, Is.EqualTo(8));
+    Assert.That(_actuator.CustomParams.VMax, Is.EqualTo(9));
+    Assert.That(_actuator.CustomParams.FpMax, Is.EqualTo(10));
+    Assert.That(_actuator.CustomParams.FvMax, Is.EqualTo(11));
+  }
+
+  [Test]
+  public void ParseDefaultSettings() {
+    _doc.LoadXml("<muscle joint=\"my_joint\"/>");
+    _actuator.ParseMjcf(_doc.GetElementsByTagName("muscle")[0] as XmlElement);
+    Assert.That(_actuator.CustomParams.MuscleTimeConst, Is.EqualTo(new Vector2(0.01f, 0.04f)));
+    Assert.That(_actuator.CustomParams.Range, Is.EqualTo(new Vector2(0.75f, 1.05f)));
+    Assert.That(_actuator.CustomParams.Force, Is.EqualTo(-1));
+    Assert.That(_actuator.CustomParams.Scale, Is.EqualTo(200));
+    Assert.That(_actuator.CustomParams.LMin, Is.EqualTo(0.5f));
+    Assert.That(_actuator.CustomParams.LMax, Is.EqualTo(1.6f));
+    Assert.That(_actuator.CustomParams.VMax, Is.EqualTo(1.5f));
+    Assert.That(_actuator.CustomParams.FpMax, Is.EqualTo(1.3f));
+    Assert.That(_actuator.CustomParams.FvMax, Is.EqualTo(1.2f));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/MjActuatorTests.cs.meta b/unity/Tests/Editor/components/MjActuatorTests.cs.meta
new file mode 100644
index 00000000..df0849b9
--- /dev/null
+++ b/unity/Tests/Editor/components/MjActuatorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: f9f410f3cddf84133a9db8a7226af54f
+timeCreated: 1547033205
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjExcludeTests.cs b/unity/Tests/Editor/components/MjExcludeTests.cs
new file mode 100644
index 00000000..b7b1ce5a
--- /dev/null
+++ b/unity/Tests/Editor/components/MjExcludeTests.cs
@@ -0,0 +1,54 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+[TestFixture]
+public class MjExcludeTests {
+  private MjBody _body1;
+  private MjBody _body2;
+  private MjExclude _exclude;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _body1 = new GameObject("body1").AddComponent<MjBody>();
+    _body2 = new GameObject("body2").AddComponent<MjBody>();
+    _exclude = new GameObject("exclude").AddComponent<MjExclude>();
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_exclude.gameObject);
+    UnityEngine.Object.DestroyImmediate(_body1.gameObject);
+    UnityEngine.Object.DestroyImmediate(_body2.gameObject);
+  }
+
+  [Test]
+  public void ParseAllSettings() {
+    _doc.LoadXml(
+        "<exclude body1='body1' body2='body2'/>");
+    _exclude.ParseMjcf(_doc.GetElementsByTagName("exclude")[0] as XmlElement);
+    Assert.That(_exclude.Body1, Is.EqualTo(_body1));
+    Assert.That(_exclude.Body2, Is.EqualTo(_body2));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/MjExcludeTests.cs.meta b/unity/Tests/Editor/components/MjExcludeTests.cs.meta
new file mode 100644
index 00000000..ed2550e2
--- /dev/null
+++ b/unity/Tests/Editor/components/MjExcludeTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0b6ccb511e4d84261942206958dd2c73
+timeCreated: 1550588347
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjGeomSettingsTests.cs b/unity/Tests/Editor/components/MjGeomSettingsTests.cs
new file mode 100644
index 00000000..56471eab
--- /dev/null
+++ b/unity/Tests/Editor/components/MjGeomSettingsTests.cs
@@ -0,0 +1,203 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjGeomSettingsGenerationTests {
+
+  private MjGeomSettings _settings;
+  private XmlDocument _doc;
+  private XmlElement _mjcf;
+
+  [SetUp]
+  public void SetUp() {
+    _settings = new MjGeomSettings();
+    _doc = new XmlDocument();
+    _mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+  }
+
+  [Test]
+  public void ContactFilteringTypeMjcf() {
+    _settings.Filtering.Contype = 5;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"contype=""5"""));
+  }
+
+  [Test]
+  public void ContactFilteringAffinityMjcf() {
+    _settings.Filtering.Conaffinity = 5;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"conaffinity=""5"""));
+  }
+
+  [Test]
+  public void ContactFilteringGroupMjcf() {
+    _settings.Filtering.Group = 5;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"group=""5"""));
+  }
+
+  [Test]
+  public void SolverContactDimensionalityMjcf() {
+    _settings.Solver.ConDim = 5;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"condim=""5"""));
+  }
+
+  [Test]
+  public void SolverMixMjcf() {
+    _settings.Solver.SolMix = 5;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"solmix=""5"""));
+  }
+
+  [Test]
+  public void SolverReferenceMjcf() {
+    _settings.Solver.SolRef.TimeConst = 5;
+    _settings.Solver.SolRef.DampRatio = 6;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"solref=""5 6"""));
+  }
+
+  [Test]
+  public void SolverImpendanceMjcf() {
+    _settings.Solver.SolImp.DMin = 5;
+    _settings.Solver.SolImp.DMax = 6;
+    _settings.Solver.SolImp.Width = 7;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"solimp=""5 6 7"""));
+  }
+
+  [Test]
+  public void SolverMarginMjcf() {
+    _settings.Solver.Margin = 5;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"margin=""5"""));
+  }
+
+  [Test]
+  public void SolverGapMjcf() {
+    _settings.Solver.Gap = 5;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"gap=""5"""));
+  }
+
+  [Test]
+  public void MaterialFrictionMjcf() {
+    _settings.Friction.Sliding = 5;
+    _settings.Friction.Torsional = 6;
+    _settings.Friction.Rolling = 7;
+    _settings.ToMjcf(_mjcf);
+    Assert.That(_doc.OuterXml, Does.Contain(@"friction=""5 6 7"""));
+  }
+}
+
+[TestFixture]
+public class MjGeomSettingsParsingTests {
+
+  private MjGeomSettings _settings;
+  private XmlDocument _doc;
+  private XmlElement _mjcf;
+
+  [SetUp]
+  public void SetUp() {
+    _doc = new XmlDocument();
+    _mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    _settings = new MjGeomSettings();
+  }
+
+  [Test]
+  public void ContactFilteringTypeMjcf() {
+    _mjcf.SetAttribute("contype", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Filtering.Contype, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void ContactFilteringAffinityMjcf() {
+    _mjcf.SetAttribute("conaffinity", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Filtering.Conaffinity, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void ContactFilteringGroupMjcf() {
+    _mjcf.SetAttribute("group", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Filtering.Group, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void SolverContactDimensionalityMjcf() {
+    _mjcf.SetAttribute("condim", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.ConDim, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void SolverMixMjcf() {
+    _mjcf.SetAttribute("solmix", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.SolMix, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void SolverReferenceMjcf() {
+    _mjcf.SetAttribute("solref", "5 6");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.SolRef.TimeConst, Is.EqualTo(5));
+    Assert.That(_settings.Solver.SolRef.DampRatio, Is.EqualTo(6));
+  }
+
+  [Test]
+  public void SolverImpendanceMjcf() {
+    _mjcf.SetAttribute("solimp", "5 6 7");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.SolImp.DMin, Is.EqualTo(5));
+    Assert.That(_settings.Solver.SolImp.DMax, Is.EqualTo(6));
+    Assert.That(_settings.Solver.SolImp.Width, Is.EqualTo(7));
+  }
+
+  [Test]
+  public void SolverMarginMjcf() {
+    _mjcf.SetAttribute("margin", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.Margin, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void SolverGapMjcf() {
+    _mjcf.SetAttribute("gap", "5");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Solver.Gap, Is.EqualTo(5));
+  }
+
+  [Test]
+  public void MaterialFrictionMjcf() {
+    _mjcf.SetAttribute("friction", "5 6 7");
+    _settings.FromMjcf(_mjcf);
+    Assert.That(_settings.Friction.Sliding, Is.EqualTo(5));
+    Assert.That(_settings.Friction.Torsional, Is.EqualTo(6));
+    Assert.That(_settings.Friction.Rolling, Is.EqualTo(7));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/MjGeomSettingsTests.cs.meta b/unity/Tests/Editor/components/MjGeomSettingsTests.cs.meta
new file mode 100644
index 00000000..a51848ef
--- /dev/null
+++ b/unity/Tests/Editor/components/MjGeomSettingsTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 83a2b8f3a6ff24e15ac22ec387fe57fc
+timeCreated: 1539945962
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjGeomTests.cs b/unity/Tests/Editor/components/MjGeomTests.cs
new file mode 100644
index 00000000..eb8cbb14
--- /dev/null
+++ b/unity/Tests/Editor/components/MjGeomTests.cs
@@ -0,0 +1,207 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjGeomTransformTests {
+
+  private GameObject _parent;
+  private MjGeom _geom;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _parent = new GameObject("parent");
+    _geom = new GameObject("geom", typeof(MjGeom)).GetComponent<MjGeom>();
+    _geom.transform.parent = _parent.transform;
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_geom.gameObject);
+    UnityEngine.Object.DestroyImmediate(_parent);
+  }
+
+  [Test]
+  public void WorldPositionToMjCoordinates() {
+    _geom.transform.position = new Vector3(1, 2, 3);
+    _doc.AppendChild(_geom.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"pos=""1 3 2"""));
+  }
+
+  [Test]
+  public void WorldRotationToMjCoordinates() {
+    _geom.transform.rotation = Quaternion.AngleAxis(45.0f, Vector3.up);
+    _doc.AppendChild(_geom.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"quat=""-0.9238795 0 0 0.3826835"""));
+  }
+
+  [Test]
+  public void BodyRelativePositionUsedInMjcf() {
+    _parent.transform.position = new Vector3(1, 2, 3);
+    _parent.transform.rotation = Quaternion.AngleAxis(45.0f, (new Vector3(1, 2, 3)).normalized);
+    _doc.AppendChild(_geom.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"pos=""1 3 2"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"quat=""-0.9238795 0.1022765 0.3068294 0.2045529"""));
+  }
+
+  [Test]
+  public void LocalPositionParsing() {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    geomElement.SetAttribute("pos", "1 2 3");
+    _geom.ParseMjcf(geomElement);
+    Assert.That(_geom.transform.localPosition, Is.EqualTo(new Vector3(1, 3, 2)));
+  }
+
+  [TestCase(0.866f, 0.5f, 0, 0, 0.5f, 0, 0, -0.866f)]
+  [TestCase(0.866f, 0, 0.5f, 0, 0, 0, 0.5f, -0.866f)]
+  [TestCase(0.866f, 0, 0, 0.5f, 0, 0.5f, 0, -0.866f)]
+  [TestCase(0, 0.866f, 0.5f, 0, 0.866f, 0, 0.5f, 0)]
+  [TestCase(0, 0.866f, 0, 0.5f, 0.866f, 0.5f, 0, 0)]
+  [TestCase(0, 0, 0.866f, 0.5f, 0, 0.5f, 0.866f, 0)]
+  public void BodyLocalRotationParsing(
+      float ix, float iy, float iz, float iw, float ex, float ey, float ez, float ew) {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    geomElement.SetAttribute("quat", $"{ix} {iy} {iz} {iw}");
+    _geom.ParseMjcf(geomElement);
+    var angle = Quaternion.Angle(_geom.transform.localRotation, new Quaternion(ex, ey, ez, ew));
+    Assert.That(angle, Is.EqualTo(0).Within(3));
+  }
+
+  [TestCase("0 0 0 0 0 1", 0, 0, 0, 1)]
+  [TestCase("0 0 0 0 1 0", 0.707f, 0, 0, 0.707f)]
+  [TestCase("0 0 0 1 0 0", 0, 0, -0.707f, 0.707f)]
+  [TestCase("1 0 0 0 0 0", 0, 0, 0.707f, 0.707f)]
+  [TestCase("0 1 0 0 0 0", -0.707f, 0, 0, 0.707f)]
+  [TestCase("0 0 1 0 0 0", 1, 0, 0, 0)]
+  [TestCase("1 0 0 0 0 1", 0, 0, 0.382f, 0.924f)]
+  [TestCase("1 0 0 0 1 0", 0.5f, 0, 0.5f, 0.707f)]
+  public void OrientationSpecifiedUsingFromToParameterIsTheDirectionOfFromToVector(
+      string input, float ex, float ey, float ez, float ew) {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    geomElement.SetAttribute("type", "box");
+    geomElement.SetAttribute("fromto", input);
+    _geom.ParseMjcf(geomElement);
+    var angle = Quaternion.Angle(_geom.transform.localRotation, new Quaternion(ex, ey, ez, ew));
+    Assert.That(angle, Is.EqualTo(0).Within(3));
+  }
+
+  [TestCase("0 0 0 0 0 1", 0)]
+  [TestCase("0 0 0 0 0.01 1", 0.573f)]
+  [TestCase("0 0 0 0 -0.01 1", 0.573f)]
+  [TestCase("0 0 0 0 0 -1", 180)]
+  [TestCase("0 0 0 0 0.01 -1", 179.427f)]
+  [TestCase("0 0 0 0 -0.01 -1", 179.427f)]
+  public void TestingFromToRotationsAroundThePoles(string input, float expectedAngle) {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    geomElement.SetAttribute("type", "box");
+    geomElement.SetAttribute("fromto", input);
+    _geom.ParseMjcf(geomElement);
+    var transformedForward = _geom.transform.localRotation * Vector3.forward;
+    var angle = Vector3.Angle(transformedForward, Vector3.forward);
+    Assert.That(angle, Is.EqualTo(expectedAngle).Within(1e-3f));
+  }
+
+  [TestCase("0 0 0 0 0 1", 0, 0.5f, 0)]
+  [TestCase("0 0 0 0 1 0", 0, 0, 0.5f)]
+  [TestCase("0 0 0 1 0 0", 0.5f, 0, 0)]
+  [TestCase("1 0 0 0 0 1", 0.5f, 0.5f, 0)]
+  [TestCase("0 1 0 0 0 1", 0, 0.5f, 0.5f)]
+  [TestCase("0 1 0 0 0 1", 0, 0.5f, 0.5f)]
+  public void PositionSpecifiedUsingFromToParameterIsMiddleOfFromToSegment(
+      string input, float x, float y, float z) {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    geomElement.SetAttribute("type", "box");
+    geomElement.SetAttribute("fromto", input);
+    _geom.ParseMjcf(geomElement);
+    Assert.That(_geom.transform.localPosition, Is.EqualTo(new Vector3(x, y, z)));
+  }
+
+  [TestCase("0 0 1", 0, 0, 0, 1)]
+  [TestCase("0 1 0", 0.707f, 0, 0, 0.707f)]
+  [TestCase("1 0 0", 0, 0, -0.707f, 0.707f)]
+  public void ZAxisParameterSpecifiesForwardVectorOfGeom(
+      string input, float ex, float ey, float ez, float ew) {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    geomElement.SetAttribute("zaxis", input);
+    _geom.ParseMjcf(geomElement);
+    var angle = Quaternion.Angle(_geom.transform.localRotation, new Quaternion(ex, ey, ez, ew));
+    Assert.That(angle, Is.EqualTo(0).Within(3));
+  }
+
+  [TestCase("0 0 90", 0, 0.707f, 0, 0.707f)]
+  [TestCase("0 90 0", 0, 0, -0.707f, 0.707f)]
+  [TestCase("90 0 0", 0.707f, 0, 0, 0.707f)]
+  [TestCase("0 0 45", 0, 0.382f, 0, 0.924f)]
+  [TestCase("0 45 0", 0, 0, -0.382f, 0.924f)]
+  [TestCase("45 0 0", 0.382f, 0, 0, 0.924f)]
+  public void UsingEulerAnglesToSpecifyRotation(
+      string input, float ex, float ey, float ez, float ew) {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    geomElement.SetAttribute("euler", input);
+    _geom.ParseMjcf(geomElement);
+    var angle = Quaternion.Angle(_geom.transform.localRotation, new Quaternion(ex, ey, ez, ew));
+    Assert.That(angle, Is.EqualTo(0).Within(3));
+  }
+
+  [Test]
+  public void NoRotationSpecificationSetsIdentityRotation() {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    _geom.ParseMjcf(geomElement);
+    Assert.That(_geom.transform.localRotation, Is.EqualTo(Quaternion.identity));
+  }
+}
+
+[TestFixture]
+public class MjGeomPropertiesSerializingTests {
+
+  private MjGeom _geom;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _geom = new GameObject("geom", typeof(MjGeom)).GetComponent<MjGeom>();
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_geom.gameObject);
+  }
+
+  [Test]
+  public void MaterialDensityMjcf() {
+    _geom.Density = 5;
+    _doc.AppendChild(_geom.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain(@"density=""5"""));
+  }
+
+  [Test]
+  public void MaterialDensityParsing() {
+    var geomElement = (XmlElement)_doc.AppendChild(_doc.CreateElement("geom"));
+    geomElement.SetAttribute("density", "5.2");
+    _geom.ParseMjcf(geomElement);
+    Assert.That(_geom.Density, Is.EqualTo(5.2f));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/MjGeomTests.cs.meta b/unity/Tests/Editor/components/MjGeomTests.cs.meta
new file mode 100644
index 00000000..c56f87fb
--- /dev/null
+++ b/unity/Tests/Editor/components/MjGeomTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 626fcf7698e8e484eb8c1f0c2399947d
+timeCreated: 1537258560
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjGlobalSettingsTests.cs b/unity/Tests/Editor/components/MjGlobalSettingsTests.cs
new file mode 100644
index 00000000..308e1333
--- /dev/null
+++ b/unity/Tests/Editor/components/MjGlobalSettingsTests.cs
@@ -0,0 +1,197 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjGlobalSettingsGenerationTests {
+
+  private MjGlobalSettings _settings;
+  private XmlDocument _doc;
+  private XmlElement _option;
+  private XmlElement _size;
+
+  [SetUp]
+  public void SetUp() {
+    _settings = new GameObject("settings").AddComponent<MjGlobalSettings>();
+    _doc = new XmlDocument();
+    var root = (XmlElement)_doc.AppendChild(_doc.CreateElement("root"));
+    _option = (XmlElement)root.AppendChild(_doc.CreateElement("option"));
+    _size = (XmlElement)root.AppendChild(_doc.CreateElement("size"));
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_settings.gameObject);
+  }
+
+  [Test]
+  public void GenerateOptionAndSize() {
+    _settings.GlobalOptions.ImpRatio = 1.2f;
+    _settings.GlobalOptions.Magnetic = new Vector3(3.4f, 4.5f, 5.6f);
+    _settings.GlobalOptions.Wind = new Vector3(6.7f, 7.8f, 8.9f);
+    _settings.GlobalOptions.Density = 0.1f;
+    _settings.GlobalOptions.Viscosity = 2.3f;
+    _settings.GlobalOptions.OverrideMargin = 4.5f;
+    _settings.GlobalOptions.Integrator = IntegratorType.RK4;
+    _settings.GlobalOptions.Cone = FrictionConeType.elliptic;
+    _settings.GlobalOptions.Jacobian = JacobianType.dense;
+    _settings.GlobalOptions.Solver = ConstraintSolverType.PGS;
+    _settings.GlobalOptions.Iterations = 12;
+    _settings.GlobalOptions.Tolerance = 3.4f;
+    _settings.GlobalOptions.NoSlipIterations = 5;
+    _settings.GlobalOptions.NoSlipTolerance = 6.7f;
+    _settings.GlobalOptions.MprIterations = 8;
+    _settings.GlobalOptions.MprTolerance = 0.9f;
+    _settings.GlobalSizes.Nconmax = 321;
+
+    _settings.OptionSizeToMjcf(_option, _size);
+    Assert.That(_doc.OuterXml, Does.Contain(@"impratio=""1.2"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"magnetic=""3.4 4.5 5.6"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"wind=""6.7 7.8 8.9"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"density=""0.1"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"viscosity=""2.3"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"o_margin=""4.5"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"integrator=""RK4"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"cone=""elliptic"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"collision=""all"""));  // the default value.
+    Assert.That(_doc.OuterXml, Does.Contain(@"jacobian=""dense"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"o_solref="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"o_solimp="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"solver=""PGS"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"iterations=""12"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"tolerance=""3.4"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"noslip_iterations=""5"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"noslip_tolerance=""6.7"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"mpr_iterations=""8"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"mpr_tolerance=""0.9"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"nconmax=""321"""));
+  }
+
+  [Test]
+  public void GenerateFlag() {
+    _settings.GlobalOptions.Flag.Gravity = EnableDisableFlag.disable;
+    _settings.OptionSizeToMjcf(_option, _size);
+    Assert.That(_doc.OuterXml, Does.Contain(@"gravity=""disable"""));
+    Assert.That(_doc.OuterXml, Does.Contain(@"constraint="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"equality="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"frictionloss="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"limit="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"contact="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"passive="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"clampctrl="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"warmstart="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"filterparent="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"actuation="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"refsafe="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"override="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"energy="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"fwdinv="));
+    Assert.That(_doc.OuterXml, Does.Contain(@"sensornoise="));
+  }
+}
+
+[TestFixture]
+public class MjGlobalSettingsParsingTests {
+
+  private MjGlobalSettings _settings;
+  private XmlElement _option;
+  private XmlElement _size;
+  private XmlElement _flag;
+
+  [SetUp]
+  public void SetUp() {
+    _settings = new GameObject("settings").AddComponent<MjGlobalSettings>();
+    var doc = new XmlDocument();
+    var root = (XmlElement)doc.AppendChild(doc.CreateElement("root"));
+    _option = (XmlElement)root.AppendChild(doc.CreateElement("option"));
+    _size = (XmlElement)root.AppendChild(doc.CreateElement("size"));
+    _flag = (XmlElement)_option.AppendChild(doc.CreateElement("flag"));
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_settings.gameObject);
+  }
+
+  [Test]
+  public void ParseSizeOptionAndFlag() {
+    _option.SetAttribute("impratio", "1.2");
+    _option.SetAttribute("magnetic", "3.4 4.5 5.6");
+    _option.SetAttribute("wind", "6.7 7.8 8.9");
+    _option.SetAttribute("density", "0.1");
+    _option.SetAttribute("viscosity", "2.3");
+    _option.SetAttribute("o_margin", "4.5");
+    _option.SetAttribute("integrator", "RK4");
+    _option.SetAttribute("cone", "elliptic");
+    _option.SetAttribute("collisionchecktype", "all");
+    _option.SetAttribute("jacobian", "dense");
+    _option.SetAttribute("solver", "PGS");
+    _option.SetAttribute("iterations", "12");
+    _option.SetAttribute("tolerance", "3.4");
+    _option.SetAttribute("noslip_iterations", "5");
+    _option.SetAttribute("noslip_tolerance", "6.7");
+    _option.SetAttribute("mpr_iterations", "8");
+    _option.SetAttribute("mpr_tolerance", "0.9");
+
+    _flag.SetAttribute("gravity", "disable");
+
+    _size.SetAttribute("nconmax", "432");
+
+    _settings.ParseOptionSizeMjcf(_option, _size);
+    Assert.That(_settings.GlobalOptions.ImpRatio, Is.EqualTo(1.2f));
+    Assert.That(_settings.GlobalOptions.Magnetic, Is.EqualTo(new Vector3(3.4f, 4.5f, 5.6f)));
+    Assert.That(_settings.GlobalOptions.Wind, Is.EqualTo(new Vector3(6.7f, 7.8f, 8.9f)));
+    Assert.That(_settings.GlobalOptions.Density, Is.EqualTo(0.1f));
+    Assert.That(_settings.GlobalOptions.Viscosity, Is.EqualTo(2.3f));
+    Assert.That(_settings.GlobalOptions.OverrideMargin, Is.EqualTo(4.5f));
+    Assert.That(_settings.GlobalOptions.Integrator, Is.EqualTo(IntegratorType.RK4));
+    Assert.That(_settings.GlobalOptions.Cone, Is.EqualTo(FrictionConeType.elliptic));
+    Assert.That(_settings.GlobalOptions.Jacobian, Is.EqualTo(JacobianType.dense));
+    Assert.That(_settings.GlobalOptions.Solver, Is.EqualTo(ConstraintSolverType.PGS));
+    Assert.That(_settings.GlobalOptions.Iterations, Is.EqualTo(12));
+    Assert.That(_settings.GlobalOptions.Tolerance, Is.EqualTo(3.4f));
+    Assert.That(_settings.GlobalOptions.NoSlipIterations, Is.EqualTo(5));
+    Assert.That(_settings.GlobalOptions.NoSlipTolerance, Is.EqualTo(6.7f));
+    Assert.That(_settings.GlobalOptions.MprIterations, Is.EqualTo(8));
+    Assert.That(_settings.GlobalOptions.MprTolerance, Is.EqualTo(0.9f));
+
+    Assert.That(_settings.GlobalOptions.Flag.Gravity, Is.EqualTo(EnableDisableFlag.disable));
+
+    Assert.That(_settings.GlobalSizes.Nconmax, Is.EqualTo(432));
+    // these statements shouldn't fail:
+    _settings.ParseOptionSizeMjcf(_option, null);
+    _settings.ParseOptionSizeMjcf(null, _size);
+  }
+
+  [Test]
+  public void AvoidMultipleFlagClauses() {
+    var doubleFlagXML = @"<option>
+      <flag/> <flag/>
+      </option>";
+    var doc = new XmlDocument();
+    doc.LoadXml(doubleFlagXML);
+    Assert.That(
+        () => { _settings.ParseOptionSizeMjcf(doc.DocumentElement, null); },
+        Throws.ArgumentException);
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/MjGlobalSettingsTests.cs.meta b/unity/Tests/Editor/components/MjGlobalSettingsTests.cs.meta
new file mode 100644
index 00000000..e74854ff
--- /dev/null
+++ b/unity/Tests/Editor/components/MjGlobalSettingsTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 57b08bea18fda4c70a99bc636a13c1f2
+timeCreated: 1548950233
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjInertialTests.cs b/unity/Tests/Editor/components/MjInertialTests.cs
new file mode 100644
index 00000000..037604c8
--- /dev/null
+++ b/unity/Tests/Editor/components/MjInertialTests.cs
@@ -0,0 +1,57 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjInertialTests {
+  private MjInertial _inertial;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _inertial = new GameObject("inertial").AddComponent<MjInertial>();
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_inertial.gameObject);
+  }
+
+  [Test]
+  public void ParseAllSettings() {
+    _doc.LoadXml("<inertial mass='5' diaginertia='1 2 3'/>");
+    _inertial.ParseMjcf(_doc.GetElementsByTagName("inertial")[0] as XmlElement);
+    Assert.That(_inertial.Mass, Is.EqualTo(5.0f));
+    Assert.That(_inertial.DiagInertia, Is.EqualTo(new Vector3(1, 3, 2)));
+  }
+
+  [Test]
+  public void GenerateMjcf() {
+    _inertial.Mass = 6.0f;
+    _inertial.DiagInertia = new Vector3(7, 8, 9);
+    var mjcf = _inertial.GenerateMjcf("inertial", _doc);
+    Assert.That(mjcf.OuterXml, Does.Contain("mass=\"6\""));
+    Assert.That(mjcf.OuterXml, Does.Contain("diaginertia=\"7 9 8\""));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/MjInertialTests.cs.meta b/unity/Tests/Editor/components/MjInertialTests.cs.meta
new file mode 100644
index 00000000..1b8d97b5
--- /dev/null
+++ b/unity/Tests/Editor/components/MjInertialTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 49a2df64f659c498aa573ad717200548
+timeCreated: 1551130256
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjSceneTests.cs b/unity/Tests/Editor/components/MjSceneTests.cs
new file mode 100644
index 00000000..7a3e588b
--- /dev/null
+++ b/unity/Tests/Editor/components/MjSceneTests.cs
@@ -0,0 +1,215 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools.Utils;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjSceneGenerationTests {
+
+  [Test]
+  public void AssigningComponentsUniqueName() {
+    _fakeBodyA.enabled = true;
+    _fakeBodyB.enabled = true;
+    _scene.CreateScene(skipCompile:true);
+    Assert.That(_fakeBodyA.MujocoName, Is.Not.EqualTo(_fakeBodyB.MujocoName));
+  }
+
+  [Test]
+  public void AttachingComponentsToMjNodesThroughId() {
+    _fakeBodyA.enabled = true;
+    _fakeBodyB.enabled = true;
+    _scene.CreateScene();
+    Assert.That(_fakeBodyA.MujocoId, Is.GreaterThanOrEqualTo(0));
+    Assert.That(_fakeBodyB.MujocoId, Is.GreaterThanOrEqualTo(0));
+    Assert.That(_fakeBodyA.MujocoId, Is.Not.EqualTo(_fakeBodyB.MujocoId));
+  }
+
+  [Test]
+  public unsafe void ModelStructureIsInitialized() {
+    _fakeBodyA.enabled = true;
+    _fakeBodyB.enabled = true;
+    _scene.CreateScene();
+    Assert.That(_scene.Model->nbody, Is.GreaterThanOrEqualTo(2));
+  }
+
+  [Test]
+  public void SyncingComponentStateOnFixedUpdate() {
+    _fakeBodyA.enabled = true;
+    _fakeBodyB.enabled = true;
+    _scene.CreateScene();
+    Assert.That(_fakeBodyA.StateSynced, Is.False);
+    Assert.That(_fakeBodyB.StateSynced, Is.False);
+    _scene.StepScene();
+    Assert.That(_fakeBodyA.StateSynced, Is.True);
+    Assert.That(_fakeBodyB.StateSynced, Is.True);
+  }
+
+  [Test]
+  public unsafe void PhysicsRuntimeError() {
+    _scene.CreateScene();
+    _scene.Data->qpos[0] = float.PositiveInfinity;
+    Assert.That(
+        () => { _scene.StepScene(); },
+        Throws.TypeOf<PhysicsRuntimeException>()
+        .With.Message.EqualTo("BADQPOS: NaN/inf in qpos."));
+  }
+
+  [Test]
+  public void MjcfHierarchyMirrorsTheHierarchyOfUnityObjects() {
+    _fakeBodyA.transform.parent = _fakeBodyB.transform;
+    _fakeBodyA.enabled = true;
+    _fakeBodyB.enabled = true;
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    // Three components are already in this scene: body, joint and inertia (see SetUp function below)
+    var mjcfFakeBodyB = mjcf.SelectNodes("/mujoco/worldbody/body")[1] as XmlElement;
+    var mjcfFakeBodyA = mjcf.SelectNodes("/mujoco/worldbody/body/body")[0] as XmlElement;
+    Assert.That(mjcfFakeBodyA, Is.Not.Null);
+    Assert.That(mjcfFakeBodyB, Is.Not.Null);
+    // B is the parent, so it appears first in the XML
+    Assert.That(mjcfFakeBodyB.GetAttribute("name"), Is.EqualTo("component_3"));
+    Assert.That(mjcfFakeBodyA.GetAttribute("name"), Is.EqualTo("component_4"));
+  }
+
+  [Test]
+  public void ActuatorsAreAddedToDedicatedTag() {
+    _actuator.enabled = true;
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    var mjcfForActuator = mjcf.SelectNodes("/mujoco/actuator/general")[0] as XmlElement;
+    Assert.That(mjcfForActuator, Is.Not.Null);
+  }
+
+  [Test]
+  public void SensorsAreAddedToDedicatedTag() {
+    _sensor.enabled = true;
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    var mjcfForSensor = mjcf.SelectNodes("/mujoco/sensor/jointpos")[0] as XmlElement;
+    Assert.That(mjcfForSensor, Is.Not.Null);
+  }
+
+  [Test]
+  public unsafe void SceneRecreatedWithAddition() {
+    _scene.CreateScene();
+    _scene.Data->qvel[0] = 1;
+    var nq = _scene.Model->nq;
+    var tickedRotation = _body.transform.rotation;
+    var body = new GameObject("body").AddComponent<MjBody>();
+    var inertia = new GameObject("inertia").AddComponent<MjInertial>();
+    inertia.transform.parent = body.transform;
+    var joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    joint.transform.parent = body.transform;
+    _scene.RecreateScene();
+    Assert.That(_scene.Model->nq, Is.EqualTo(nq+1));
+    Assert.That(_scene.Data->qvel[joint.DofAddress], Is.EqualTo(0));
+    Assert.That(_scene.Data->qvel[_joint.DofAddress], Is.EqualTo(1));
+    UnityEngine.Object.DestroyImmediate(inertia.gameObject);
+    UnityEngine.Object.DestroyImmediate(joint.gameObject);
+    UnityEngine.Object.DestroyImmediate(body.gameObject);
+  }
+
+  [Test]
+  public unsafe void SceneRecreatedAfterDeletion() {
+    var body = new GameObject("body").AddComponent<MjBody>();
+    var inertia = new GameObject("inertia").AddComponent<MjInertial>();
+    inertia.transform.parent = body.transform;
+    var joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    joint.transform.parent = body.transform;
+    _scene.CreateScene();
+    _scene.Data->qvel[0] = 1;
+    _scene.Data->qvel[1] = 2;
+    var nq = _scene.Model->nq;
+    UnityEngine.Object.DestroyImmediate(inertia.gameObject);
+    UnityEngine.Object.DestroyImmediate(joint.gameObject);
+    UnityEngine.Object.DestroyImmediate(body.gameObject);
+    _scene.RecreateScene();
+    Assert.That(_scene.Model->nq, Is.EqualTo(nq-1));
+    Assert.That(_scene.Data->qvel[0], Is.EqualTo(2));
+  }
+
+#region Test setup.
+
+  public class FakeMjBody : MjBaseBody {
+    public bool StateSynced = false;
+
+    public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_BODY;
+
+    protected override void OnParseMjcf(XmlElement mjcf) {}
+
+    protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+      // We'll create an actual element because the code will then pass it on to Mujoco scene
+      // compiler, and we care that the compiler doesn't fail.
+      var mjcf = doc.CreateElement("body");
+      return mjcf;
+    }
+
+    public override unsafe void OnSyncState(MujocoLib.mjData_* data) {
+      StateSynced = true;
+    }
+  }
+
+  private MjScene _scene;
+  private FakeMjBody _fakeBodyA;
+  private FakeMjBody _fakeBodyB;
+  private MjJointScalarSensor _sensor;
+  private MjBody _body;
+  private MjInertial _inertia;
+  private MjHingeJoint _joint;
+  private MjActuator _actuator;
+  private Vector4EqualityComparer _quaternionComparer;
+
+  [SetUp]
+  public void SetUp() {
+    _quaternionComparer = new Vector4EqualityComparer(1e-5f);
+    _scene = MjScene.Instance;
+    _fakeBodyA = new GameObject("component").AddComponent<FakeMjBody>();
+    _fakeBodyB = new GameObject("component").AddComponent<FakeMjBody>();
+    _sensor = new GameObject("sensor").AddComponent<MjJointScalarSensor>();
+    _actuator = new GameObject("actuator").AddComponent<MjActuator>();
+    // body, joint and inertia are always present so that the actuator and sensor are valid
+    _body = new GameObject("body").AddComponent<MjBody>();
+    _inertia = new GameObject("inertia").AddComponent<MjInertial>();
+    _inertia.transform.parent = _body.transform;
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.transform.parent = _body.transform;
+    _sensor.Joint = _joint;
+    _sensor.SensorType = MjJointScalarSensor.AvailableSensors.JointPos;
+    _actuator.Joint = _joint;
+    _fakeBodyA.enabled = false;
+    _fakeBodyB.enabled = false;
+    _sensor.enabled = false;
+    _actuator.enabled = false;
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_fakeBodyA.gameObject);
+    UnityEngine.Object.DestroyImmediate(_fakeBodyB.gameObject);
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_actuator.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+    UnityEngine.Object.DestroyImmediate(_inertia.gameObject);
+    UnityEngine.Object.DestroyImmediate(_body.gameObject);
+    UnityEngine.Object.DestroyImmediate(_scene.gameObject);
+  }
+
+#endregion
+}
+}
diff --git a/unity/Tests/Editor/components/MjSceneTests.cs.meta b/unity/Tests/Editor/components/MjSceneTests.cs.meta
new file mode 100644
index 00000000..f120df46
--- /dev/null
+++ b/unity/Tests/Editor/components/MjSceneTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: d5db1f5b04f4c4ab3b6081481fa45cab
+timeCreated: 1536939770
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjSiteTests.cs b/unity/Tests/Editor/components/MjSiteTests.cs
new file mode 100644
index 00000000..577ffa96
--- /dev/null
+++ b/unity/Tests/Editor/components/MjSiteTests.cs
@@ -0,0 +1,65 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjSiteEditorTests {
+
+  private MjSite _site;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _site = new GameObject("site", typeof(MjSite)).GetComponent<MjSite>();
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    GameObject.DestroyImmediate(_site.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [Test]
+  public void GeneratingShapePropertiesMjcf() {
+    _site.ShapeType = MjShapeComponent.ShapeTypes.Box;
+    _site.Box.Extents = new Vector3(1, 2, 3);
+    _doc.AppendChild(_site.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain("type=\"box\""));
+    Assert.That(_doc.OuterXml, Does.Contain("size=\"1 3 2\""));
+  }
+
+  [Test]
+  public void ParsingShapePropertiesMjcf() {
+    var mjcfString = "<site type=\"box\" size=\"1 3 2\"/>";
+    var mjcfElement = Parse(mjcfString, "site");
+    _site.ParseMjcf(mjcfElement);
+    Assert.That(_site.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Box));
+    Assert.That(_site.Box.Extents, Is.EqualTo(new Vector3(1, 2, 3)));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/MjSiteTests.cs.meta b/unity/Tests/Editor/components/MjSiteTests.cs.meta
new file mode 100644
index 00000000..8574a0a9
--- /dev/null
+++ b/unity/Tests/Editor/components/MjSiteTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c0e1212bb116746d990a603c60820a7f
+timeCreated: 1547480369
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/MjcfGenerationContextTests.cs b/unity/Tests/Editor/components/MjcfGenerationContextTests.cs
new file mode 100644
index 00000000..c1432d12
--- /dev/null
+++ b/unity/Tests/Editor/components/MjcfGenerationContextTests.cs
@@ -0,0 +1,144 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjcfGenerationContextTests {
+
+  [Test]
+  public void ComponentAssignedMujocoName() {
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    Assert.That(mjcf.OuterXml, Does.Contain(
+        @"name=""component_0"""));
+  }
+
+  [Test]
+  public void TwoComponentsWithSameNameReceiveDistinctMujocoNames() {
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    Assert.That(mjcf.OuterXml, Does.Contain(
+        @"name=""component_0"""));
+    Assert.That(mjcf.OuterXml, Does.Contain(
+        @"name=""component_1"""));
+  }
+
+  [Test]
+  public void GravityVectorIsConvertedToMjWorldReferenceFrame() {
+    Physics.gravity = new Vector3(1, 2, 3);
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    Assert.That(mjcf.OuterXml, Does.Contain("gravity=\"1 3 2\""));
+  }
+
+  [Test]
+  public void ConfigurationMjcfSpecifiesTimeout() {
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    Assert.That(mjcf.OuterXml, Does.Contain($"timestep=\"{Time.fixedDeltaTime}\""));
+  }
+
+  [Test]
+  public void ConfigurationMjcfSpecifiesCoordinateSystemAsLocal() {
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    Assert.That(mjcf.OuterXml, Does.Contain("coordinate=\"local\""));
+  }
+
+  [Test]
+  public void ConfigurationMjcIncludesOptions() {
+    var mjcf = _scene.CreateScene(skipCompile:true);
+    Assert.That(mjcf.OuterXml, Does.Contain("impratio"));
+    Assert.That(mjcf.OuterXml, Does.Contain("magnetic"));
+    Assert.That(mjcf.OuterXml, Does.Contain("wind"));
+    Assert.That(mjcf.OuterXml, Does.Contain("density"));
+    Assert.That(mjcf.OuterXml, Does.Contain("viscosity"));
+    Assert.That(mjcf.OuterXml, Does.Contain("o_margin"));
+    Assert.That(mjcf.OuterXml, Does.Contain("o_solref"));
+    Assert.That(mjcf.OuterXml, Does.Contain("o_solimp"));
+    Assert.That(mjcf.OuterXml, Does.Contain("iterations"));
+    Assert.That(mjcf.OuterXml, Does.Contain("tolerance"));
+    Assert.That(mjcf.OuterXml, Does.Contain("noslip_iterations"));
+    Assert.That(mjcf.OuterXml, Does.Contain("noslip_tolerance"));
+    Assert.That(mjcf.OuterXml, Does.Contain("mpr_iterations"));
+    Assert.That(mjcf.OuterXml, Does.Contain("mpr_tolerance"));
+  }
+
+  [Test]
+  public void AssigningGeneratedMeshAssetsUniqueNames() {
+    var context = new MjcfGenerationContext();
+    var uniqueAssetName = context.AddMeshAsset(mesh: new Mesh());
+    var element = new XmlDocument().CreateElement("test");
+    context.GenerateMjcf(element);
+    var assetNodes = element.SelectNodes($"asset/mesh[@name='{uniqueAssetName}']");
+    Assert.That(assetNodes, Has.Count.EqualTo(1));
+  }
+
+  [Test]
+  public void MeshMjcfIgnoresTriangleConnectivityAndStoredOnlyTheVertexCloud() {
+    var mesh = new Mesh();
+    mesh.vertices = new Vector3[] {
+        new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1) };
+    mesh.triangles = new int[] { 0, 1, 2, 2, 1, 0, 1, 0, 2 };
+    var context = new MjcfGenerationContext();
+    context.AddMeshAsset(mesh);
+    var element = new XmlDocument().CreateElement("test");
+    context.GenerateMjcf(element);
+    Assert.That(element.OuterXml, Does.Contain("vertex=\"1 0 0 0 0 1 0 1 0 \""));
+  }
+
+  [Test]
+  public void SettingNUserSensorValuesKeepsTheHigherValue() {
+    var context = new MjcfGenerationContext();
+    context.NUserSensor = 5;
+    context.NUserSensor = 6;
+    context.NUserSensor = 1;
+    Assert.That(context.NUserSensor, Is.EqualTo(6));
+    var element = new XmlDocument().CreateElement("test");
+    context.GenerateMjcf(element);
+    Assert.That(element.OuterXml, Does.Contain("nuser_sensor=\"6\""));
+  }
+
+  #region Test setup.
+
+  private MjBody _componentA;
+  private MjBody _componentB;
+  private Vector3 _originalGravity;
+  private MjScene _scene;
+  private MjGlobalSettings _settings;
+
+  [SetUp]
+  public void SetUp() {
+    _componentA = new GameObject("component").AddComponent<MjBody>();
+    _componentB = new GameObject("component").AddComponent<MjBody>();
+    _scene = MjScene.Instance;
+    _originalGravity = Physics.gravity;
+    _settings = new GameObject("settings").AddComponent<MjGlobalSettings>();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    Physics.gravity = _originalGravity;
+    UnityEngine.Object.DestroyImmediate(_componentA.gameObject);
+    UnityEngine.Object.DestroyImmediate(_componentB.gameObject);
+    UnityEngine.Object.DestroyImmediate(_settings.gameObject);
+    UnityEngine.Object.DestroyImmediate(_scene.gameObject);
+  }
+
+  #endregion
+}
+}
diff --git a/unity/Tests/Editor/components/MjcfGenerationContextTests.cs.meta b/unity/Tests/Editor/components/MjcfGenerationContextTests.cs.meta
new file mode 100644
index 00000000..7583ea67
--- /dev/null
+++ b/unity/Tests/Editor/components/MjcfGenerationContextTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: de5be923668a9430596708fea97eb93c
+timeCreated: 1537461794
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors.meta b/unity/Tests/Editor/components/Sensors.meta
new file mode 100644
index 00000000..92457a9d
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f2ea6a2cbdb5b655782b59b4f75f602d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjActuatorScalarSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjActuatorScalarSensorTests.cs
new file mode 100644
index 00000000..b5ce9476
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjActuatorScalarSensorTests.cs
@@ -0,0 +1,108 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+[TestFixture]
+public class MjActuatorScalarSensorTests {
+
+  private MjActuatorScalarSensor _sensor;
+  private MjActuator _actuator;
+  private MjHingeJoint _joint;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("sensor", typeof(MjActuatorScalarSensor))
+        .GetComponent<MjActuatorScalarSensor>();
+    _joint = new GameObject("joint", typeof(MjHingeJoint)).GetComponent<MjHingeJoint>();
+    _actuator = new GameObject("actuator", typeof(MjActuator)).GetComponent<MjActuator>();
+    _actuator.Joint = _joint;
+    _sensor.Actuator = _actuator;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+    UnityEngine.Object.DestroyImmediate(_actuator.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [TestCase(MjActuatorScalarSensor.AvailableSensors.ActuatorPos, "actuatorpos")]
+  [TestCase(MjActuatorScalarSensor.AvailableSensors.ActuatorVel, "actuatorvel")]
+  [TestCase(MjActuatorScalarSensor.AvailableSensors.ActuatorFrc, "actuatorfrc")]
+  public void GenerateSensorName(
+    MjActuatorScalarSensor.AvailableSensors type, string expectedTag) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<{expectedTag}"));
+  }
+
+  [TestCase(MjActuatorScalarSensor.AvailableSensors.ActuatorPos)]
+  [TestCase(MjActuatorScalarSensor.AvailableSensors.ActuatorVel)]
+  [TestCase(MjActuatorScalarSensor.AvailableSensors.ActuatorFrc)]
+  public void GenerateJointReference(MjActuatorScalarSensor.AvailableSensors type) {
+    var parentNode = _doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    _sensor.SensorType = type;
+    parentNode.AppendChild(_actuator.GenerateMjcf("test_actuator", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain("actuator=\"test_actuator\""));
+  }
+
+  [TestCase("actuatorpos", MjActuatorScalarSensor.AvailableSensors.ActuatorPos)]
+  [TestCase("actuatorvel", MjActuatorScalarSensor.AvailableSensors.ActuatorVel)]
+  [TestCase("actuatorfrc", MjActuatorScalarSensor.AvailableSensors.ActuatorFrc)]
+  public void ParsingSensorType(
+      string tag, MjActuatorScalarSensor.AvailableSensors expectedType) {
+    var mjcfString = $"<sensors><{tag} actuator=\"actuator\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, tag);
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.SensorType, Is.EqualTo(expectedType));
+  }
+
+  [TestCase("actuatorpos")]
+  [TestCase("actuatorvel")]
+  [TestCase("actuatorfrc")]
+  public void ParsingReferenceToExistingActuator(string tag) {
+    var mjcfString = $"<sensors><{tag} actuator=\"actuator\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, tag);
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Actuator, Is.EqualTo(_actuator));
+  }
+
+  [TestCase("actuatorpos")]
+  [TestCase("actuatorvel")]
+  [TestCase("actuatorfrc")]
+  public void ParsingReferenceToMissingAcgtuatorThrowsException(string tag) {
+    var mjcfString = $"<sensors><{tag} actuator=\"missing_actuator\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, tag);
+    Assert.That(() => { _sensor.ParseMjcf(mjcfElement); }, Throws.TypeOf<ArgumentException>());
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjActuatorScalarSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjActuatorScalarSensorTests.cs.meta
new file mode 100644
index 00000000..181ec53d
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjActuatorScalarSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 287455e1e42ce4ac1817b65258ddd17f
+timeCreated: 1548111403
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjBaseSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjBaseSensorTests.cs
new file mode 100644
index 00000000..8a15152f
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjBaseSensorTests.cs
@@ -0,0 +1,72 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjBaseSensorTests {
+
+  public class MjMockSensor : MjBaseSensor {
+    protected override XmlElement ToMjcf(XmlDocument doc) {
+      return doc.CreateElement("sensor");
+    }
+    protected override void FromMjcf(XmlElement mjcf) {}
+  }
+
+  private MjMockSensor _sensor;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("sensor", typeof(MjMockSensor)).GetComponent<MjMockSensor>();
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [Test]
+  public void GeneratingNoiseAndCutoffMjcf() {
+    _sensor.Noise = 2.0f;
+    _sensor.Cutoff = 3.0f;
+    _doc.AppendChild(_sensor.GenerateMjcf("name", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain("noise=\"2\""));
+    Assert.That(_doc.OuterXml, Does.Contain("cutoff=\"3\""));
+  }
+
+  [Test]
+  public void ParsingShapePropertiesMjcf() {
+    var mjcfString = "<sensor noise=\"3\" cutoff=\"4\" actuator=\"actuator\"/>";
+    var mjcfElement = Parse(mjcfString, "sensor");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Noise, Is.EqualTo(3.0f));
+    Assert.That(_sensor.Cutoff, Is.EqualTo(4.0f));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjBaseSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjBaseSensorTests.cs.meta
new file mode 100644
index 00000000..5969f762
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjBaseSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 8bfd8b530bc0546a69960cffd3c1cb35
+timeCreated: 1548085697
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjBodyQuaternionSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjBodyQuaternionSensorTests.cs
new file mode 100644
index 00000000..90ef6409
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjBodyQuaternionSensorTests.cs
@@ -0,0 +1,91 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjBodyQuaternionSensorTests {
+
+  private MjBodyQuaternionSensor _sensor;
+  private MjBody _body;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("sensor", typeof(MjBodyQuaternionSensor))
+        .GetComponent<MjBodyQuaternionSensor>();
+    _body = new GameObject("body", typeof(MjBody)).GetComponent<MjBody>();
+    _sensor.Body = _body;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_body.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [Test]
+  public void GenerateSensorName() {
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<framequat"));
+  }
+
+  [Test]
+  public void GenerateBodyReference() {
+    var parentNode = (XmlElement)_doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    parentNode.AppendChild(_body.GenerateMjcf("test_body", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"objname=\"test_body\""));
+  }
+
+  [TestCase(true, "xbody")]
+  [TestCase(false, "body")]
+  public void FrameTypeSpecification(bool useInertial, string expectedValue) {
+    _sensor.UseInertialFrame = useInertial;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Not.Contain($"objname=\"{expectedValue}\""));
+  }
+
+  [Test]
+  public void ParsingFrameBodyName() {
+    var mjcfString = $"<sensors><framequat objname=\"body\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"framequat");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Body, Is.EqualTo(_body));
+  }
+
+  [Test]
+  public void ExceptionThrownWhenReferencedBodyNotFoundInScene() {
+    var mjcfString = $"<sensors><framequat objname=\"missing_body\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"framequat");
+    Assert.That(() => { _sensor.ParseMjcf(mjcfElement); }, Throws.TypeOf<ArgumentException>());
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjBodyQuaternionSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjBodyQuaternionSensorTests.cs.meta
new file mode 100644
index 00000000..3dc60366
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjBodyQuaternionSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: f205441f0cfbb407abd911ffd114bef9
+timeCreated: 1548171405
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjBodyVectorSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjBodyVectorSensorTests.cs
new file mode 100644
index 00000000..12360f0c
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjBodyVectorSensorTests.cs
@@ -0,0 +1,176 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjBodyVectorSensorTests {
+
+  private MjBodyVectorSensor _sensor;
+  private MjBody _body;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("sensor", typeof(MjBodyVectorSensor))
+        .GetComponent<MjBodyVectorSensor>();
+    _body = new GameObject("body", typeof(MjBody)).GetComponent<MjBody>();
+    _sensor.Body = _body;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_body.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeCom, "subtreecom")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeLinVel, "subtreelinvel")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeAngMom, "subtreeangmom")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FramePos, "framepos")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameXAxis, "framexaxis")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameYAxis, "frameyaxis")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameZAxis, "framezaxis")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameLinVel, "framelinvel")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameAngVel, "frameangvel")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameLinAcc, "framelinacc")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameAngAcc, "frameangacc")]
+  public void GenerateSensorName(
+      MjBodyVectorSensor.AvailableSensors type, string expectedTag) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<{expectedTag}"));
+  }
+
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeCom, "body")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeLinVel, "body")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeAngMom, "body")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FramePos, "objname")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameXAxis, "objname")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameYAxis, "objname")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameZAxis, "objname")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameLinVel, "objname")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameAngVel, "objname")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameLinAcc, "objname")]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameAngAcc, "objname")]
+  public void GenerateBodyReference(
+      MjBodyVectorSensor.AvailableSensors type, string expectedAttribute) {
+    var parentNode = (XmlElement)_doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    _sensor.SensorType = type;
+    parentNode.AppendChild(_body.GenerateMjcf("test_body", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"{expectedAttribute}=\"test_body\""));
+  }
+
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeCom)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeLinVel)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.SubtreeAngMom)]
+  public void SensorsWithoutExplicitBindingTypeSpecification(
+      MjBodyVectorSensor.AvailableSensors type) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Not.Contain($"objname"));
+  }
+
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FramePos)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameXAxis)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameYAxis)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameZAxis)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameLinVel)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameAngVel)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameLinAcc)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameAngAcc)]
+  public void InertialFrameSpecification(MjBodyVectorSensor.AvailableSensors type) {
+    _sensor.SensorType = type;
+    _sensor.UseInertialFrame = true;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Not.Contain($"objname=\"xbody\""));
+  }
+
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FramePos)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameXAxis)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameYAxis)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameZAxis)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameLinVel)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameAngVel)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameLinAcc)]
+  [TestCase(MjBodyVectorSensor.AvailableSensors.FrameAngAcc)]
+  public void RegularFrameSpecification(MjBodyVectorSensor.AvailableSensors type) {
+    _sensor.SensorType = type;
+    _sensor.UseInertialFrame = false;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Not.Contain($"objname=\"body\""));
+  }
+
+  [TestCase("subtreecom", MjBodyVectorSensor.AvailableSensors.SubtreeCom)]
+  [TestCase("subtreelinvel", MjBodyVectorSensor.AvailableSensors.SubtreeLinVel)]
+  [TestCase("subtreeangmom", MjBodyVectorSensor.AvailableSensors.SubtreeAngMom)]
+  [TestCase("framepos", MjBodyVectorSensor.AvailableSensors.FramePos)]
+  [TestCase("framexaxis", MjBodyVectorSensor.AvailableSensors.FrameXAxis)]
+  [TestCase("frameyaxis", MjBodyVectorSensor.AvailableSensors.FrameYAxis)]
+  [TestCase("framezaxis", MjBodyVectorSensor.AvailableSensors.FrameZAxis)]
+  [TestCase("framelinvel", MjBodyVectorSensor.AvailableSensors.FrameLinVel)]
+  [TestCase("frameangvel", MjBodyVectorSensor.AvailableSensors.FrameAngVel)]
+  [TestCase("framelinacc", MjBodyVectorSensor.AvailableSensors.FrameLinAcc)]
+  [TestCase("frameangacc", MjBodyVectorSensor.AvailableSensors.FrameAngAcc)]
+  public void ParsingSensorType(
+      string tag, MjBodyVectorSensor.AvailableSensors expectedType) {
+    var mjcfString = $"<sensors><{tag} body=\"body\" objname=\"body\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.SensorType, Is.EqualTo(expectedType));
+  }
+
+  [TestCase("subtreecom", "body")]
+  [TestCase("subtreelinvel", "body")]
+  [TestCase("subtreeangmom", "body")]
+  public void ParsingSubtreeBodyName(string tag, string bodyAttribute) {
+    var mjcfString = $"<sensors><{tag} {bodyAttribute}=\"body\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Body, Is.EqualTo(_body));
+  }
+
+  [TestCase("framepos", "objname")]
+  [TestCase("framexaxis", "objname")]
+  [TestCase("frameyaxis", "objname")]
+  [TestCase("framezaxis", "objname")]
+  [TestCase("framelinvel", "objname")]
+  [TestCase("frameangvel", "objname")]
+  [TestCase("framelinacc", "objname")]
+  [TestCase("frameangacc", "objname")]
+  public void ParsingFrameBodyName(string tag, string bodyAttribute) {
+    var mjcfString = $"<sensors><{tag} {bodyAttribute}=\"body\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Body, Is.EqualTo(_body));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjBodyVectorSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjBodyVectorSensorTests.cs.meta
new file mode 100644
index 00000000..a3261e03
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjBodyVectorSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: f526488db0d874499bc9af392d6dedd1
+timeCreated: 1548105164
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjGeomQuaternionSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjGeomQuaternionSensorTests.cs
new file mode 100644
index 00000000..3d6b6977
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjGeomQuaternionSensorTests.cs
@@ -0,0 +1,88 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+[TestFixture]
+public class MjGeomQuaternionSensorTests {
+
+  private MjGeomQuaternionSensor _sensor;
+  private MjGeom _geom;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("MjGeomQuaternionSensorTests_sensor")
+        .AddComponent<MjGeomQuaternionSensor>();
+    _geom = new GameObject("MjGeomQuaternionSensorTests_geom").AddComponent<MjGeom>();
+    _sensor.Geom = _geom;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_geom.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  public void GenerateSensorName() {
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain("<framequat"));
+  }
+
+  public void GenerateGeomReference() {
+    var parentNode = (XmlElement)_doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    parentNode.AppendChild(_geom.GenerateMjcf("test_geom", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain("objname=\"test_geom\""));
+  }
+
+  public void FrameTypeSpecification() {
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(
+        _doc.OuterXml, Does.Not.Contain("objname=\"MjGeomQuaternionSensorTests_geom\""));
+  }
+
+  [Test]
+  public void FindTheReferencedGeom() {
+    var mjcfString =
+        "<sensors><framequat objname=\"MjGeomQuaternionSensorTests_geom\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, "framequat");
+    _sensor.Geom = null;
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Geom, Is.EqualTo(_geom));
+  }
+
+  [Test]
+  public void ExceptionThrownWhenReferencedBodyNotFoundInScene() {
+    var mjcfString = "<sensors><framequat objname=\"missing_geom\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, "framequat");
+    Assert.That(() => { _sensor.ParseMjcf(mjcfElement); }, Throws.TypeOf<ArgumentException>());
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjGeomQuaternionSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjGeomQuaternionSensorTests.cs.meta
new file mode 100644
index 00000000..5cbde878
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjGeomQuaternionSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ca32673e22b8f42f58cb7fb324980224
+timeCreated: 1548171623
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjGeomVectorSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjGeomVectorSensorTests.cs
new file mode 100644
index 00000000..e7aa9f14
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjGeomVectorSensorTests.cs
@@ -0,0 +1,134 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjGeomVectorSensorTests {
+
+  private MjGeomVectorSensor _sensor;
+  private MjGeom _geom;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("MjGeomVectorSensorTests_sensor")
+        .AddComponent<MjGeomVectorSensor>();
+    _geom = new GameObject("MjGeomVectorSensorTests_geom").AddComponent<MjGeom>();
+    _sensor.Geom = _geom;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_geom.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FramePos, "framepos")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameXAxis, "framexaxis")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameYAxis, "frameyaxis")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameZAxis, "framezaxis")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameLinVel, "framelinvel")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameAngVel, "frameangvel")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameLinAcc, "framelinacc")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameAngAcc, "frameangacc")]
+  public void GenerateSensorName(
+      MjGeomVectorSensor.AvailableSensors type, string expectedTag) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<{expectedTag}"));
+  }
+
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FramePos, "objname")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameXAxis, "objname")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameYAxis, "objname")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameZAxis, "objname")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameLinVel, "objname")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameAngVel, "objname")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameLinAcc, "objname")]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameAngAcc, "objname")]
+  public void GenerateGeomReference(
+      MjGeomVectorSensor.AvailableSensors type, string expectedAttribute) {
+    var parentNode = (XmlElement)_doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    _sensor.SensorType = type;
+    parentNode.AppendChild(_geom.GenerateMjcf("test_geom", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"{expectedAttribute}=\"test_geom\""));
+  }
+
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FramePos)]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameXAxis)]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameYAxis)]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameZAxis)]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameLinVel)]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameAngVel)]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameLinAcc)]
+  [TestCase(MjGeomVectorSensor.AvailableSensors.FrameAngAcc)]
+  public void FrameTypeSpecification(MjGeomVectorSensor.AvailableSensors type) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Not.Contain($"objname=\"MjGeomVectorSensorTests_geom\""));
+  }
+
+  [TestCase("framepos", MjGeomVectorSensor.AvailableSensors.FramePos)]
+  [TestCase("framexaxis", MjGeomVectorSensor.AvailableSensors.FrameXAxis)]
+  [TestCase("frameyaxis", MjGeomVectorSensor.AvailableSensors.FrameYAxis)]
+  [TestCase("framezaxis", MjGeomVectorSensor.AvailableSensors.FrameZAxis)]
+  [TestCase("framelinvel", MjGeomVectorSensor.AvailableSensors.FrameLinVel)]
+  [TestCase("frameangvel", MjGeomVectorSensor.AvailableSensors.FrameAngVel)]
+  [TestCase("framelinacc", MjGeomVectorSensor.AvailableSensors.FrameLinAcc)]
+  [TestCase("frameangacc", MjGeomVectorSensor.AvailableSensors.FrameAngAcc)]
+  public void ParsingSensorType(
+      string tag, MjGeomVectorSensor.AvailableSensors expectedType) {
+    var mjcfString =
+      $"<sensors><{tag} geom=\"MjGeomVectorSensorTests_geom\" " +
+      "objname=\"MjGeomVectorSensorTests_geom\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.SensorType, Is.EqualTo(expectedType));
+  }
+
+  [TestCase("framepos", "objname")]
+  [TestCase("framexaxis", "objname")]
+  [TestCase("frameyaxis", "objname")]
+  [TestCase("framezaxis", "objname")]
+  [TestCase("framelinvel", "objname")]
+  [TestCase("frameangvel", "objname")]
+  [TestCase("framelinacc", "objname")]
+  [TestCase("frameangacc", "objname")]
+  public void ParsingFrameGeomName(string tag, string siteAttribute) {
+    var mjcfString =
+        $"<sensors><{tag} {siteAttribute}=\"MjGeomVectorSensorTests_geom\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Geom, Is.EqualTo(_geom));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjGeomVectorSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjGeomVectorSensorTests.cs.meta
new file mode 100644
index 00000000..0dea60a5
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjGeomVectorSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 2692b29d3e9a341338aeeedf820a6ee6
+timeCreated: 1548110539
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjJointScalarSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjJointScalarSensorTests.cs
new file mode 100644
index 00000000..26f0a2f1
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjJointScalarSensorTests.cs
@@ -0,0 +1,113 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+[TestFixture]
+public class MjJointScalarSensorTests {
+
+  private MjJointScalarSensor _sensor;
+  private MjHingeJoint _joint;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("sensor").AddComponent<MjJointScalarSensor>();
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _sensor.Joint = _joint;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_joint.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointPos, "jointpos")]
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointVel, "jointvel")]
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointLimitPos, "jointlimitpos")]
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointLimitVel, "jointlimitvel")]
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointLimitFrc, "jointlimitfrc")]
+  public void GenerateSensorName(
+      MjJointScalarSensor.AvailableSensors type, string expectedTag) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<{expectedTag}"));
+  }
+
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointPos)]
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointVel)]
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointLimitPos)]
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointLimitVel)]
+  [TestCase(MjJointScalarSensor.AvailableSensors.JointLimitFrc)]
+  public void GenerateJointReference(MjJointScalarSensor.AvailableSensors type) {
+    var parentNode = _doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    _sensor.SensorType = type;
+    parentNode.AppendChild(_joint.GenerateMjcf("test_joint", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain("joint=\"test_joint\""));
+  }
+
+  [TestCase("jointpos", MjJointScalarSensor.AvailableSensors.JointPos)]
+  [TestCase("jointvel", MjJointScalarSensor.AvailableSensors.JointVel)]
+  [TestCase("jointlimitpos", MjJointScalarSensor.AvailableSensors.JointLimitPos)]
+  [TestCase("jointlimitvel", MjJointScalarSensor.AvailableSensors.JointLimitVel)]
+  [TestCase("jointlimitfrc", MjJointScalarSensor.AvailableSensors.JointLimitFrc)]
+  public void ParsingSensorType(
+      string tag, MjJointScalarSensor.AvailableSensors expectedType) {
+    var mjcfString = $"<sensors><{tag} joint=\"joint\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.SensorType, Is.EqualTo(expectedType));
+  }
+
+  [TestCase("jointpos")]
+  [TestCase("jointvel")]
+  [TestCase("jointlimitpos")]
+  [TestCase("jointlimitvel")]
+  [TestCase("jointlimitfrc")]
+  public void ParsingReferenceToExistingJoint(string tag) {
+    var mjcfString = $"<sensors><{tag} joint=\"joint\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Joint, Is.EqualTo(_joint));
+  }
+
+  [TestCase("jointpos")]
+  [TestCase("jointvel")]
+  [TestCase("jointlimitpos")]
+  [TestCase("jointlimitvel")]
+  [TestCase("jointlimitfrc")]
+  public void ParsingReferenceToMissingJointThrowsException(string tag) {
+    var mjcfString = $"<sensors><{tag} joint=\"missing_joint\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    Assert.That(() => { _sensor.ParseMjcf(mjcfElement); }, Throws.TypeOf<ArgumentException>());
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjJointScalarSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjJointScalarSensorTests.cs.meta
new file mode 100644
index 00000000..22d88117
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjJointScalarSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 723fee04a97c5487486652cd5167bd06
+timeCreated: 1548111043
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjSiteQuaternionSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjSiteQuaternionSensorTests.cs
new file mode 100644
index 00000000..7589a132
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjSiteQuaternionSensorTests.cs
@@ -0,0 +1,84 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjSiteQuaternionSensorTests {
+
+  private MjSiteQuaternionSensor _sensor;
+  private MjSite _site;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("sensor", typeof(MjSiteQuaternionSensor))
+        .GetComponent<MjSiteQuaternionSensor>();
+    _site = new GameObject("site", typeof(MjSite)).GetComponent<MjSite>();
+    _sensor.Site = _site;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_site.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [Test]
+  public void GenerateSensorName() {
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain("<framequat"));
+  }
+
+  [Test]
+  public void GenerateSiteReference() {
+    var parentNode = _doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    parentNode.AppendChild(_site.GenerateMjcf("test_site", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain("objname=\"test_site\""));
+  }
+
+  [Test]
+  public void FindingRenferencedSite() {
+    var mjcfString = "<sensors><framequat objname=\"site\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, "framequat");
+    _sensor.Site = null;
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Site, Is.EqualTo(_site));
+  }
+
+  [Test]
+  public void ExceptionThrownWhenReferencedBodyNotFoundInScene() {
+    var mjcfString = "<sensors><framequat objname=\"missing_site\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, "framequat");
+    Assert.That(() => { _sensor.ParseMjcf(mjcfElement); }, Throws.TypeOf<ArgumentException>());
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjSiteQuaternionSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjSiteQuaternionSensorTests.cs.meta
new file mode 100644
index 00000000..4921d86a
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjSiteQuaternionSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 733b3b2c8a1ea44ddab4da302810cc4d
+timeCreated: 1548171912
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjSiteScalarSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjSiteScalarSensorTests.cs
new file mode 100644
index 00000000..92c9a2cb
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjSiteScalarSensorTests.cs
@@ -0,0 +1,101 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjSiteScalarSensorTests {
+
+  private MjSiteScalarSensor _sensor;
+  private MjSite _site;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("sensor", typeof(MjSiteScalarSensor))
+        .GetComponent<MjSiteScalarSensor>();
+    _site = new GameObject("site", typeof(MjSite)).GetComponent<MjSite>();
+    _sensor.Site = _site;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_site.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [TestCase(MjSiteScalarSensor.AvailableSensors.Touch, "touch")]
+  [TestCase(MjSiteScalarSensor.AvailableSensors.RangeFinder, "rangefinder")]
+  public void GenerateSensorName(
+      MjSiteScalarSensor.AvailableSensors type, string expectedTag) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<{expectedTag}"));
+  }
+
+  [TestCase(MjSiteScalarSensor.AvailableSensors.Touch)]
+  [TestCase(MjSiteScalarSensor.AvailableSensors.RangeFinder)]
+  public void GenerateSiteReference(MjSiteScalarSensor.AvailableSensors type) {
+    var parentNode = (XmlElement)_doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    _sensor.SensorType = type;
+    parentNode.AppendChild(_site.GenerateMjcf("test_site", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"site=\"test_site\""));
+  }
+
+  [TestCase(MjSiteScalarSensor.AvailableSensors.Touch)]
+  [TestCase(MjSiteScalarSensor.AvailableSensors.RangeFinder)]
+  public void SensorsWithoutExplicitBindingTypeSpecification(
+      MjSiteScalarSensor.AvailableSensors type) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Not.Contain($"objname"));
+  }
+
+  [TestCase("touch", MjSiteScalarSensor.AvailableSensors.Touch)]
+  [TestCase("rangefinder", MjSiteScalarSensor.AvailableSensors.RangeFinder)]
+  public void ParsingSensorType(
+      string tag, MjSiteScalarSensor.AvailableSensors expectedType) {
+    var mjcfString = $"<sensors><{tag} site=\"site\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.SensorType, Is.EqualTo(expectedType));
+  }
+
+  [TestCase("touch", "site")]
+  [TestCase("rangefinder", "site")]
+  public void ParsingSubtreeSiteName(string tag, string siteAttribute) {
+    var mjcfString = $"<sensors><{tag} {siteAttribute}=\"site\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, $"{tag}");
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Site, Is.EqualTo(_site));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjSiteScalarSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjSiteScalarSensorTests.cs.meta
new file mode 100644
index 00000000..c73cf0b4
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjSiteScalarSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 3a827466bc75c47b6afc4bc474a2a066
+timeCreated: 1548110161
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Sensors/MjSiteVectorSensorTests.cs b/unity/Tests/Editor/components/Sensors/MjSiteVectorSensorTests.cs
new file mode 100644
index 00000000..970748d3
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjSiteVectorSensorTests.cs
@@ -0,0 +1,173 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+[TestFixture]
+public class MjSiteVectorSensorTests {
+
+  private MjSiteVectorSensor _sensor;
+  private MjSite _site;
+  private XmlDocument _doc;
+
+  [SetUp]
+  public void SetUp() {
+    _sensor = new GameObject("sensor").AddComponent<MjSiteVectorSensor>();
+    _site = new GameObject("site").AddComponent<MjSite>();
+    _sensor.Site = _site;
+
+    _doc = new XmlDocument();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_sensor.gameObject);
+    UnityEngine.Object.DestroyImmediate(_site.gameObject);
+  }
+
+  private XmlElement Parse(string mjcfString, string tag) {
+    _doc.LoadXml(mjcfString);
+    var elementList = _doc.GetElementsByTagName(tag);
+    return elementList[0] as XmlElement;
+  }
+
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Accelerometer, "accelerometer")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Velocimeter, "velocimeter")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Gyro, "gyro")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Force, "force")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Torque, "torque")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Magnetometer, "magnetometer")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FramePos, "framepos")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameXAxis, "framexaxis")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameYAxis, "frameyaxis")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameZAxis, "framezaxis")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameLinVel, "framelinvel")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameAngVel, "frameangvel")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameLinAcc, "framelinacc")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameAngAcc, "frameangacc")]
+  public void GenerateSensorName(
+      MjSiteVectorSensor.AvailableSensors type, string expectedTag) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"<{expectedTag}"));
+  }
+
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Accelerometer, "site")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Velocimeter, "site")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Gyro, "site")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Force, "site")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Torque, "site")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Magnetometer, "site")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FramePos, "objname")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameXAxis, "objname")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameYAxis, "objname")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameZAxis, "objname")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameLinVel, "objname")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameAngVel, "objname")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameLinAcc, "objname")]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameAngAcc, "objname")]
+  public void GenerateSiteReference(
+      MjSiteVectorSensor.AvailableSensors type, string expectedAttribute) {
+    var parentNode = (XmlElement)_doc.CreateElement("parent");
+    _doc.AppendChild(parentNode);
+    _sensor.SensorType = type;
+    parentNode.AppendChild(_site.GenerateMjcf("test_site", _doc));
+    parentNode.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Contain($"{expectedAttribute}=\"test_site\""));
+  }
+
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Accelerometer)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Velocimeter)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Gyro)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Force)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Torque)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.Magnetometer)]
+  public void SensorsWithoutExplicitBindingTypeSpecification(
+      MjSiteVectorSensor.AvailableSensors type) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Not.Contain("objname"));
+  }
+
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FramePos)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameXAxis)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameYAxis)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameZAxis)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameLinVel)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameAngVel)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameLinAcc)]
+  [TestCase(MjSiteVectorSensor.AvailableSensors.FrameAngAcc)]
+  public void FrameTypeSpecification(MjSiteVectorSensor.AvailableSensors type) {
+    _sensor.SensorType = type;
+    _doc.AppendChild(_sensor.GenerateMjcf("test_sensor", _doc));
+    Assert.That(_doc.OuterXml, Does.Not.Contain("objname=\"site\""));
+  }
+
+  [TestCase("accelerometer", MjSiteVectorSensor.AvailableSensors.Accelerometer)]
+  [TestCase("velocimeter", MjSiteVectorSensor.AvailableSensors.Velocimeter)]
+  [TestCase("gyro", MjSiteVectorSensor.AvailableSensors.Gyro)]
+  [TestCase("force", MjSiteVectorSensor.AvailableSensors.Force)]
+  [TestCase("torque", MjSiteVectorSensor.AvailableSensors.Torque)]
+  [TestCase("magnetometer", MjSiteVectorSensor.AvailableSensors.Magnetometer)]
+  [TestCase("framepos", MjSiteVectorSensor.AvailableSensors.FramePos)]
+  [TestCase("framexaxis", MjSiteVectorSensor.AvailableSensors.FrameXAxis)]
+  [TestCase("frameyaxis", MjSiteVectorSensor.AvailableSensors.FrameYAxis)]
+  [TestCase("framezaxis", MjSiteVectorSensor.AvailableSensors.FrameZAxis)]
+  [TestCase("framelinvel", MjSiteVectorSensor.AvailableSensors.FrameLinVel)]
+  [TestCase("frameangvel", MjSiteVectorSensor.AvailableSensors.FrameAngVel)]
+  [TestCase("framelinacc", MjSiteVectorSensor.AvailableSensors.FrameLinAcc)]
+  [TestCase("frameangacc", MjSiteVectorSensor.AvailableSensors.FrameAngAcc)]
+  public void ParsingSensorType(
+      string tag, MjSiteVectorSensor.AvailableSensors expectedType) {
+    var mjcfString = $"<sensors><{tag} site=\"site\" objname=\"site\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, tag);
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.SensorType, Is.EqualTo(expectedType));
+  }
+
+  [TestCase("accelerometer", "site")]
+  [TestCase("velocimeter", "site")]
+  [TestCase("gyro", "site")]
+  [TestCase("force", "site")]
+  [TestCase("torque", "site")]
+  [TestCase("magnetometer", "site")]
+  public void ParsingSubtreeSiteName(string tag, string siteAttribute) {
+    var mjcfString = $"<sensors><{tag} {siteAttribute}=\"site\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, tag);
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Site, Is.EqualTo(_site));
+  }
+
+  [TestCase("framepos", "objname")]
+  [TestCase("framexaxis", "objname")]
+  [TestCase("frameyaxis", "objname")]
+  [TestCase("framezaxis", "objname")]
+  [TestCase("framelinvel", "objname")]
+  [TestCase("frameangvel", "objname")]
+  [TestCase("framelinacc", "objname")]
+  [TestCase("frameangacc", "objname")]
+  public void ParsingFrameSiteName(string tag, string siteAttribute) {
+    var mjcfString = $"<sensors><{tag} {siteAttribute}=\"site\"/></sensors>";
+    var mjcfElement = Parse(mjcfString, tag);
+    _sensor.ParseMjcf(mjcfElement);
+    Assert.That(_sensor.Site, Is.EqualTo(_site));
+  }
+}
+}
diff --git a/unity/Tests/Editor/components/Sensors/MjSiteVectorSensorTests.cs.meta b/unity/Tests/Editor/components/Sensors/MjSiteVectorSensorTests.cs.meta
new file mode 100644
index 00000000..81a80b89
--- /dev/null
+++ b/unity/Tests/Editor/components/Sensors/MjSiteVectorSensorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 8f9f930ccc5684f279f5e2ca0ec29cc8
+timeCreated: 1548171912
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes.meta b/unity/Tests/Editor/components/Shapes.meta
new file mode 100644
index 00000000..1f5a5306
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6cee6252a3cdc9a24a25b7cc99be3392
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes/MeshGeneratorsTests.cs b/unity/Tests/Editor/components/Shapes/MeshGeneratorsTests.cs
new file mode 100644
index 00000000..57718db0
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MeshGeneratorsTests.cs
@@ -0,0 +1,174 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools.Utils;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MeshGeneratorsEditorTests {
+    [Test]
+    public void FirstAndLastVerticalSlicesContainVerticesLocatedInTheSamePlace() {
+      var meshData = MeshGenerators.BuildSphere(scale: Vector3.one, numVerticalSlices: 4,
+                                                numHorizontalSlices: 3);
+      var vertices = meshData.Item1;
+      Assert.That(vertices[0], Is.EqualTo(vertices[1]));
+      Assert.That(vertices[1], Is.EqualTo(vertices[2]));
+      Assert.That(vertices[2], Is.EqualTo(vertices[3]));
+      Assert.That(vertices[8], Is.EqualTo(vertices[9]));
+      Assert.That(vertices[9], Is.EqualTo(vertices[10]));
+      Assert.That(vertices[10], Is.EqualTo(vertices[11]));
+    }
+
+    [Test]
+    public void GeneratedSphereWithProperScaling() {
+      var scale = new Vector3(0.5f, 2, 3);
+      var meshData =
+          MeshGenerators.BuildSphere(scale: scale, numVerticalSlices: 4, numHorizontalSlices: 3);
+      var vertices = meshData.Item1;
+      // One of the vertices of the bottom cap.
+      Assert.That(vertices[0], Is.EqualTo(Vector3.down * scale.y).Using(Vector3ComparerWithEqualsOperator.Instance));
+      // One of the vertices of the top cap.
+      Assert.That(vertices[8], Is.EqualTo(Vector3.up * scale.y).Using(Vector3ComparerWithEqualsOperator.Instance));
+      // The sides.
+      Assert.That(vertices[4], Is.EqualTo(Vector3.right * scale.x).Using(Vector3ComparerWithEqualsOperator.Instance));
+      Assert.That(vertices[5], Is.EqualTo(Vector3.back * scale.z).Using(Vector3ComparerWithEqualsOperator.Instance));
+      Assert.That(vertices[6], Is.EqualTo(Vector3.left * scale.x).Using(Vector3ComparerWithEqualsOperator.Instance));
+      Assert.That(vertices[7],
+                  Is.EqualTo(Vector3.forward * scale.z).Using(Vector3ComparerWithEqualsOperator.Instance));
+    }
+
+    [Test]
+    public void GeneratedCylinderHasCorrectHeight() {
+      var meshData = MeshGenerators.BuildCylinder(radius: 1.0f, height: 5.0f, numVerticalSlices: 4);
+      var bottomVertex =
+          meshData.Item1.Aggregate((result, item) => result.y < item.y ? result : item);
+      var topVertex = meshData.Item1.Aggregate((result, item) => result.y > item.y ? result : item);
+      Assert.That(topVertex.y - bottomVertex.y, Is.EqualTo(5.0f).Within(1e-3f));
+    }
+
+    [Test]
+    public void GeneratedCylinderHasCorrectRadius() {
+      var meshData = MeshGenerators.BuildCylinder(radius: 2.0f, height: 1.0f, numVerticalSlices: 4);
+      var averageRadius =
+          meshData.Item1.Select(v => new Vector3(v.x, 0, v.z).magnitude).Average(radius => radius);
+      Assert.That(averageRadius, Is.EqualTo(2.0f).Within(1e-3f));
+    }
+
+    [Test]
+    public void GeneratedCapsuleHasCorrectHeight() {
+      var meshData = MeshGenerators.BuildCapsule(radius: 1.0f, height: 5.0f, numVerticalSlices: 4,
+                                                 numHorizontalSlices: 3);
+      var bottomVertex =
+          meshData.Item1.Aggregate((result, item) => result.y < item.y ? result : item);
+      var topVertex = meshData.Item1.Aggregate((result, item) => result.y > item.y ? result : item);
+      // The height of the capsule is the height of the body plus the diameter of the sphere that
+      // forms the bases.
+      Assert.That(topVertex.y - bottomVertex.y, Is.EqualTo(5.0f).Within(1e-3f));
+    }
+
+    [Test]
+    public void GeneratedCapsuleHasCorrectRadius() {
+      var meshData = MeshGenerators.BuildCapsule(radius: 2.0f, height: 3.0f, numVerticalSlices: 4,
+                                                 numHorizontalSlices: 3);
+      var averageRadius = meshData.Item1.Where(v => Math.Abs(v.y) <= 0.5f)
+                              .Select(v => new Vector3(v.x, 0, v.z).magnitude)
+                              .Average(radius => radius);
+      Assert.That(averageRadius, Is.EqualTo(2.0f).Within(1e-3f));
+    }
+
+    [Test]
+    public void GeneratedBoxHasCorrectExtents() {
+      var extents = new Vector3(0.5f, 2, 3);
+      var meshData = MeshGenerators.BuildBox(extents: extents);
+      var minVertex = meshData.Item1.Aggregate(
+          (result, item) =>
+              (result.x + result.y + result.z) < (item.x + item.y + item.z) ? result : item);
+      var maxVertex = meshData.Item1.Aggregate(
+          (result, item) =>
+              (result.x + result.y + result.z) > (item.x + item.y + item.z) ? result : item);
+      Assert.That(minVertex, Is.EqualTo(extents * -1.0f).Using(Vector3ComparerWithEqualsOperator.Instance));
+      Assert.That(maxVertex, Is.EqualTo(extents).Using(Vector3ComparerWithEqualsOperator.Instance));
+    }
+
+    [Test]
+    public void GeneratedBoxTriangleMapIsAListOfConsecutiveIntegers() {
+      var meshData = MeshGenerators.BuildBox(extents: Vector3.one);
+      Assert.That(meshData.Item2, Has.Length.EqualTo(36));
+      for (var i = 0; i < 36; ++i) {
+        Assert.That(meshData.Item2[i], Is.EqualTo(i));
+      }
+    }
+
+    [Test]
+    public void GeneratedPlaneHasCorrectExtents() {
+      var meshData = MeshGenerators.BuildPlane(width: 2, height: 3);
+      var minVertex = meshData.Item1.Aggregate(
+          (result, item) => (result.x + result.z) < (item.x + item.z) ? result : item);
+      var maxVertex = meshData.Item1.Aggregate(
+          (result, item) => (result.x + result.z) > (item.x + item.z) ? result : item);
+      Assert.That(minVertex, Is.EqualTo(new Vector3(-1, 0, -1.5f)).Using(Vector3ComparerWithEqualsOperator.Instance));
+      Assert.That(maxVertex, Is.EqualTo(new Vector3(1, 0, 1.5f)).Using(Vector3ComparerWithEqualsOperator.Instance));
+    }
+  }
+
+  [TestFixture]
+  public class MeshMergerEditorTests {
+    private MeshMerger _meshMerger;
+
+    [SetUp]
+    public void SetUp() {
+      _meshMerger = new MeshMerger();
+    }
+
+    [Test]
+    public void AddingMeshVerticesAggregatesThem() {
+      _meshMerger.Add(vertices: new Vector3[] { Vector3.one }, triangles: new int[] {});
+      Assert.That(_meshMerger.Vertices, Has.Length.EqualTo(1));
+      _meshMerger.Add(vertices: new Vector3[] { Vector3.forward }, triangles: new int[] {});
+      Assert.That(_meshMerger.Vertices, Has.Length.EqualTo(2));
+      Assert.That(_meshMerger.Vertices[0], Is.EqualTo(Vector3.one));
+      Assert.That(_meshMerger.Vertices[1], Is.EqualTo(Vector3.forward));
+    }
+
+    [Test]
+    public void TriangleIndicesAreOffsetToPointAtTheCorrespondingMeshes() {
+      _meshMerger.Add(vertices: new Vector3[] { Vector3.right, Vector3.up },
+                      triangles: new int[] { 0, 1 });
+      _meshMerger.Add(vertices: new Vector3[] { Vector3.forward, Vector3.zero },
+                      triangles: new int[] { 0, 1 });
+      Assert.That(_meshMerger.Triangles, Has.Length.EqualTo(4));
+      Assert.That(_meshMerger.Vertices[_meshMerger.Triangles[0]], Is.EqualTo(Vector3.right));
+      Assert.That(_meshMerger.Vertices[_meshMerger.Triangles[1]], Is.EqualTo(Vector3.up));
+      Assert.That(_meshMerger.Vertices[_meshMerger.Triangles[2]], Is.EqualTo(Vector3.forward));
+      Assert.That(_meshMerger.Vertices[_meshMerger.Triangles[3]], Is.EqualTo(Vector3.zero));
+    }
+
+    [Test]
+    public void TranslatingAddedVertices() {
+      _meshMerger.AddAndTranslate(vertices: new Vector3[] { Vector3.zero }, triangles: new int[] {},
+                                  translation: Vector3.right);
+      _meshMerger.AddAndTranslate(vertices: new Vector3[] { Vector3.zero }, triangles: new int[] {},
+                                  translation: Vector3.up);
+      Assert.That(_meshMerger.Vertices[0], Is.EqualTo(Vector3.right));
+      Assert.That(_meshMerger.Vertices[1], Is.EqualTo(Vector3.up));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Shapes/MeshGeneratorsTests.cs.meta b/unity/Tests/Editor/components/Shapes/MeshGeneratorsTests.cs.meta
new file mode 100644
index 00000000..511ad8ad
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MeshGeneratorsTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d757196bb4bbd7d0d8eddc399cfeddef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes/MjBoxShapeTests.cs b/unity/Tests/Editor/components/Shapes/MjBoxShapeTests.cs
new file mode 100644
index 00000000..52e68014
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjBoxShapeTests.cs
@@ -0,0 +1,104 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjBoxShapeTests {
+    private GameObject _owner;
+    private MjShapeComponent _shape;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _owner = new GameObject("owner");
+      _shape = _owner.AddComponent<MjSite>();
+      _shape.ShapeType = MjShapeComponent.ShapeTypes.Box;
+      _shape.Box.Extents = Vector3.one;
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_owner);
+    }
+
+    [TestCase(1, 2, 3, "1 3 2")]
+    public void BoxSize(float x, float y, float z, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _shape.Box.Extents = new Vector3(x, y, z);
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(0.5f, "0.5 0.5 0.5")]
+    [TestCase(2.0f, "2 2 2")]
+    public void EffectOfUniformScaling(float uniformScale, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _owner.transform.localScale = Vector3.one * uniformScale;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(2, 3, 4, "2 4 3")]
+    public void EffectOfNonUniformScaling(float x, float y, float z, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _owner.transform.localScale = new Vector3(x, y, z);
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [Test]
+    public void ParsingSettings() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "box");
+      mjcf.SetAttribute("size", "0.1 0.2 0.3");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Box));
+      Assert.That(_shape.Box.Extents, Is.EqualTo(new Vector3(0.1f, 0.3f, 0.2f)));
+    }
+
+    [TestCase("0 0 0 0 0 1", 0.5f, 0.5f, 0.5f)]
+    [TestCase("0 0 0 0 1 0", 0.5f, 0.5f, 0.5f)]
+    [TestCase("0 0 0 1 0 0", 0.5f, 0.5f, 0.5f)]
+    [TestCase("0 0 -1 0 0 1", 1, 1, 1)]
+    [TestCase("0 -1 0 0 1 0", 1, 1, 1)]
+    [TestCase("-1 0 0 1 0 0", 1, 1, 1)]
+    public void FromToSizeSpecificationIsOrientationAgnostic(string fromToStr, float x, float y,
+                                                             float z) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "box");
+      mjcf.SetAttribute("fromto", fromToStr);
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.Box.Extents, Is.EqualTo(new Vector3(x, y, z)));
+    }
+
+    [Test]
+    public void FromToSizeSpecificationUsesMagnitudeOfVectorAsSizeBase() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "box");
+      mjcf.SetAttribute("fromto", "-1 0 0 0 0 1");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That((_shape.Box.Extents - new Vector3(0.707f, 0.707f, 0.707f)).magnitude,
+                  Is.EqualTo(0).Within(1e-3f));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Shapes/MjBoxShapeTests.cs.meta b/unity/Tests/Editor/components/Shapes/MjBoxShapeTests.cs.meta
new file mode 100644
index 00000000..543480ed
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjBoxShapeTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: aec19e8fe359a4415a24f826721d003c
+timeCreated: 1547644312
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes/MjCapsuleShapeTests.cs b/unity/Tests/Editor/components/Shapes/MjCapsuleShapeTests.cs
new file mode 100644
index 00000000..28bef3cb
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjCapsuleShapeTests.cs
@@ -0,0 +1,96 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjCapsuleShapeTests {
+    private GameObject _owner;
+    private MjShapeComponent _shape;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _owner = new GameObject("owner");
+      _shape = _owner.AddComponent<MjSite>();
+      _shape.ShapeType = MjShapeComponent.ShapeTypes.Capsule;
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_owner);
+    }
+
+    [TestCase(0.5f, 0.5f, "0.5 0.5")]
+    [TestCase(1.5f, 1.5f, "1.5 1.5")]
+    public void CapsuleSize(float radius, float halfHeight, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _shape.Capsule.Radius = radius;
+      _shape.Capsule.HalfHeight = halfHeight;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(0.5f, "0.5 1")]
+    [TestCase(2.0f, "2 4")]
+    public void EffectOfUniformScaling(float uniformScale, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _shape.Capsule.Radius = 1.0f;
+      _shape.Capsule.HalfHeight = 2.0f;
+      _owner.transform.localScale = Vector3.one * uniformScale;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [Test]
+    public void ParsingSettings() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "capsule");
+      mjcf.SetAttribute("size", "1.5 2.4");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Capsule));
+      Assert.That(_shape.Capsule.Radius, Is.EqualTo(1.5f));
+      Assert.That(_shape.Capsule.HalfHeight, Is.EqualTo(2.4f));
+    }
+
+    [Test]
+    public void FromToSizeSpecificationOverridesHeightOnly() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "capsule");
+      mjcf.SetAttribute("size", "5 1");
+      mjcf.SetAttribute("fromto", "0 0 0 0 0 3");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.Capsule.Radius, Is.EqualTo(5));
+      Assert.That(_shape.Capsule.HalfHeight, Is.EqualTo(1.5f));
+    }
+
+    [TestCase("0 0 -1 0 0 2", 1.5f)]
+    [TestCase("1 0 0 3 0 0", 1)]
+    public void FromToHeightMeasuredAsSegmentLength(string fromToStr, float expectedHeight) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "capsule");
+      mjcf.SetAttribute("fromto", fromToStr);
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.Capsule.HalfHeight, Is.EqualTo(expectedHeight));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Shapes/MjCapsuleShapeTests.cs.meta b/unity/Tests/Editor/components/Shapes/MjCapsuleShapeTests.cs.meta
new file mode 100644
index 00000000..8a7e707d
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjCapsuleShapeTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9871b9790c4594f638a5bd00d660e897
+timeCreated: 1547635214
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes/MjCylinderShapeTests.cs b/unity/Tests/Editor/components/Shapes/MjCylinderShapeTests.cs
new file mode 100644
index 00000000..34c95e41
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjCylinderShapeTests.cs
@@ -0,0 +1,96 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjCylinderShapeTests {
+    private GameObject _owner;
+    private MjShapeComponent _shape;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _owner = new GameObject("owner");
+      _shape = _owner.AddComponent<MjSite>();
+      _shape.ShapeType = MjShapeComponent.ShapeTypes.Cylinder;
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_owner);
+    }
+
+    [TestCase(0.5f, 0.5f, "0.5 0.5")]
+    [TestCase(1.5f, 1.5f, "1.5 1.5")]
+    public void CylinderSize(float radius, float height, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _shape.Cylinder.Radius = radius;
+      _shape.Cylinder.HalfHeight = height;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(0.5f, "0.5 1")]
+    [TestCase(2.0f, "2 4")]
+    public void EffectOfUniformScaling(float uniformScale, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _shape.Cylinder.Radius = 1.0f;
+      _shape.Cylinder.HalfHeight = 2.0f;
+      _owner.transform.localScale = Vector3.one * uniformScale;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [Test]
+    public void ParsingSettings() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "cylinder");
+      mjcf.SetAttribute("size", "1.5 2.4");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Cylinder));
+      Assert.That(_shape.Cylinder.Radius, Is.EqualTo(1.5f));
+      Assert.That(_shape.Cylinder.HalfHeight, Is.EqualTo(2.4f));
+    }
+
+    [Test]
+    public void FromToSizeSpecificationOverridesHeightOnly() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "cylinder");
+      mjcf.SetAttribute("size", "5 1");
+      mjcf.SetAttribute("fromto", "0 0 0 0 0 3");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.Cylinder.Radius, Is.EqualTo(5));
+      Assert.That(_shape.Cylinder.HalfHeight, Is.EqualTo(1.5f));
+    }
+
+    [TestCase("0 0 -1 0 0 2", 1.5f)]
+    [TestCase("1 0 0 3 0 0", 1)]
+    public void FromToHeightMeasuredAsSegmentLength(string fromToStr, float expectedHeight) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "cylinder");
+      mjcf.SetAttribute("fromto", fromToStr);
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.Cylinder.HalfHeight, Is.EqualTo(expectedHeight));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Shapes/MjCylinderShapeTests.cs.meta b/unity/Tests/Editor/components/Shapes/MjCylinderShapeTests.cs.meta
new file mode 100644
index 00000000..99ce8138
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjCylinderShapeTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: cb7edb2ed8966435991a52ed46024185
+timeCreated: 1547729698
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes/MjEllipsoidShapeTests.cs b/unity/Tests/Editor/components/Shapes/MjEllipsoidShapeTests.cs
new file mode 100644
index 00000000..ca44b636
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjEllipsoidShapeTests.cs
@@ -0,0 +1,104 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjEllipsoidShapeTests {
+    private GameObject _owner;
+    private MjShapeComponent _shape;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _owner = new GameObject("owner");
+      _shape = _owner.AddComponent<MjSite>();
+      _shape.ShapeType = MjShapeComponent.ShapeTypes.Ellipsoid;
+      _shape.Ellipsoid.Radiuses = Vector3.one;
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_owner);
+    }
+
+    [TestCase(1, 2, 3, "1 3 2")]
+    public void EllipsoidSize(float x, float y, float z, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _shape.Ellipsoid.Radiuses = new Vector3(x, y, z);
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(0.5f, "0.5 0.5 0.5")]
+    [TestCase(2.0f, "2 2 2")]
+    public void EffectOfUniformScaling(float uniformScale, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _owner.transform.localScale = Vector3.one * uniformScale;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(2, 3, 4, "2 4 3")]
+    public void EffectOfNonUniformScaling(float x, float y, float z, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _owner.transform.localScale = new Vector3(x, y, z);
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [Test]
+    public void ParsingSettings() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "ellipsoid");
+      mjcf.SetAttribute("size", "0.1 0.2 0.3");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Ellipsoid));
+      Assert.That(_shape.Ellipsoid.Radiuses, Is.EqualTo(new Vector3(0.1f, 0.3f, 0.2f)));
+    }
+
+    [TestCase("0 0 0 0 0 1", 0.5f, 0.5f, 0.5f)]
+    [TestCase("0 0 0 0 1 0", 0.5f, 0.5f, 0.5f)]
+    [TestCase("0 0 0 1 0 0", 0.5f, 0.5f, 0.5f)]
+    [TestCase("0 0 -1 0 0 1", 1, 1, 1)]
+    [TestCase("0 -1 0 0 1 0", 1, 1, 1)]
+    [TestCase("-1 0 0 1 0 0", 1, 1, 1)]
+    public void FromToSizeSpecificationIsOrientationAgnostic(string fromToStr, float x, float y,
+                                                             float z) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "ellipsoid");
+      mjcf.SetAttribute("fromto", fromToStr);
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.Ellipsoid.Radiuses, Is.EqualTo(new Vector3(x, y, z)));
+    }
+
+    [Test]
+    public void FromToSizeSpecificationUsesMagnitudeOfVectorAsSizeBase() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "ellipsoid");
+      mjcf.SetAttribute("fromto", "-1 0 0 0 0 1");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That((_shape.Ellipsoid.Radiuses - new Vector3(0.707f, 0.707f, 0.707f)).magnitude,
+                  Is.EqualTo(0).Within(1e-3f));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Shapes/MjEllipsoidShapeTests.cs.meta b/unity/Tests/Editor/components/Shapes/MjEllipsoidShapeTests.cs.meta
new file mode 100644
index 00000000..d9593fff
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjEllipsoidShapeTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 8fe14b804de054f709bd186df6160648
+timeCreated: 1547644312
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes/MjGizmosTests.cs b/unity/Tests/Editor/components/Shapes/MjGizmosTests.cs
new file mode 100644
index 00000000..279e46d4
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjGizmosTests.cs
@@ -0,0 +1,270 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjGizmosDrawArcTests {
+    [SetUp]
+    public void SetUp() {
+      MjGizmos.DrawLine = MockDrawLine;
+      MjGizmos.NumCircleSegments = 4;
+      _lineFrom = new List<Vector3>();
+      _lineTo = new List<Vector3>();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      MjGizmos.DrawLine = Gizmos.DrawLine;
+      MjGizmos.NumCircleSegments = 32;
+    }
+
+    private List<Vector3> _lineFrom;
+    private List<Vector3> _lineTo;
+
+    private void MockDrawLine(Vector3 from, Vector3 to) {
+      _lineFrom.Add(from);
+      _lineTo.Add(to);
+    }
+
+    [Test]
+    public void LineCountOfDrawnCircle() {
+      MjGizmos.DrawArc(Vector3.zero, 1.0f, Vector3.up, 1.0f, 0.0f);
+      Assert.That(_lineFrom, Has.Count.EqualTo(MjGizmos.NumCircleSegments));
+      Assert.That(_lineTo, Has.Count.EqualTo(MjGizmos.NumCircleSegments));
+    }
+
+    [Test]
+    public void LineAdjacencyOfDrawnCircle() {
+      MjGizmos.DrawArc(Vector3.zero, 1.0f, Vector3.up, 1.0f, 0.0f);
+      Assert.That((_lineFrom[0] - _lineTo[3]).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[1] - _lineTo[0]).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[2] - _lineTo[1]).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[3] - _lineTo[2]).magnitude, Is.LessThan(1e-3f));
+    }
+
+    [Test]
+    public void CircleVertexPositions() {
+      MjGizmos.DrawArc(Vector3.zero, 1.0f, Vector3.up, 1.0f, 0.0f);
+      Assert.That((_lineFrom[0] - new Vector3(0, 0, -1)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[1] - new Vector3(-1, 0, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[2] - new Vector3(0, 0, 1)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[3] - new Vector3(1, 0, 0)).magnitude, Is.LessThan(1e-3f));
+    }
+
+    [Test]
+    public void VerticesOfOffsetCircle() {
+      MjGizmos.DrawArc(Vector3.one, 1.0f, Vector3.up, 1.0f, 0.0f);
+      Assert.That((_lineFrom[0] - new Vector3(1, 1, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[1] - new Vector3(0, 1, 1)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[2] - new Vector3(1, 1, 2)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[3] - new Vector3(2, 1, 1)).magnitude, Is.LessThan(1e-3f));
+    }
+
+    [Test]
+    public void DrawingRotatedCircle() {
+      MjGizmos.DrawArc(Vector3.zero, 1.0f, Vector3.right, 1.0f, 0.0f);
+      Assert.That((_lineFrom[0] - new Vector3(0, 0, 1)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[1] - new Vector3(0, -1, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[2] - new Vector3(0, 0, -1)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineFrom[3] - new Vector3(0, 1, 0)).magnitude, Is.LessThan(1e-3f));
+    }
+
+    [Test]
+    public void DrawingHalfCircle() {
+      MjGizmos.DrawArc(Vector3.zero, 1.0f, Vector3.up, 0.25f, 0.0f);
+      Assert.That(_lineFrom, Has.Count.EqualTo(1));
+      Assert.That(_lineTo, Has.Count.EqualTo(1));
+      Assert.That((_lineFrom[0] - new Vector3(0, 0, -1)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineTo[0] - new Vector3(-1, 0, 0)).magnitude, Is.LessThan(1e-3f));
+    }
+
+    [Test]
+    public void DrawingHalfCircleWithOffsetCircumference() {
+      MjGizmos.DrawArc(Vector3.zero, 1.0f, Vector3.up, 0.25f, 90);
+      Assert.That((_lineFrom[0] - new Vector3(-1, 0, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_lineTo[0] - new Vector3(0, 0, 1)).magnitude, Is.LessThan(1e-3f));
+    }
+  }
+
+  [TestFixture]
+  public class MjGizmosCapsuleTests {
+    [SetUp]
+    public void SetUp() {
+      MjGizmos.DrawLine = MockDrawLine;
+      MjGizmos.DrawArc = MockDrawArc;
+      MjGizmos.NumCircleSegments = 4;
+      _arc = new List<Tuple<Vector3, float, Vector3, float, float>>();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      MjGizmos.DrawLine = Gizmos.DrawLine;
+      MjGizmos.DrawArc = MjGizmos.DrawArcInternal;
+      MjGizmos.NumCircleSegments = 32;
+    }
+
+    private List<Tuple<Vector3, float, Vector3, float, float>> _arc;
+
+    private void MockDrawLine(Vector3 from, Vector3 to) {}
+
+    private void MockDrawArc(Vector3 position, float radius, Vector3 axis, float length,
+                             float startAngle) {
+      _arc.Add(Tuple.Create(position, radius, axis, length, startAngle));
+    }
+
+    [Test]
+    public void NumberOfArcsUsedToDrawCapsule() {
+      MjGizmos.DrawWireCapsule(Vector3.zero, 0.5f, 1.0f);
+      Assert.That(_arc, Has.Count.EqualTo(6));
+    }
+
+    [Test]
+    public void CapsuleBaseCirclesOrigins() {
+      MjGizmos.DrawWireCapsule(Vector3.zero, 0.5f, 1.0f);
+      Assert.That((_arc[0].Item1 - new Vector3(0, 0.5f, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_arc[1].Item1 - new Vector3(0, -0.5f, 0)).magnitude, Is.LessThan(1e-3f));
+    }
+
+    [Test]
+    public void CapsuleBaseCirclesRadiuses() {
+      MjGizmos.DrawWireCapsule(Vector3.zero, 0.5f, 1.0f);
+      Assert.That(_arc[0].Item2, Is.EqualTo(0.5f));
+      Assert.That(_arc[1].Item2, Is.EqualTo(0.5f));
+    }
+
+    [Test]
+    public void CapsuleBaseArcsOrigins() {
+      MjGizmos.DrawWireCapsule(Vector3.zero, 0.5f, 1.0f);
+      Assert.That((_arc[2].Item1 - new Vector3(0, -0.5f, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_arc[3].Item1 - new Vector3(0, 0.5f, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_arc[4].Item1 - new Vector3(0, 0.5f, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_arc[5].Item1 - new Vector3(0, -0.5f, 0)).magnitude, Is.LessThan(1e-3f));
+    }
+
+    [Test]
+    public void CapsuleBaseArcsRadiuses() {
+      MjGizmos.DrawWireCapsule(Vector3.zero, 0.5f, 1.0f);
+      Assert.That(_arc[2].Item2, Is.EqualTo(0.5f));
+      Assert.That(_arc[3].Item2, Is.EqualTo(0.5f));
+      Assert.That(_arc[4].Item2, Is.EqualTo(0.5f));
+      Assert.That(_arc[5].Item2, Is.EqualTo(0.5f));
+    }
+  }
+
+  [TestFixture]
+  public class MjGizmosCylinderTests {
+    [SetUp]
+    public void SetUp() {
+      MjGizmos.DrawLine = MockDrawLine;
+      MjGizmos.DrawArc = MockDrawArc;
+      MjGizmos.NumCircleSegments = 4;
+      _arc = new List<Tuple<Vector3, float, Vector3, float, float>>();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      MjGizmos.DrawLine = Gizmos.DrawLine;
+      MjGizmos.DrawArc = MjGizmos.DrawArcInternal;
+      MjGizmos.NumCircleSegments = 32;
+    }
+
+    private List<Tuple<Vector3, float, Vector3, float, float>> _arc;
+
+    private void MockDrawLine(Vector3 from, Vector3 to) {}
+
+    private void MockDrawArc(Vector3 position, float radius, Vector3 axis, float length,
+                             float startAngle) {
+      _arc.Add(Tuple.Create(position, radius, axis, length, startAngle));
+    }
+
+    [Test]
+    public void NumberOfArcsUsedToDrawCylinder() {
+      MjGizmos.DrawWireCylinder(Vector3.zero, 0.5f, 1.0f);
+      Assert.That(_arc, Has.Count.EqualTo(2));
+    }
+
+    [Test]
+    public void CylinderBaseCirclesOrigins() {
+      MjGizmos.DrawWireCylinder(Vector3.zero, 0.5f, 1.0f);
+      Assert.That((_arc[0].Item1 - new Vector3(0, 0.5f, 0)).magnitude, Is.LessThan(1e-3f));
+      Assert.That((_arc[1].Item1 - new Vector3(0, -0.5f, 0)).magnitude, Is.LessThan(1e-3f));
+    }
+
+    [Test]
+    public void CylinderBaseCirclesRadiuses() {
+      MjGizmos.DrawWireCylinder(Vector3.zero, 0.5f, 1.0f);
+      Assert.That(_arc[0].Item2, Is.EqualTo(0.5f));
+      Assert.That(_arc[1].Item2, Is.EqualTo(0.5f));
+    }
+  }
+
+  [TestFixture]
+  public class MjGizmosPlaneTests {
+    [SetUp]
+    public void SetUp() {
+      MjGizmos.DrawLine = MockDrawLine;
+      _lines = new List<Tuple<Vector3, Vector3>>();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      MjGizmos.DrawLine = Gizmos.DrawLine;
+      _lines.Clear();
+    }
+
+    private List<Tuple<Vector3, Vector3>> _lines;
+
+    private void MockDrawLine(Vector3 start, Vector3 end) {
+      _lines.Add(Tuple.Create(start, end));
+    }
+
+    [Test]
+    public void DrawingPlaneAroundArbitraryCenter() {
+      MjGizmos.DrawWirePlane(new Vector3(1, 2, 3), 1, 1);
+      Assert.That(_lines, Has.Count.EqualTo(5));
+      Assert.That(_lines[0].Item1, Is.EqualTo(new Vector3(0.5f, 2, 2.5f)));
+      Assert.That(_lines[0].Item2, Is.EqualTo(new Vector3(1.5f, 2, 2.5f)));
+      Assert.That(_lines[1].Item1, Is.EqualTo(new Vector3(1.5f, 2, 2.5f)));
+      Assert.That(_lines[1].Item2, Is.EqualTo(new Vector3(1.5f, 2, 3.5f)));
+      Assert.That(_lines[2].Item1, Is.EqualTo(new Vector3(1.5f, 2, 3.5f)));
+      Assert.That(_lines[2].Item2, Is.EqualTo(new Vector3(0.5f, 2, 3.5f)));
+      Assert.That(_lines[3].Item1, Is.EqualTo(new Vector3(0.5f, 2, 3.5f)));
+      Assert.That(_lines[3].Item2, Is.EqualTo(new Vector3(0.5f, 2, 2.5f)));
+      Assert.That(_lines[4].Item1, Is.EqualTo(new Vector3(0.5f, 2, 2.5f)));
+      Assert.That(_lines[4].Item2, Is.EqualTo(new Vector3(1.5f, 2, 3.5f)));
+    }
+
+    [Test]
+    public void DrawingPlaneWithCorrectDimensions() {
+      MjGizmos.DrawWirePlane(Vector3.zero, width: 2, height: 4);
+      Assert.That(_lines[0].Item1, Is.EqualTo(new Vector3(-1, 0, -2)));
+      Assert.That(_lines[0].Item2, Is.EqualTo(new Vector3(1, 0, -2)));
+      Assert.That(_lines[1].Item1, Is.EqualTo(new Vector3(1, 0, -2)));
+      Assert.That(_lines[1].Item2, Is.EqualTo(new Vector3(1, 0, 2)));
+      Assert.That(_lines[2].Item1, Is.EqualTo(new Vector3(1, 0, 2)));
+      Assert.That(_lines[2].Item2, Is.EqualTo(new Vector3(-1, 0, 2)));
+      Assert.That(_lines[3].Item1, Is.EqualTo(new Vector3(-1, 0, 2)));
+      Assert.That(_lines[3].Item2, Is.EqualTo(new Vector3(-1, 0, -2)));
+      Assert.That(_lines[4].Item1, Is.EqualTo(new Vector3(-1, 0, -2)));
+      Assert.That(_lines[4].Item2, Is.EqualTo(new Vector3(1, 0, 2)));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Shapes/MjGizmosTests.cs.meta b/unity/Tests/Editor/components/Shapes/MjGizmosTests.cs.meta
new file mode 100644
index 00000000..bd1793e3
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjGizmosTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: a8a01c1e2d4304ce78d8efc6150f2f87
+timeCreated: 1536937372
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes/MjPlaneShapeTests.cs b/unity/Tests/Editor/components/Shapes/MjPlaneShapeTests.cs
new file mode 100644
index 00000000..0fb4540b
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjPlaneShapeTests.cs
@@ -0,0 +1,78 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjPlaneShapeTests {
+    private GameObject _owner;
+    private MjShapeComponent _shape;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _owner = new GameObject("owner");
+      _shape = _owner.AddComponent<MjSite>();
+      _shape.ShapeType = MjShapeComponent.ShapeTypes.Plane;
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_owner);
+    }
+
+    [TestCase(1, 2, "1 2 1")]
+    public void PlaneSize(float x, float y, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _shape.Plane.Extents = new Vector2(x, y);
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(0.5f, "0.5 0.5 0.5")]
+    [TestCase(2.0f, "2 2 2")]
+    public void EffectOfUniformScaling(float uniformScale, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _owner.transform.localScale = Vector3.one * uniformScale;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(2, 3, 4, "2 3 4")]
+    public void EffectOfNonUniformScaling(float x, float y, float z, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _owner.transform.localScale = new Vector3(x, y, z);
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [Test]
+    public void ParsingSettings() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "plane");
+      mjcf.SetAttribute("size", "0.1 0.2 0.3");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Plane));
+      Assert.That(_shape.Plane.Extents, Is.EqualTo(new Vector2(0.1f, 0.2f)));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Shapes/MjPlaneShapeTests.cs.meta b/unity/Tests/Editor/components/Shapes/MjPlaneShapeTests.cs.meta
new file mode 100644
index 00000000..d4c1d50f
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjPlaneShapeTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: b37384fec57304bfbb4edd50d7f2f80a
+timeCreated: 1547644312
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Shapes/MjSphereShapeTests.cs b/unity/Tests/Editor/components/Shapes/MjSphereShapeTests.cs
new file mode 100644
index 00000000..ca6db033
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjSphereShapeTests.cs
@@ -0,0 +1,72 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjSphereShapeTests {
+    private GameObject _owner;
+    private MjShapeComponent _shape;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _owner = new GameObject("owner");
+      _shape = _owner.AddComponent<MjSite>();
+      _shape.ShapeType = MjShapeComponent.ShapeTypes.Sphere;
+      _shape.Sphere.Radius = 1.0f;
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_owner);
+    }
+
+    [TestCase(2.0f, "2")]
+    [TestCase(1.5f, "1.5")]
+    public void XmlSizeForUnscaledSphere(float radius, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _shape.Sphere.Radius = radius;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [TestCase(0.5f, "0.5")]
+    [TestCase(2.0f, "2")]
+    public void EffectOfUniformScaling(float uniformScale, string expectedResult) {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      _owner.transform.localScale = Vector3.one * uniformScale;
+      _shape.ShapeToMjcf(mjcf, _owner.transform);
+      Assert.That(_doc.OuterXml, Does.Contain("size=\"" + expectedResult + "\""));
+    }
+
+    [Test]
+    public void ParsingSettings() {
+      var mjcf = (XmlElement)_doc.AppendChild(_doc.CreateElement("test"));
+      mjcf.SetAttribute("type", "sphere");
+      mjcf.SetAttribute("size", "0.75");
+      _shape.ShapeFromMjcf(mjcf);
+      Assert.That(_shape.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Sphere));
+      Assert.That(_shape.Sphere.Radius, Is.EqualTo(0.75f));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Shapes/MjSphereShapeTests.cs.meta b/unity/Tests/Editor/components/Shapes/MjSphereShapeTests.cs.meta
new file mode 100644
index 00000000..9beda98c
--- /dev/null
+++ b/unity/Tests/Editor/components/Shapes/MjSphereShapeTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 11e6a66435b9b4c79b38438dfe92b14d
+timeCreated: 1547635214
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Tendons.meta b/unity/Tests/Editor/components/Tendons.meta
new file mode 100644
index 00000000..5bf9b0ee
--- /dev/null
+++ b/unity/Tests/Editor/components/Tendons.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7a0617b3ff610c7f1929e31ec82c7e75
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Tendons/MjFixedTendonTests.cs b/unity/Tests/Editor/components/Tendons/MjFixedTendonTests.cs
new file mode 100644
index 00000000..22d4b0f9
--- /dev/null
+++ b/unity/Tests/Editor/components/Tendons/MjFixedTendonTests.cs
@@ -0,0 +1,60 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+  [TestFixture]
+  public class MjFixedTendonTests {
+    private MjHingeJoint _joint1;
+    private MjHingeJoint _joint2;
+    private MjFixedTendon _tendon;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _joint1 = new GameObject("joint1").AddComponent<MjHingeJoint>();
+      _joint2 = new GameObject("joint2").AddComponent<MjHingeJoint>();
+      _tendon = new GameObject("tendon").AddComponent<MjFixedTendon>();
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_tendon.gameObject);
+      UnityEngine.Object.DestroyImmediate(_joint1.gameObject);
+      UnityEngine.Object.DestroyImmediate(_joint2.gameObject);
+      UnityEngine.Object.DestroyImmediate(MjScene.Instance);
+    }
+
+    [Test]
+    public void ParseAllSettings() {
+      _doc.LoadXml("<fixed range='3 4'>" + "<joint joint='joint1' coef='1'/>" +
+                   "<joint joint='joint2' coef='2'/>" + "</fixed>");
+      _tendon.ParseMjcf(_doc.GetElementsByTagName("fixed")[0] as XmlElement);
+      Assert.That(_tendon.RangeLower, Is.EqualTo(3));
+      Assert.That(_tendon.RangeUpper, Is.EqualTo(4));
+      Assert.That(_tendon.JointList.Count, Is.EqualTo(2));
+      Assert.That(_tendon.JointList[0].Joint, Is.EqualTo(_joint1));
+      Assert.That(_tendon.JointList[0].Coefficient, Is.EqualTo(1.0f));
+      Assert.That(_tendon.JointList[1].Joint, Is.EqualTo(_joint2));
+      Assert.That(_tendon.JointList[1].Coefficient, Is.EqualTo(2.0f));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Tendons/MjFixedTendonTests.cs.meta b/unity/Tests/Editor/components/Tendons/MjFixedTendonTests.cs.meta
new file mode 100644
index 00000000..f3ccccf2
--- /dev/null
+++ b/unity/Tests/Editor/components/Tendons/MjFixedTendonTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 839d86acac1494dba9a7617f96ba27df
+timeCreated: 1550658312
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/components/Tendons/MjSpatialTendonTests.cs b/unity/Tests/Editor/components/Tendons/MjSpatialTendonTests.cs
new file mode 100644
index 00000000..060063a6
--- /dev/null
+++ b/unity/Tests/Editor/components/Tendons/MjSpatialTendonTests.cs
@@ -0,0 +1,56 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+  [TestFixture]
+  public class MjSpatialTendonTests {
+    private MjSite _site1;
+    private MjSite _site2;
+    private MjSpatialTendon _tendon;
+    private XmlDocument _doc;
+
+    [SetUp]
+    public void SetUp() {
+      _site1 = new GameObject("site1").AddComponent<MjSite>();
+      _site2 = new GameObject("site2").AddComponent<MjSite>();
+      _tendon = new GameObject("tendon").AddComponent<MjSpatialTendon>();
+      _doc = new XmlDocument();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_tendon.gameObject);
+      UnityEngine.Object.DestroyImmediate(_site1.gameObject);
+      UnityEngine.Object.DestroyImmediate(_site2.gameObject);
+      UnityEngine.Object.DestroyImmediate(MjScene.Instance);
+    }
+
+    [Test]
+    public void ParseAllSettings() {
+      _doc.LoadXml("<spatial>" + "<site site='site1'/>" +
+                   "<site site='site2'/>" + "</spatial>");
+      _tendon.ParseMjcf(_doc.GetElementsByTagName("spatial")[0] as XmlElement);
+      Assert.That(_tendon.ViapointsList.Count, Is.EqualTo(2));
+      Assert.That(_tendon.ViapointsList[0].Site, Is.EqualTo(_site1));
+      Assert.That(_tendon.ViapointsList[1].Site, Is.EqualTo(_site2));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/components/Tendons/MjSpatialTendonTests.cs.meta b/unity/Tests/Editor/components/Tendons/MjSpatialTendonTests.cs.meta
new file mode 100644
index 00000000..ce161516
--- /dev/null
+++ b/unity/Tests/Editor/components/Tendons/MjSpatialTendonTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e8324e6aceb78a067801d2bc304e4a27
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/importer.meta b/unity/Tests/Editor/importer.meta
new file mode 100644
index 00000000..b84211f1
--- /dev/null
+++ b/unity/Tests/Editor/importer.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f84e327ea7163a015a7d81508e6828c6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/importer/MjImporterTests.cs b/unity/Tests/Editor/importer/MjImporterTests.cs
new file mode 100644
index 00000000..5b4b19e6
--- /dev/null
+++ b/unity/Tests/Editor/importer/MjImporterTests.cs
@@ -0,0 +1,185 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjMaterialImportTests {
+
+  private GameObject _sceneRoot;
+  private bool _removeLocal = false;
+  private bool _removeLocalMujoco = false;
+  private MjImporterWithAssets _importer;
+
+  [SetUp]
+  public void SetUp() {
+    _importer = new MjImporterWithAssets();
+    LogAssert.ignoreFailingMessages = true;
+    // these two directories may exist from previous imports
+    string[] assetsRoot = {"Assets"};
+    var guids = AssetDatabase.FindAssets("Local", assetsRoot);
+    if (guids.Length == 0) {
+      _removeLocal = true;
+      AssetDatabase.CreateFolder("Assets", "Local");
+    }
+    string[] assetsLocal = {"Assets/Local"};
+    guids = AssetDatabase.FindAssets("MjImports", assetsLocal);
+    if (guids.Length == 0) {
+      _removeLocalMujoco = true;
+    }
+  }
+
+  [TearDown]
+  public void TearDown() {
+    LogAssert.ignoreFailingMessages = false;
+    if (_sceneRoot != null) {
+      UnityEngine.Object.DestroyImmediate(_sceneRoot);
+    }
+    // remove main resources folder:
+    // string[] mainTestResources = {"Assets/Local/Mujoco/MjMaterialImportTests/Resources"};
+    // foreach (var asset in AssetDatabase.FindAssets("", mainTestResources)) {
+    //   AssetDatabase.DeleteAsset(AssetDatabase.GUIDToAssetPath(asset));
+    // }
+    // // remove main resources folder:
+    // AssetDatabase.DeleteAsset(mainTestResources[0]);
+    // remove all test folders:
+    string[] assetLocalMujoco = {"Assets/Local/MjImports"};
+    foreach (var asset in AssetDatabase.FindAssets("MjMaterialImportTests", assetLocalMujoco)) {
+      AssetDatabase.DeleteAsset(AssetDatabase.GUIDToAssetPath(asset));
+    }
+    if (_removeLocalMujoco) {
+      AssetDatabase.DeleteAsset("Assets/Local/MjImports");
+    }
+    if (_removeLocal) {
+      AssetDatabase.DeleteAsset("Assets/Local");
+    }
+  }
+
+  [Test]
+  public void ParsingMaterialProperties() {
+    var mjcfString = @"<mujoco>
+      <asset>
+        <material name='test_material'
+                  rgba='.7 .5 .3 .1' specular='.5' shininess='.7' reflectance='.2'/>
+      </asset>
+      <worldbody>
+        <body>
+          <geom name='test_geom' material='test_material' size='1 1 1'/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: "MjMaterialImportTests", mjcfString: mjcfString);
+    var geom = _sceneRoot.GetComponentInChildren<MjGeom>();
+    Assert.That(geom, Is.Not.Null);
+    var meshRenderer = geom.GetComponent<MeshRenderer>();
+    Assert.That(meshRenderer, Is.Not.Null);
+    Assert.That(meshRenderer.sharedMaterial, Is.Not.Null);
+    Assert.That(meshRenderer.sharedMaterial.color, Is.EqualTo(new Color(0.7f, 0.5f, 0.3f, 0.1f)));
+    Assert.That(meshRenderer.sharedMaterial.GetFloat("_Metallic"), Is.EqualTo(0.2f));
+    Assert.That(meshRenderer.sharedMaterial.GetFloat("_Glossiness"), Is.GreaterThan(0.0f));
+  }
+
+  [Test]
+  public void ParsingMaterialWithoutEmissivity() {
+    var mjcfString = @"<mujoco>
+      <asset>
+        <material name='test_material' rgba='.7 .5 .3 .1'/>
+      </asset>
+      <worldbody>
+        <body>
+          <geom name='test_geom' material='test_material' size='1 1 1'/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: "MjMaterialImportTests", mjcfString: mjcfString);
+    var geom = _sceneRoot.GetComponentInChildren<MjGeom>();
+    Assert.That(geom, Is.Not.Null);
+    var meshRenderer = geom.GetComponent<MeshRenderer>();
+    Assert.That(meshRenderer, Is.Not.Null);
+    Assert.That(meshRenderer.sharedMaterial, Is.Not.Null);
+    Assert.That(meshRenderer.sharedMaterial.shaderKeywords, Has.No.Member("_EMISSION"));
+  }
+
+  [Test]
+  public void ParsingMaterialWithEmissivity() {
+    var mjcfString = @"<mujoco>
+      <asset>
+        <material name='test_material' rgba='.7 .5 .3 .1' emission='1'/>
+      </asset>
+      <worldbody>
+        <body>
+          <geom name='test_geom' material='test_material' size='1 1 1'/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: "MjMaterialImportTests", mjcfString: mjcfString);
+    var geom = _sceneRoot.GetComponentInChildren<MjGeom>();
+    Assert.That(geom, Is.Not.Null);
+    var meshRenderer = geom.GetComponent<MeshRenderer>();
+    Assert.That(meshRenderer, Is.Not.Null);
+    Assert.That(meshRenderer.sharedMaterial, Is.Not.Null);
+    Assert.That(meshRenderer.sharedMaterial.shaderKeywords, Has.Member("_EMISSION"));
+    Assert.That(
+        meshRenderer.sharedMaterial.GetColor("_EmissionColor"),
+        Is.EqualTo(new Color(0.7f, 0.5f, 0.3f, 0.1f)));
+  }
+
+  [Test]
+  public void ResettingColorDatabaseForEachImport() {
+    var mjcfString1 = @"<mujoco>
+      <asset>
+        <material name='test_material' rgba='.2 .2 .2 .2'/>
+      </asset>
+      <worldbody>
+        <body>
+          <geom name='test_geom' material='test_material' size='1 1 1'/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    var mjcfString2 = @"<mujoco>
+      <asset>
+        <material name='test_material' rgba='.5 .5 .5 .5'/>
+      </asset>
+      <worldbody>
+        <body>
+          <geom name='test_geom' material='test_material' size='1 1 1'/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = new GameObject();
+    var importedMesh1 = _importer.ImportString(
+        name: "MjMaterialImportTests"+$"{UnityEngine.Random.Range(0,999)}", mjcfString: mjcfString1);
+    importedMesh1.transform.parent = _sceneRoot.transform;
+    var importedMesh2 = _importer.ImportString(
+        name: "MjMaterialImportTests"+$"{UnityEngine.Random.Range(0,999)}", mjcfString: mjcfString2);
+    importedMesh2.transform.parent = _sceneRoot.transform;
+    var geom = importedMesh2.GetComponentInChildren<MjGeom>();
+    var meshRenderer = geom.GetComponent<MeshRenderer>();
+    Assert.That(meshRenderer.sharedMaterial.color, Is.EqualTo(new Color(0.5f, 0.5f, 0.5f, 0.5f)));
+  }
+}
+}
diff --git a/unity/Tests/Editor/importer/MjImporterTests.cs.meta b/unity/Tests/Editor/importer/MjImporterTests.cs.meta
new file mode 100644
index 00000000..3aee5f4d
--- /dev/null
+++ b/unity/Tests/Editor/importer/MjImporterTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 3f8cfe95d25bf4da0b31bcb772f19c22
+timeCreated: 1538645397
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/importer/MjStlMeshParserTests.cs b/unity/Tests/Editor/importer/MjStlMeshParserTests.cs
new file mode 100644
index 00000000..4286eacb
--- /dev/null
+++ b/unity/Tests/Editor/importer/MjStlMeshParserTests.cs
@@ -0,0 +1,97 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjStlMeshParserTests {
+
+  private Mesh _originalMesh;
+
+  [SetUp]
+  public void SetUp() {
+    _originalMesh = new Mesh();
+    _originalMesh.vertices = new Vector3[] {
+        new Vector3(0, 0, 2), new Vector3(1, 0, 2), new Vector3(0, 1, 2)
+    };
+    _originalMesh.triangles = new int[] {0, 1, 2};
+    _originalMesh.normals = new Vector3[] {
+        new Vector3(0, 0, 1), new Vector3(0, 0, 1), new Vector3(0, 0, 1)
+    };
+  }
+
+  [Test]
+  public void RoundrobinMeshParsing() {
+    var serializedMesh = StlMeshParser.SerializeBinary(_originalMesh);
+    var restoredMesh = StlMeshParser.ParseBinary(serializedMesh, Vector3.one);
+
+    Assert.That(restoredMesh.vertices, Has.Length.EqualTo(_originalMesh.vertices.Length));
+    Assert.That(restoredMesh.normals, Has.Length.EqualTo(_originalMesh.normals.Length));
+    Assert.That(restoredMesh.triangles, Has.Length.EqualTo(_originalMesh.triangles.Length));
+  }
+
+  [Test]
+  public void VertexPositionsSerialization() {
+    var serializedMesh = StlMeshParser.SerializeBinary(_originalMesh);
+    var restoredMesh = StlMeshParser.ParseBinary(serializedMesh, Vector3.one);
+
+    Assert.That(
+        restoredMesh.vertices[restoredMesh.triangles[0]],
+        Is.EqualTo(_originalMesh.vertices[_originalMesh.triangles[0]]));
+    Assert.That(
+        restoredMesh.vertices[restoredMesh.triangles[1]],
+        Is.EqualTo(_originalMesh.vertices[_originalMesh.triangles[1]]));
+    Assert.That(
+        restoredMesh.vertices[restoredMesh.triangles[2]],
+        Is.EqualTo(_originalMesh.vertices[_originalMesh.triangles[2]]));
+  }
+
+  [Test]
+  public void ProcessDuplicatesSharedVertices() {
+    _originalMesh.triangles = new int[] {0, 0, 2};
+    var serializedMesh = StlMeshParser.SerializeBinary(_originalMesh);
+    var restoredMesh = StlMeshParser.ParseBinary(serializedMesh, Vector3.one);
+
+    Assert.That(
+        restoredMesh.vertices[restoredMesh.triangles[0]],
+        Is.EqualTo(_originalMesh.vertices[_originalMesh.triangles[0]]));
+    Assert.That(
+        restoredMesh.vertices[restoredMesh.triangles[1]],
+        Is.EqualTo(_originalMesh.vertices[_originalMesh.triangles[1]]));
+    Assert.That(
+        restoredMesh.vertices[restoredMesh.triangles[2]],
+        Is.EqualTo(_originalMesh.vertices[_originalMesh.triangles[2]]));
+  }
+
+  [Test]
+  public void VertexNormalsAreRcalculated() {
+    _originalMesh.normals = new Vector3[] {
+        new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1)
+    };
+    var serializedMesh = StlMeshParser.SerializeBinary(_originalMesh);
+    var restoredMesh = StlMeshParser.ParseBinary(serializedMesh, Vector3.one);
+
+    Assert.That(restoredMesh.normals[0], Is.EqualTo(Vector3.forward));
+    Assert.That(restoredMesh.normals[1], Is.EqualTo(Vector3.forward));
+    Assert.That(restoredMesh.normals[2], Is.EqualTo(Vector3.forward));
+  }
+}
+}
diff --git a/unity/Tests/Editor/importer/MjStlMeshParserTests.cs.meta b/unity/Tests/Editor/importer/MjStlMeshParserTests.cs.meta
new file mode 100644
index 00000000..6a8bc253
--- /dev/null
+++ b/unity/Tests/Editor/importer/MjStlMeshParserTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 95962f380898244f09d871fd35e28c0b
+timeCreated: 1561551392
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/importer/MjXmlModifiersTests.cs b/unity/Tests/Editor/importer/MjXmlModifiersTests.cs
new file mode 100644
index 00000000..2a4a7cb8
--- /dev/null
+++ b/unity/Tests/Editor/importer/MjXmlModifiersTests.cs
@@ -0,0 +1,256 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjDefaultSelectorsEditorTests {
+
+  private XmlElement SetUp(string mjcfString, string selector) {
+    var mjcf = new XmlDocument();
+    mjcf.LoadXml(mjcfString);
+    return mjcf.SelectSingleNode(selector) as XmlElement;
+  }
+
+  [TestCase("class")]
+  [TestCase("childclass")]
+  public void SelectingTopLevelClassDefault(string qualifier) {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <modified QUALIFIER=""class""/>
+      </worldbody>
+    </mujoco>".Replace("QUALIFIER", qualifier);
+    var modifiedNode = SetUp(mjcfString, "/mujoco/worldbody/modified");
+    var classes = MjXmlModifiers.GetApplicableDefaultClasses(modifiedNode).ToArray();
+    Assert.That(classes.Length, Is.EqualTo(1));
+    Assert.That(
+        classes[0], Is.EqualTo("class"));
+  }
+
+  [TestCase("class")]
+  [TestCase("childclass")]
+  public void SelectingNestedClassDefaultWithInheritance(string qualifier) {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <some_node childclass=""parent"">
+          <modified QUALIFIER=""child""/>
+        </some_node>
+      </worldbody>
+    </mujoco>".Replace("QUALIFIER", qualifier);
+    var modifiedNode = SetUp(mjcfString, "/mujoco/worldbody/some_node/modified");
+    var classes = MjXmlModifiers.GetApplicableDefaultClasses(modifiedNode).ToArray();
+
+    Assert.That(classes.Length, Is.EqualTo(2));
+    Assert.That(classes[0], Is.EqualTo("child"));
+    Assert.That(
+        classes[1], Is.EqualTo("parent"));
+  }
+
+  [TestCase("class")]
+  [TestCase("childclass")]
+  public void SelectingNestedClassDefaultWithoutInheritance(string qualifier) {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <some_node class=""parent"">
+          <modified QUALIFIER=""child""/>
+        </some_node>
+      </worldbody>
+    </mujoco>".Replace("QUALIFIER", qualifier);
+    var modifiedNode = SetUp(mjcfString, "/mujoco/worldbody/some_node/modified");
+    var classes = MjXmlModifiers.GetApplicableDefaultClasses(modifiedNode).ToArray();
+
+    Assert.That(classes.Length, Is.EqualTo(1));
+    Assert.That(classes[0], Is.EqualTo("child"));
+  }
+}
+
+[TestFixture]
+public class MjAttributeCopierEditorTests {
+
+  [Test]
+  public void CopyingXmlElementAttributes() {
+    var mjcfString = @"<root>
+      <tag_1 attr_1=""a"" attr_2=""b""/>
+      <tag_2/>
+    </root>";
+    var mjcf = new XmlDocument();
+    mjcf.LoadXml(mjcfString);
+    var tags = new XmlElement[] {
+        mjcf.SelectSingleNode("/root/tag_1") as XmlElement,
+        mjcf.SelectSingleNode("/root/tag_2") as XmlElement
+    };
+    MjXmlModifiers.CopyAttributes(tags[0], tags[1]);
+    // Reselect the element to make sure we're testing the actual part of the DOM, and not its copy.
+    var testedElement = mjcf.SelectSingleNode("/root/tag_2") as XmlElement;
+    Assert.That(testedElement.GetStringAttribute("attr_1", "unknown"), Is.EqualTo("a"));
+    Assert.That(testedElement.GetStringAttribute("attr_2", "unknown"), Is.EqualTo("b"));
+  }
+
+  [Test]
+  public void CopyingXmlElementAttributesWithoutOverwritingTheExistingOnes() {
+    var mjcfString = @"<root>
+      <tag_1 attr_1=""a"" attr_2=""b""/>
+      <tag_2 attr_1=""c""/>
+    </root>";
+    var mjcf = new XmlDocument();
+    mjcf.LoadXml(mjcfString);
+    var tags = new XmlElement[] {
+        mjcf.SelectSingleNode("/root/tag_1") as XmlElement,
+        mjcf.SelectSingleNode("/root/tag_2") as XmlElement
+    };
+    MjXmlModifiers.CopyAttributes(tags[0], tags[1]);
+    // Reselect the element to make sure we're testing the actual part of the DOM, and not its copy.
+    var testedElement = mjcf.SelectSingleNode("/root/tag_2") as XmlElement;
+    Assert.That(testedElement.GetStringAttribute("attr_1", "unknown"), Is.EqualTo("c"));
+    Assert.That(testedElement.GetStringAttribute("attr_2", "unknown"), Is.EqualTo("b"));
+  }
+
+  [Test]
+  public void CopyingXmlElementAttributesWithOverwritingTheExistingOnes() {
+    var mjcfString = @"<root>
+      <tag_1 attr_1=""a"" attr_2=""b""/>
+      <tag_2 attr_1=""c""/>
+    </root>";
+    var mjcf = new XmlDocument();
+    mjcf.LoadXml(mjcfString);
+    var tags = new XmlElement[] {
+        mjcf.SelectSingleNode("/root/tag_1") as XmlElement,
+        mjcf.SelectSingleNode("/root/tag_2") as XmlElement
+    };
+    MjXmlModifiers.CopyAttributesOverwriteExisting(tags[0], tags[1]);
+    // Reselect the element to make sure we're testing the actual part of the DOM, and not its copy.
+    var testedElement = mjcf.SelectSingleNode("/root/tag_2") as XmlElement;
+    Assert.That(testedElement.GetStringAttribute("attr_1", "unknown"), Is.EqualTo("a"));
+    Assert.That(testedElement.GetStringAttribute("attr_2", "unknown"), Is.EqualTo("b"));
+  }
+}
+
+[TestFixture]
+public class MjXmlModifiersIntegrationEditorTests {
+
+  [Test]
+  public void ApplyingDefaultsAggregatesAttributesFromMultipleDefaults() {
+    var mjcfString = @"<mujoco>
+      <default>
+        <modified attrib=""a""/>
+        <default class=""class"">
+          <modified attrib=""b""/>
+        </default>
+      </default>
+      <worldbody>
+        <modified class=""class""/>
+      </worldbody>
+    </mujoco>";
+
+    var mjcf = new XmlDocument();
+    mjcf.LoadXml(mjcfString);
+    var modifiedElement = mjcf.SelectSingleNode("/mujoco/worldbody/modified") as XmlElement;
+    var modifiers = new MjXmlModifiers(mjcf);
+    modifiers.ApplyModifiersToElement(modifiedElement);
+
+    modifiedElement = mjcf.SelectSingleNode("/mujoco/worldbody/modified") as XmlElement;
+    Assert.That(modifiedElement.GetStringAttribute("attrib", string.Empty), Is.EqualTo("b"));
+  }
+
+  [Test]
+  public void ApplyingDefaultsDoesntOverwriteTheExistingNodeAttribute() {
+    var mjcfString = @"<mujoco>
+      <default>
+        <modified attrib=""b""/>
+      </default>
+      <worldbody>
+        <modified attrib=""a""/>
+      </worldbody>
+    </mujoco>";
+
+    var mjcf = new XmlDocument();
+    mjcf.LoadXml(mjcfString);
+    var modifiedElement = mjcf.SelectSingleNode("/mujoco/worldbody/modified") as XmlElement;
+    var modifiers = new MjXmlModifiers(mjcf);
+    modifiers.ApplyModifiersToElement(modifiedElement);
+
+    modifiedElement = mjcf.SelectSingleNode("/mujoco/worldbody/modified") as XmlElement;
+    Assert.That(modifiedElement.GetStringAttribute("attrib", string.Empty), Is.EqualTo("a"));
+  }
+
+  [Test]
+  public void MissingDefaultDoesntBreakInheritanceHierarchy() {
+    var mjcfString = @"<mujoco>
+      <default>
+          <default class=""a"">
+              <default class=""b"">
+                  <geom type=""sphere""/>
+              </default>
+          </default>
+      </default>
+      <worldbody>
+          <body childclass=""a"">
+              <body childclass=""b"">
+                  <geom name=""thingy""/>
+              </body>
+          </body>
+      </worldbody>
+    </mujoco>";
+
+    var mjcf = new XmlDocument();
+    mjcf.LoadXml(mjcfString);
+    var modifiedElement = mjcf.SelectSingleNode("descendant::body/geom") as XmlElement;
+    var modifiers = new MjXmlModifiers(mjcf);
+    modifiers.ApplyModifiersToElement(modifiedElement);
+    Assert.That(modifiedElement.GetStringAttribute("name", string.Empty), Is.EqualTo("thingy"));
+    Assert.That(modifiedElement.GetStringAttribute("type", string.Empty), Is.EqualTo("sphere"));
+  }
+
+  [Test]
+  public void PropagatePropertiesAcrossDefaultHierarchy() {
+    var mjcfString = @"<mujoco>
+      <default>
+          <default class=""a"">
+              <geom attrib1=""from_a""/>
+              <default class=""b"">
+                  <geom attrib2=""from_b""/>
+              </default>
+          </default>
+      </default>
+      <worldbody>
+          <body>
+              <body>
+                  <body>
+                      <geom class=""b"" name=""thingy""/>
+                  </body>
+              </body>
+          </body>
+      </worldbody>
+    </mujoco>";
+
+    var mjcf = new XmlDocument();
+    mjcf.LoadXml(mjcfString);
+    var modifiedElement = mjcf.SelectSingleNode("descendant::body/geom") as XmlElement;
+    var modifiers = new MjXmlModifiers(mjcf);
+    modifiers.ApplyModifiersToElement(modifiedElement);
+    Assert.That(modifiedElement.GetStringAttribute("name", string.Empty), Is.EqualTo("thingy"));
+    Assert.That(modifiedElement.GetStringAttribute("attrib1", string.Empty), Is.EqualTo("from_a"));
+    Assert.That(modifiedElement.GetStringAttribute("attrib2", string.Empty), Is.EqualTo("from_b"));
+  }
+}
+}
diff --git a/unity/Tests/Editor/importer/MjXmlModifiersTests.cs.meta b/unity/Tests/Editor/importer/MjXmlModifiersTests.cs.meta
new file mode 100644
index 00000000..be356df1
--- /dev/null
+++ b/unity/Tests/Editor/importer/MjXmlModifiersTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: f585df9e8f9fb4bcd8e5da018f96a3dd
+timeCreated: 1539953427
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/importer/MjcfImporterTests.cs b/unity/Tests/Editor/importer/MjcfImporterTests.cs
new file mode 100644
index 00000000..74d89ed8
--- /dev/null
+++ b/unity/Tests/Editor/importer/MjcfImporterTests.cs
@@ -0,0 +1,346 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjcfImporterTests {
+
+  private GameObject _sceneRoot;
+  private MjcfImporter _importer;
+
+  [SetUp]
+  public void SetUp() {
+    _importer = new MjcfImporter();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    if (_sceneRoot != null) {
+      UnityEngine.Object.DestroyImmediate(_sceneRoot);
+    }
+  }
+
+  [Test]
+  public void SceneRootIsGivenRequestedName() {
+    var rootName = "rootName";
+    var mjcfString = "<mujoco><worldbody/></mujoco>";
+    _sceneRoot = _importer.ImportString(name: rootName, mjcfString: mjcfString);
+    Assert.That(_sceneRoot.name, Is.EqualTo(rootName));
+  }
+
+  [Test]
+  public void ParsingAGeom() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <geom size='1'/>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    Assert.That(_sceneRoot.transform.childCount, Is.EqualTo(1));
+    var geomChild = _sceneRoot.transform.GetChild(0).gameObject;
+    Assert.That(geomChild, Is.Not.Null);
+    Assert.That(geomChild.GetComponent<MjGeom>(), Is.Not.Null);
+  }
+
+  [TestCase("hinge", typeof(MjHingeJoint))]
+  [TestCase("slide", typeof(MjSlideJoint))]
+  [TestCase("free", typeof(MjFreeJoint))]
+  public void ParsingJoints(string typeId, Type jointType) {
+    var mjcfString = string.Format(@"<mujoco>
+      <worldbody>
+        <body>
+          <joint type=""{0}""/>
+          <geom size='1'/>
+        </body>
+      </worldbody>
+    </mujoco>", typeId);
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    Assert.That(_sceneRoot.transform.childCount, Is.EqualTo(1));
+    var bodyChild = _sceneRoot.transform.GetChild(0).gameObject;
+    Assert.That(bodyChild.transform.childCount, Is.EqualTo(2));
+    var jointChild = bodyChild.transform.GetChild(0).gameObject;
+    Assert.That(jointChild, Is.Not.Null);
+    Assert.That(jointChild.GetComponent(jointType), Is.Not.Null);
+  }
+
+  [Test]
+  public void ParsingAFreeJointStandaloneNode() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <body>
+          <freejoint/>
+          <geom size='1'/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    Assert.That(_sceneRoot.transform.childCount, Is.EqualTo(1));
+    var bodyChild = _sceneRoot.transform.GetChild(0).gameObject;
+    Assert.That(bodyChild.transform.childCount, Is.EqualTo(2));
+    var jointChild = bodyChild.transform.GetChild(0).gameObject;
+    Assert.That(jointChild, Is.Not.Null);
+    Assert.That(jointChild.GetComponent<MjFreeJoint>(), Is.Not.Null);
+  }
+
+  [Test]
+  public void ParsingABody() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <body/>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    Assert.That(_sceneRoot.transform.childCount, Is.EqualTo(1));
+    var bodyChild = _sceneRoot.transform.GetChild(0).gameObject;
+    Assert.That(bodyChild, Is.Not.Null);
+    Assert.That(bodyChild.GetComponent<MjBody>(), Is.Not.Null);
+  }
+
+  [Test]
+  public void ParsingChildrenOfABody() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <body>
+          <geom size='1'/>
+          <body/>
+          <joint type=""hinge""/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    Assert.That(_sceneRoot.transform.childCount, Is.EqualTo(1));
+    var bodyChild = _sceneRoot.transform.GetChild(0).gameObject;
+    Assert.That(bodyChild, Is.Not.Null);
+    Assert.That(bodyChild.transform.childCount, Is.EqualTo(3));
+  }
+
+  [Test]
+  public void AnonymousNodeReceivesGeneratedName() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <body/>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var bodyChild = _sceneRoot.transform.GetChild(0).gameObject;
+    Assert.That(bodyChild.name, Is.EqualTo("body_0"));
+  }
+
+  [Test]
+  public void AnonymousNodesReceiveTheSameNamesWithEveryImport() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <body/>
+      </worldbody>
+    </mujoco>";
+    var scenes = new GameObject[] {
+      _importer.ImportString(name: string.Empty, mjcfString: mjcfString),
+      _importer.ImportString(name: string.Empty, mjcfString: mjcfString)
+    };
+    // Ensure that the objects will be destroyed after the test is completed.
+    _sceneRoot = new GameObject();
+    foreach (var scene in scenes) {
+      scene.transform.parent = _sceneRoot.transform;
+    }
+    var children = scenes.Select(parent => parent.transform.GetChild(0).gameObject).ToArray();
+    Assert.That(children[0].name, Is.EqualTo(children[1].name));
+  }
+
+  [Test]
+  public void ApplyingDefaultOutsideWorldbody() {
+    var mjcfString = @"<mujoco>
+      <default>
+        <general ctrllimited='true' ctrlrange='-1 1'/>
+      </default>
+      <worldbody>
+        <body>
+          <geom name=""root_geom"" size='1 2'/>
+          <joint name='j'/>
+        </body>
+      </worldbody>
+      <actuator>
+        <general joint='j'/>
+      </actuator>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var actuator = _sceneRoot.GetComponentInChildren<MjActuator>();
+    Assert.That(actuator.CommonParams.CtrlLimited, Is.True);
+  }
+
+  [Test]
+  public void ApplyingDefaultSettingsToNodeWithoutClass() {
+    var mjcfString = @"<mujoco>
+      <default>
+        <geom type=""cylinder""/>
+      </default>
+      <worldbody>
+        <geom name=""root_geom"" size='1 2'/>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var rootGeom = _sceneRoot.GetComponentInChildren<MjGeom>();
+    Assert.That(rootGeom.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Cylinder));
+  }
+
+  [Test]
+  public void ApplyingHierarchicalDefaultSettingsToNodeWithClass() {
+    var mjcfString = @"<mujoco>
+      <default>
+        <geom type=""cylinder""/>
+        <default class=""child"">
+          <geom type=""box""/>
+        </default>
+      </default>
+      <worldbody>
+        <body childclass=""child"">
+          <geom name=""body_geom"" size='1 2 3'/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var bodyGeom = _sceneRoot.GetComponentInChildren<MjGeom>();
+    Assert.That(bodyGeom.ShapeType, Is.EqualTo(MjShapeComponent.ShapeTypes.Box));
+  }
+
+  [Test]
+  public void ReadingOption() {
+    var mjcfString = @"<mujoco>
+      <option impratio='1.2345'/>
+      <worldbody/>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var settings = _sceneRoot.GetComponentInChildren<MjGlobalSettings>();
+    Assert.That(settings.GlobalOptions.ImpRatio, Is.EqualTo(1.2345f));
+  }
+
+  [Test]
+  public void ReadingSize() {
+    var mjcfString = @"<mujoco>
+      <size njmax='1234'/>
+      <worldbody/>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var settings = _sceneRoot.GetComponentInChildren<MjGlobalSettings>();
+    Assert.That(settings.GlobalSizes.Njmax, Is.EqualTo(1234));
+  }
+
+  [Test]
+  public void ReadingOptionAndSize() {
+    var mjcfString = @"<mujoco>
+      <option impratio='5.4321'/>
+      <size njmax='4321'/>
+      <worldbody/>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var settings = _sceneRoot.GetComponentInChildren<MjGlobalSettings>();
+    Assert.That(settings.GlobalOptions.ImpRatio, Is.EqualTo(5.4321f));
+    Assert.That(settings.GlobalSizes.Njmax, Is.EqualTo(4321));
+  }
+
+  [Test]
+  public void ReadingOptionFlags() {
+    var mjcfString = @"<mujoco>
+      <option>
+        <flag gravity='disable' contact='disable' sensornoise='enable'/>
+      </option>
+      <worldbody/>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var settings = _sceneRoot.GetComponentInChildren<MjGlobalSettings>();
+    Assert.That(settings.GlobalOptions.Flag.Gravity, Is.EqualTo(EnableDisableFlag.disable));
+    Assert.That(settings.GlobalOptions.Flag.Contact, Is.EqualTo(EnableDisableFlag.disable));
+    Assert.That(settings.GlobalOptions.Flag.SensorNoise, Is.EqualTo(EnableDisableFlag.enable));
+  }
+
+  [Test]
+  public void ParsedActuatorsAddedToDedicatedGameObjectAggregate() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <body>
+          <geom size='1'/>
+          <joint name='1'/>
+        </body>
+      </worldbody>
+      <actuator>
+        <motor joint='1'/>
+      </actuator>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var actuator = _sceneRoot.GetComponentInChildren<MjActuator>();
+    Assert.That(actuator, Is.Not.Null);
+    Assert.That(actuator.transform.parent.gameObject.name, Is.EqualTo("actuators"));
+  }
+
+  [Test]
+  public void ParsedSensorsAddedToDedicatedGameObjectAggregate() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <body name='1'/>
+      </worldbody>
+      <sensor>
+        <framepos objtype='body' objname='1'/>
+      </sensor>
+    </mujoco>";
+    _sceneRoot = _importer.ImportString(
+        name: string.Empty, mjcfString: mjcfString);
+    var sensor = _sceneRoot.GetComponentInChildren<MjBaseSensor>();
+    Assert.That(sensor, Is.Not.Null);
+    Assert.That(sensor.transform.parent.gameObject.name, Is.EqualTo("sensors"));
+  }
+
+  [Test]
+  public void NodeHandlerCalledForMatchingelements() {
+    var mjcfString = @"<mujoco>
+      <worldbody>
+        <body>
+          <CustomTestNode/>
+        </body>
+      </worldbody>
+    </mujoco>";
+    var customImporter = new MjcfImporter();
+    bool ranCustomFunction = false;
+    customImporter.AddNodeHandler("CustomTestNode", (element, o) => {
+      ranCustomFunction = true;
+    });
+    var mjcfXml = new XmlDocument();
+    mjcfXml.LoadXml(mjcfString);
+    customImporter.ImportXml(mjcfXml);
+    Assert.That(ranCustomFunction, Is.True);
+  }
+}
+}
diff --git a/unity/Tests/Editor/importer/MjcfImporterTests.cs.meta b/unity/Tests/Editor/importer/MjcfImporterTests.cs.meta
new file mode 100644
index 00000000..2bbb2fac
--- /dev/null
+++ b/unity/Tests/Editor/importer/MjcfImporterTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 15a77617e445153bb847b0c8e91e0c29
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/tools.meta b/unity/Tests/Editor/tools.meta
new file mode 100644
index 00000000..d9164538
--- /dev/null
+++ b/unity/Tests/Editor/tools.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b601d749f2b1edf9e845ebc57fc23742
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/tools/HierarchyToolTests.cs b/unity/Tests/Editor/tools/HierarchyToolTests.cs
new file mode 100644
index 00000000..9b347ebf
--- /dev/null
+++ b/unity/Tests/Editor/tools/HierarchyToolTests.cs
@@ -0,0 +1,239 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class FindParentComponentTests {
+    public class FakeMjComponent : MjComponent {
+      public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_GEOM;
+      protected override void OnParseMjcf(XmlElement mjcf) {}
+      protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+        return null;
+      }
+    }
+
+    public class FakeGenericComponent : MonoBehaviour {}
+
+    private FakeMjComponent _parent;
+    private FakeMjComponent _child;
+    private FakeMjComponent _secondChild;
+    private FakeGenericComponent _hierarchyBreaker;
+
+    [SetUp]
+    public void SetUp() {
+      _parent =
+          new GameObject("parent", typeof(FakeMjComponent)).GetComponent<FakeMjComponent>();
+      _child =
+          new GameObject("child", typeof(FakeMjComponent)).GetComponent<FakeMjComponent>();
+      _secondChild = new GameObject("secondChild", typeof(FakeMjComponent))
+                         .GetComponent<FakeMjComponent>();
+      _hierarchyBreaker = new GameObject("hierarchyBreaker", typeof(FakeGenericComponent))
+                              .GetComponent<FakeGenericComponent>();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      GameObject.DestroyImmediate(_secondChild.gameObject);
+      GameObject.DestroyImmediate(_child.gameObject);
+      GameObject.DestroyImmediate(_hierarchyBreaker.gameObject);
+      GameObject.DestroyImmediate(_parent.gameObject);
+    }
+
+    [Test]
+    public void FindParentWithMjComponentAsImmediateParent() {
+      _child.transform.parent = _parent.transform;
+      Assert.That(MjHierarchyTool.FindParentComponent(_child), Is.EqualTo(_parent));
+    }
+
+    [Test]
+    public void FindParentWithHavingToSkipAParent() {
+      _hierarchyBreaker.transform.parent = _parent.transform;
+      _child.transform.parent = _hierarchyBreaker.transform;
+      Assert.That(MjHierarchyTool.FindParentComponent(_child), Is.EqualTo(_parent));
+    }
+
+    [Test]
+    public void FindParentWitNoMjComponentParent() {
+      _child.transform.parent = _hierarchyBreaker.transform;
+      Assert.That(MjHierarchyTool.FindParentComponent(_child), Is.Null);
+    }
+
+    [Test]
+    public void InChainOfThreeTheCorrectImmediateParentIsPicked() {
+      _child.transform.parent = _parent.transform;
+      _secondChild.transform.parent = _child.transform;
+      Assert.That(MjHierarchyTool.FindParentComponent(_secondChild), Is.EqualTo(_child));
+    }
+  }
+
+  [TestFixture]
+  public class HierachyLinearizationTests {
+    public class FakeMjComponent : MjComponent {
+      public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_GEOM;
+      protected override void OnParseMjcf(XmlElement mjcf) {}
+      protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+        return null;
+      }
+    }
+
+    public class FakeGenericComponent : MonoBehaviour {}
+
+    private FakeMjComponent _root;
+    private FakeMjComponent _node01;
+    private FakeMjComponent _node02;
+    private FakeMjComponent _node11;
+    private FakeMjComponent _node21;
+    private FakeGenericComponent _hierarchyBreaker;
+
+    [SetUp]
+    public void SetUp() {
+      _root =
+          new GameObject("root", typeof(FakeMjComponent)).GetComponent<FakeMjComponent>();
+      _node01 =
+          new GameObject("node01", typeof(FakeMjComponent)).GetComponent<FakeMjComponent>();
+      _node02 =
+          new GameObject("node02", typeof(FakeMjComponent)).GetComponent<FakeMjComponent>();
+      _node11 =
+          new GameObject("node11", typeof(FakeMjComponent)).GetComponent<FakeMjComponent>();
+      _node21 =
+          new GameObject("node21", typeof(FakeMjComponent)).GetComponent<FakeMjComponent>();
+      _hierarchyBreaker = new GameObject("hierarchyBreaker", typeof(FakeGenericComponent))
+                              .GetComponent<FakeGenericComponent>();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      GameObject.DestroyImmediate(_node21.gameObject);
+      GameObject.DestroyImmediate(_node11.gameObject);
+      GameObject.DestroyImmediate(_node02.gameObject);
+      GameObject.DestroyImmediate(_node01.gameObject);
+      GameObject.DestroyImmediate(_hierarchyBreaker.gameObject);
+      GameObject.DestroyImmediate(_root.gameObject);
+    }
+
+    [Test]
+    public void OneNodeHierarchy() {
+      var hierarchy = MjHierarchyTool.LinearizeHierarchyBFS(_root.transform).ToArray();
+      Assert.That(hierarchy, Has.Length.EqualTo(1));
+      Assert.That(hierarchy[0], Is.EqualTo(_root));
+    }
+
+    [Test]
+    public void OneLevelDeepTreeExclusivelyWithMjComponents() {
+      _node01.transform.parent = _root.transform;
+      _node02.transform.parent = _root.transform;
+      var hierarchy = MjHierarchyTool.LinearizeHierarchyBFS(_root.transform).ToArray();
+      Assert.That(hierarchy, Has.Length.EqualTo(3));
+      Assert.That(hierarchy[0], Is.EqualTo(_root));
+      Assert.That(hierarchy[1], Is.EqualTo(_node01));
+      Assert.That(hierarchy[2], Is.EqualTo(_node02));
+    }
+
+    [Test]
+    public void DeepTreeExclusivelyWithMjComponents() {
+      _node01.transform.parent = _root.transform;
+      _node02.transform.parent = _root.transform;
+      _node11.transform.parent = _node01.transform;
+      _node21.transform.parent = _node02.transform;
+      var hierarchy = MjHierarchyTool.LinearizeHierarchyBFS(_root.transform).ToArray();
+      Assert.That(hierarchy, Has.Length.EqualTo(5));
+      Assert.That(hierarchy[0], Is.EqualTo(_root));
+      Assert.That(hierarchy[1], Is.EqualTo(_node01));
+      Assert.That(hierarchy[2], Is.EqualTo(_node02));
+      Assert.That(hierarchy[3], Is.EqualTo(_node11));
+      Assert.That(hierarchy[4], Is.EqualTo(_node21));
+    }
+
+    [Test]
+    public void TreeWithAGenericComponent() {
+      _node01.transform.parent = _root.transform;
+      _hierarchyBreaker.transform.parent = _root.transform;
+      _node02.transform.parent = _hierarchyBreaker.transform;
+      var hierarchy = MjHierarchyTool.LinearizeHierarchyBFS(_root.transform).ToArray();
+      Assert.That(hierarchy, Has.Length.EqualTo(3));
+      Assert.That(hierarchy[0], Is.EqualTo(_root));
+      Assert.That(hierarchy[1], Is.EqualTo(_node01));
+      Assert.That(hierarchy[2], Is.EqualTo(_node02));
+    }
+  }
+
+  [TestFixture]
+  public class GetComponentsInImmediateChildrenTests {
+    public class FakeComponentA : MonoBehaviour {}
+    public class FakeComponentB : MonoBehaviour {}
+
+    private FakeComponentA _root;
+    private FakeComponentA _validChild;
+    private FakeComponentB _invalidChild;
+    private FakeComponentA _validGrandchild;
+
+    [SetUp]
+    public void SetUp() {
+      _root = new GameObject("root", typeof(FakeComponentA)).GetComponent<FakeComponentA>();
+      _validChild =
+          new GameObject("validChild", typeof(FakeComponentA)).GetComponent<FakeComponentA>();
+      _invalidChild =
+          new GameObject("invalidChild", typeof(FakeComponentB)).GetComponent<FakeComponentB>();
+      _validGrandchild =
+          new GameObject("validGrandchild", typeof(FakeComponentA)).GetComponent<FakeComponentA>();
+      _validGrandchild.transform.parent = _validChild.transform;
+      _validChild.transform.parent = _root.transform;
+    }
+
+    [TearDown]
+    public void TearDown() {
+      GameObject.DestroyImmediate(_validGrandchild.gameObject);
+      GameObject.DestroyImmediate(_invalidChild.gameObject);
+      GameObject.DestroyImmediate(_validChild.gameObject);
+      GameObject.DestroyImmediate(_root.gameObject);
+    }
+
+    [Test]
+    public void RootNodeIsIgnoredInTheSearch() {
+      var components =
+          MjHierarchyTool.GetComponentsInImmediateChildren<FakeComponentA>(_root.transform);
+      Assert.That(components, Has.No.Member(_root));
+    }
+
+    [Test]
+    public void ImmediateValidChildIsReturned() {
+      var components =
+          MjHierarchyTool.GetComponentsInImmediateChildren<FakeComponentA>(_root.transform);
+      Assert.That(components, Has.Member(_validChild));
+    }
+
+    [Test]
+    public void ChildWithAnInvalidTypeIsIgnored() {
+      var components =
+          MjHierarchyTool.GetComponentsInImmediateChildren<FakeComponentA>(_root.transform);
+      Assert.That(components, Has.No.Member(_invalidChild));
+    }
+
+    [Test]
+    public void GrandchildrenAreIgnoredDuringSearch() {
+      var components =
+          MjHierarchyTool.GetComponentsInImmediateChildren<FakeComponentA>(_root.transform);
+      Assert.That(components, Has.No.Member(_validGrandchild));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/tools/HierarchyToolTests.cs.meta b/unity/Tests/Editor/tools/HierarchyToolTests.cs.meta
new file mode 100644
index 00000000..2c1a1d00
--- /dev/null
+++ b/unity/Tests/Editor/tools/HierarchyToolTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 2eca32299982b4901a0b01568b992fed
+timeCreated: 1537463659
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/tools/MjEngineTests.cs b/unity/Tests/Editor/tools/MjEngineTests.cs
new file mode 100644
index 00000000..ec8e6511
--- /dev/null
+++ b/unity/Tests/Editor/tools/MjEngineTests.cs
@@ -0,0 +1,392 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools.Utils;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjEngineToolXmlLoadingTests {
+
+    [Test]
+    public unsafe void LoadingSceneFromAProvidedAsset() {
+      var modelFile = Resources.Load<TextAsset>("ValidModel");
+      var modelPtr = MjEngineTool.LoadModelFromString(modelFile.text);
+      var model =
+          (MujocoLib.mjModel_)Marshal.PtrToStructure(new IntPtr(modelPtr), typeof(MujocoLib.mjModel_));
+      Assert.That(model.nbody, Is.EqualTo(3));
+    }
+  }
+
+  [TestFixture]
+  public class MjEngineToolTransformHelpersTests {
+    [TestCase(1, 2, 3)]
+    [TestCase(-1, -2, -3)]
+    [TestCase(-1, 2, 3)]
+    [TestCase(1, -2, 3)]
+    [TestCase(1, 2, -3)]
+    public unsafe void RoundrobinConversionOfVector3(float x, float y, float z) {
+      var vec = new Vector3(x, y, z);
+      var MjVec = MjEngineTool.MjVector3(vec);
+      var MjVecAsArray = new double[] { 10, 11, 12, MjVec.x, MjVec.y, MjVec.z };
+      fixed (double* MjArrPtr = MjVecAsArray) {
+        var recreatedVec = MjEngineTool.UnityVector3(MjArrPtr, 1);
+        Assert.That(recreatedVec, Is.EqualTo(vec));
+      }
+    }
+
+    [TestCase(1, 2, 3)]
+    [TestCase(-1, -2, -3)]
+    [TestCase(-1, 2, 3)]
+    [TestCase(1, -2, 3)]
+    [TestCase(1, 2, -3)]
+    public void RoundrobinConversionOfVector3UsingCoreType(float x, float y, float z) {
+      var vec = new Vector3(x, y, z);
+      var MjVec = MjEngineTool.MjVector3(vec);
+      var unityVec = MjEngineTool.UnityVector3(MjVec);
+      Assert.That(unityVec, Is.EqualTo(vec));
+    }
+
+    [TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
+    [TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
+    [TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
+    [TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
+    [TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
+    [TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
+    public unsafe void RoundrobinConversionOfQuaternion(float x, float y, float z, float w) {
+      var quat = new Quaternion(x, y, z, w);
+      var MjQuat = MjEngineTool.MjQuaternion(quat);
+      var MjQuatAsArray =
+          new double[] { 10, 20, 30, 40, MjQuat.w, MjQuat.x, MjQuat.y, MjQuat.z };
+      var recreatedQuat = MjEngineTool.UnityQuaternion(MjQuatAsArray, 1);
+      var q1 = new Vector4(quat.x, quat.y, quat.z, quat.w);
+      var q2 = new Vector4(recreatedQuat.x, recreatedQuat.y, recreatedQuat.z, recreatedQuat.w);
+      Assert.That(q1, Is.EqualTo(q2));
+    }
+
+    [TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
+    [TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
+    [TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
+    [TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
+    [TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
+    [TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
+    public unsafe void RoundrobinConversionOfQuaternionUsingUnsafeArrays(float x, float y, float z,
+                                                                         float w) {
+      var quat = new Quaternion(x, y, z, w);
+      var MjQuat = MjEngineTool.MjQuaternion(quat);
+      var MjQuatAsArray =
+          new double[] { 10, 20, 30, 40, MjQuat.w, MjQuat.x, MjQuat.y, MjQuat.z };
+      fixed (double* MjArrPtr = MjQuatAsArray) {
+        var recreatedQuat = MjEngineTool.UnityQuaternion(MjArrPtr, 1);
+        var q1 = new Vector4(quat.x, quat.y, quat.z, quat.w);
+        var q2 = new Vector4(recreatedQuat.x, recreatedQuat.y, recreatedQuat.z, recreatedQuat.w);
+        Assert.That(q1, Is.EqualTo(q2));
+      }
+    }
+
+    [TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
+    [TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
+    [TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
+    [TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
+    [TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
+    [TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
+    public void RoundrobinConversionOfQuaternionUsingCoreType(float x, float y, float z, float w) {
+      var quat = new Quaternion(x, y, z, w);
+      var MjQuat = MjEngineTool.MjQuaternion(quat);
+      var unityQuat = MjEngineTool.UnityQuaternion(MjQuat);
+      Assert.That(unityQuat, Is.EqualTo(quat));
+    }
+
+    [TestCase(1, 2, 3)]
+    [TestCase(-1, -2, -3)]
+    [TestCase(-1, 2, 3)]
+    [TestCase(1, -2, 3)]
+    [TestCase(1, 2, -3)]
+    public void RoundrobinConversionOfExtents(float x, float y, float z) {
+      var extents = new Vector3(x, y, z);
+      var MjExtents = MjEngineTool.MjExtents(extents);
+      var unityExtents = MjEngineTool.UnityExtents(MjExtents);
+      Assert.That(MjExtents, Is.Not.EqualTo(extents));
+      Assert.That(unityExtents, Is.EqualTo(extents));
+    }
+
+    [TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
+    [TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
+    [TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
+    [TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
+    [TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
+    [TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
+    public unsafe void SettingAndRetrievingQuaternions(float x, float y, float z, float w) {
+      var quat = new Quaternion(x, y, z, w);
+      var result = Quaternion.identity;
+      var buffer = new double[4];
+      fixed (double* unsafeBuffer = buffer) {
+        MjEngineTool.SetMjQuaternion(unsafeBuffer, quat, entryIndex: 0);
+        result = MjEngineTool.UnityQuaternion(unsafeBuffer, entryIndex: 0);
+      }
+      Assert.That(quat, Is.EqualTo(result));
+    }
+
+    [TestCase(1, 2, 3)]
+    [TestCase(-1, -2, -3)]
+    [TestCase(-1, 2, 3)]
+    [TestCase(1, -2, 3)]
+    [TestCase(1, 2, -3)]
+    public unsafe void SettingAndRetrievingVectors(float x, float y, float z) {
+      var vec = new Vector3(x, y, z);
+      var result = Vector3.zero;
+      double[] buffer = new double[3];
+      fixed (double* unsafeBuffer = buffer) {
+        MjEngineTool.SetMjVector3(unsafeBuffer, vec, entryIndex: 0);
+        result = MjEngineTool.UnityVector3(unsafeBuffer, entryIndex: 0);
+      }
+      Assert.That(vec, Is.EqualTo(result));
+    }
+  }
+
+  [TestFixture]
+  public class MjEngineToolTransformSerializationTests {
+    public class FakeMjComponent : MjComponent {
+      public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_GEOM;
+
+      protected override void OnParseMjcf(XmlElement mjcf) {}
+
+      protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
+        return doc.CreateElement("geom");
+      }
+    }
+
+    private GameObject _rootObject;
+    private GameObject _intermediateObject;
+    private FakeMjComponent _component;
+    private Vector3EqualityComparer _vectorComparer;
+    private Vector4EqualityComparer _quaternionComparer;
+
+    [SetUp]
+    public void SetUp() {
+      _rootObject = new GameObject("rootObject");
+      _intermediateObject = new GameObject("intermediateObject");
+      _component = new GameObject("component").AddComponent<FakeMjComponent>();
+      var epsilon = 1e-3f;
+      _vectorComparer = new Vector3EqualityComparer(epsilon);
+      _quaternionComparer = new Vector4EqualityComparer(epsilon);
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_component.gameObject);
+      UnityEngine.Object.DestroyImmediate(_intermediateObject);
+      UnityEngine.Object.DestroyImmediate(_rootObject);
+      MjSceneImportSettings.AnglesInDegrees = true;
+    }
+
+    [Test]
+    public void SerializingPositionRotationOfRootComponent() {
+      _component.transform.position = new Vector3(1, 2, 3);
+      _component.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
+      var doc = new XmlDocument();
+      var mjcf = doc.CreateElement("element");
+      MjEngineTool.PositionRotationToMjcf(mjcf, _component);
+      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
+      Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
+                  Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
+                  .Using(_quaternionComparer));
+    }
+
+    [Test]
+    public void SerializingPositionRotationOfRootComponentParentedToGameObject() {
+      _component.transform.parent = _rootObject.transform;
+      _rootObject.transform.position = new Vector3(1, 2, 3);
+      _rootObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
+      var doc = new XmlDocument();
+      var mjcf = doc.CreateElement("element");
+      MjEngineTool.PositionRotationToMjcf(mjcf, _component);
+      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
+      Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
+                  Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
+                  .Using(_quaternionComparer));
+    }
+
+    [Test]
+    public void SerializingPositionRotationOfChildComponentParentedThroughGameObject() {
+      _component.transform.parent = _intermediateObject.transform;
+      _intermediateObject.transform.parent = _rootObject.transform;
+      _intermediateObject.transform.position = new Vector3(1, 2, 3);
+      _intermediateObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
+      var doc = new XmlDocument();
+      var mjcf = doc.CreateElement("element");
+      MjEngineTool.PositionRotationToMjcf(mjcf, _component);
+      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
+      Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
+                  Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
+                  .Using(_quaternionComparer));
+    }
+
+    [Test]
+    public void SerializingPositionAxisOfRootComponent() {
+      _component.transform.position = new Vector3(1, 2, 3);
+      _component.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
+      var doc = new XmlDocument();
+      var mjcf = doc.CreateElement("element");
+      MjEngineTool.PositionAxisToMjcf(mjcf, _component);
+      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
+      Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
+                  Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
+      Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
+    }
+
+    [Test]
+    public void SerializingPositionAxisOfRootComponentParentedToGameObject() {
+      _component.transform.parent = _rootObject.transform;
+      _rootObject.transform.position = new Vector3(1, 2, 3);
+      _rootObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
+      var doc = new XmlDocument();
+      var mjcf = doc.CreateElement("element");
+      MjEngineTool.PositionAxisToMjcf(mjcf, _component);
+      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
+      Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
+                  Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
+      Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
+    }
+
+    [Test]
+    public void SerializingPositionAxisOfChildComponentParentedThroughGameObject() {
+      _component.transform.parent = _intermediateObject.transform;
+      _intermediateObject.transform.parent = _rootObject.transform;
+      _intermediateObject.transform.position = new Vector3(1, 2, 3);
+      _intermediateObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
+      var doc = new XmlDocument();
+      var mjcf = doc.CreateElement("element");
+      MjEngineTool.PositionAxisToMjcf(mjcf, _component);
+      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
+      Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
+                  Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
+      Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
+    }
+
+    [Test]
+    public void ParsePosition() {
+      var mjcf = new XmlDocument().CreateElement("element");
+      mjcf.SetAttribute("pos", "1 3 2");
+      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
+      Assert.That(_rootObject.transform.position, Is.EqualTo(new Vector3(1, 2, 3)));
+    }
+
+    [Test]
+    public void ParseRotationFromQuat() {
+      var mjcf = new XmlDocument().CreateElement("element");
+      mjcf.SetAttribute("quat", "-0.9238795 0 0 0.3826835");
+      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
+      var expectedRotation = Quaternion.AngleAxis(45, Vector3.up);
+      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
+      // Assert.That(
+      //     _rootObject.transform.rotation,
+      //     Is.EqualTo(Quaternion.AngleAxis(45, Vector3.up))
+      //     .Using(_quaternionComparer));
+    }
+
+    [Test]
+    public void ParseRotationFromZAxis() {
+      var mjcf = new XmlDocument().CreateElement("element");
+      mjcf.SetAttribute("zaxis", "0 1 0");
+      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
+      var expectedRotation = Quaternion.AngleAxis(90, Vector3.right);
+      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
+      // Assert.That(
+      //     _rootObject.transform.rotation,
+      //     Is.EqualTo(Quaternion.AngleAxis(90, Vector3.right))
+      //     .Using(_quaternionComparer));
+    }
+
+    [TestCase(true, 45, 45)]
+    [TestCase(false, 0.785398f, 45)]
+    [TestCase(true, 90, 90)]
+    [TestCase(false, 1.570796f, 90)]
+    public void ParseRotationFromAxisAngle(bool useDegrees, float MjAngle,
+                                           float expectedAngle) {
+      MjSceneImportSettings.AnglesInDegrees = useDegrees;
+      var mjcf = new XmlDocument().CreateElement("element");
+      mjcf.SetAttribute("axisangle", $"1 0 0 {MjAngle}");
+      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
+      var expectedRotation = Quaternion.AngleAxis(expectedAngle, Vector3.right);
+      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
+      // Assert.That(
+      //     _rootObject.transform.rotation,
+      //     Is.EqualTo(Quaternion.AngleAxis(expectedAngle, Vector3.right))
+      //     .Using(_quaternionComparer));
+    }
+
+    [TestCase(true, 0, 45, 0, 0, 0, -45)]
+    [TestCase(false, 0, 0.785398f, 0, 0, 0, -45)]
+    [TestCase(true, 0, 0, 45, 0, 45, 0)]
+    [TestCase(false, 0, 0, 0.785398f, 0, 45, 0)]
+    [TestCase(true, 45, 0, 0, 45, 0, 0)]
+    [TestCase(false, 0.785398f, 0, 0, 45, 0, 0)]
+    public void ParseRotationFromEuler(bool useDegrees, float mx, float my, float mz, float ex,
+                                       float ey, float ez) {
+      MjSceneImportSettings.AnglesInDegrees = useDegrees;
+      var mjcf = new XmlDocument().CreateElement("element");
+      mjcf.SetAttribute("euler", $"{mx} {my} {mz}");
+      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
+      var expectedRotation = Quaternion.Euler(ex, ey, ez);
+      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
+      // Assert.That(
+      //     _rootObject.transform.rotation,
+      //     Is.EqualTo(Quaternion.Euler(ex, ey, ez))
+      //     .Using(_quaternionComparer));
+    }
+
+    [Test]
+    public void ParseRotationFromDirectionVector() {
+      var mjcf = new XmlDocument().CreateElement("element");
+      mjcf.SetAttribute("fromto", $"0 0 0 1 1 0");
+      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
+      var expectedRotation = new Quaternion(0.5f, 0, -0.5f, 0.7071068f);
+      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
+      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
+      // Assert.That(
+      //     _rootObject.transform.rotation,
+      //     Is.EqualTo(new Quaternion(0.5f, 0, -0.5f, 0.7071068f))
+      //     .Using(_quaternionComparer));
+    }
+
+    [Test]
+    public void ParsePositionFromDirectionVector() {
+      var mjcf = new XmlDocument().CreateElement("element");
+      mjcf.SetAttribute("fromto", $"1 2 3 5 7 9");
+      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
+      Assert.That(_rootObject.transform.position, Is.EqualTo(new Vector3(3, 6, 4.5f)));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/tools/MjEngineTests.cs.meta b/unity/Tests/Editor/tools/MjEngineTests.cs.meta
new file mode 100644
index 00000000..c854464b
--- /dev/null
+++ b/unity/Tests/Editor/tools/MjEngineTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ff03f770fd9aa43cd95e04660fd82bb3
+timeCreated: 1536938636
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/tools/MjTransformationTests.cs b/unity/Tests/Editor/tools/MjTransformationTests.cs
new file mode 100644
index 00000000..7c11d6b7
--- /dev/null
+++ b/unity/Tests/Editor/tools/MjTransformationTests.cs
@@ -0,0 +1,159 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class MjTransformationTests {
+    [Test]
+    public void ConcatenateTranslation() {
+      var t1 = new MjTransformation(new Vector3(10, 0, 0), Quaternion.identity);
+      var t2 = new MjTransformation(new Vector3(0, 20, 0), Quaternion.identity);
+      var result = t1 * t2;
+      var expectedResult = new MjTransformation(new Vector3(10, 20, 0), Quaternion.identity);
+      CompareTransforms(result, expectedResult);
+    }
+
+    [Test]
+    public void ConcatenateRotation() {
+      var t1 = new MjTransformation(Vector3.zero, Quaternion.Euler(0, 45, 0));
+      var t2 = new MjTransformation(Vector3.zero, Quaternion.Euler(0, 15, 0));
+      var result = t1 * t2;
+      var expectedResult = new MjTransformation(Vector3.zero, Quaternion.Euler(0, 60, 0));
+      CompareTransforms(result, expectedResult);
+    }
+
+    [Test]
+    public void ConcatenateTranslationAndRotation() {
+      var t1 = new MjTransformation(new Vector3(10, 0, 0), Quaternion.Euler(0, 45, 0));
+      var t2 = new MjTransformation(new Vector3(20, 0, 0), Quaternion.Euler(0, 15, 0));
+      var result = t1 * t2;
+      // T2 is some translation and rotation in T1's reference frame. We want to learn what that
+      // transform would look like in global space - as if there was no T1.
+      // T1 is located at (10, 0, 0), and rotates its children by 45 deg around the Y axis.
+      // That means it will rotate T2 translation (20, 0, 0) by 45 degrees. Since the rotation
+      // is performed around the Y axis, the X coordinate 20 will be projected onto X and Z axis
+      // in amount [cos(45deg) * 20, -sin(45deg) * 20] = [14.14213, -14.14213].
+      // Next, the rotation will be added to that of the parent: 45 + 15 = 60 deg.
+      var expectedResult = new MjTransformation(new Vector3(24.14213f, 0, -14.14213f),
+                                                    Quaternion.Euler(0, 60, 0));
+      CompareTransforms(result, expectedResult);
+    }
+
+    [Test]
+    public void ConcatenatingRightInverse() {
+      var t1 = new MjTransformation(new Vector3(10, 0, 0), Quaternion.Euler(0, 45, 0));
+      var result = t1 * t1.Inverse();
+      var expectedResult = new MjTransformation(Vector3.zero, Quaternion.identity);
+      CompareTransforms(result, expectedResult);
+    }
+
+    [Test]
+    public void ConcatenatingLeftInverse() {
+      var t1 = new MjTransformation(new Vector3(10, 0, 0), Quaternion.Euler(0, 45, 0));
+      var result = t1.Inverse() * t1;
+      var expectedResult = new MjTransformation(Vector3.zero, Quaternion.identity);
+      CompareTransforms(result, expectedResult);
+    }
+
+    [Test]
+    public void MjTransformationsConcatenationIsTheSameAsUnitys() {
+      _parent.transform.position = new Vector3(10, 0, 0);
+      _parent.transform.rotation = Quaternion.Euler(0, 45, 0);
+      _child.transform.localPosition = new Vector3(20, 0, 0);
+      _child.transform.localRotation = Quaternion.Euler(0, 15, 0);
+      var t1 = MjTransformation.LoadGlobal(_parent.transform);
+      var t2 = MjTransformation.LoadLocal(_child.transform);
+      var result = t1 * t2;
+      var expectedResult = MjTransformation.LoadGlobal(_child.transform);
+      var expectedExplicitResult = new MjTransformation(new Vector3(24.14213f, 0, -14.14213f),
+                                                            Quaternion.Euler(0, 60, 0));
+      CompareTransforms(result, expectedResult);
+      CompareTransforms(result, expectedExplicitResult);
+    }
+
+    [Test]
+    public void LoadingGlobalTransform() {
+      var result = MjTransformation.LoadGlobal(_parent.transform);
+      CompareTransforms(result, _parent.transform.position, _parent.transform.rotation);
+    }
+
+    [Test]
+    public void LoadingLocalTransform() {
+      var result = MjTransformation.LoadLocal(_parent.transform);
+      CompareTransforms(result, _parent.transform.localPosition, _parent.transform.localRotation);
+    }
+
+    [Test]
+    public void StoringGlobalTransform() {
+      var transform = new MjTransformation(new Vector3(1, 2, 3), Quaternion.Euler(0, 45, 0));
+      transform.StoreGlobal(_parent.transform);
+      CompareTransforms(transform, _parent.transform.position, _parent.transform.rotation);
+    }
+
+    [Test]
+    public void StoringLocalTransform() {
+      var transform = new MjTransformation(new Vector3(1, 2, 3), Quaternion.Euler(0, 45, 0));
+      transform.StoreGlobal(_parent.transform);
+      CompareTransforms(transform, _parent.transform.localPosition,
+                        _parent.transform.localRotation);
+    }
+
+#region Setup
+
+    private GameObject _parent;
+    private GameObject _child;
+
+    [SetUp]
+    public void SetUp() {
+      _parent = new GameObject("parent");
+      _child = new GameObject("child");
+      _child.transform.parent = _parent.transform;
+    }
+
+    [TearDown]
+    public void TearDown() {
+      UnityEngine.Object.DestroyImmediate(_parent);
+    }
+
+    private void CompareTransforms(MjTransformation lhs, MjTransformation rhs) {
+      Assert.That(lhs.Translation.x, Is.EqualTo(rhs.Translation.x).Within(1e-5f));
+      Assert.That(lhs.Translation.y, Is.EqualTo(rhs.Translation.y).Within(1e-5f));
+      Assert.That(lhs.Translation.z, Is.EqualTo(rhs.Translation.z).Within(1e-5f));
+      Assert.That(lhs.Rotation.x, Is.EqualTo(rhs.Rotation.x).Within(1e-5f));
+      Assert.That(lhs.Rotation.y, Is.EqualTo(rhs.Rotation.y).Within(1e-5f));
+      Assert.That(lhs.Rotation.z, Is.EqualTo(rhs.Rotation.z).Within(1e-5f));
+      Assert.That(lhs.Rotation.w, Is.EqualTo(rhs.Rotation.w).Within(1e-5f));
+    }
+
+    private void CompareTransforms(MjTransformation lhs, Vector3 position,
+                                   Quaternion rotation) {
+      Assert.That(lhs.Translation.x, Is.EqualTo(position.x).Within(1e-5f));
+      Assert.That(lhs.Translation.y, Is.EqualTo(position.y).Within(1e-5f));
+      Assert.That(lhs.Translation.z, Is.EqualTo(position.z).Within(1e-5f));
+      Assert.That(lhs.Rotation.x, Is.EqualTo(rotation.x).Within(1e-5f));
+      Assert.That(lhs.Rotation.y, Is.EqualTo(rotation.y).Within(1e-5f));
+      Assert.That(lhs.Rotation.z, Is.EqualTo(rotation.z).Within(1e-5f));
+      Assert.That(lhs.Rotation.w, Is.EqualTo(rotation.w).Within(1e-5f));
+    }
+
+#endregion
+  }
+}
diff --git a/unity/Tests/Editor/tools/MjTransformationTests.cs.meta b/unity/Tests/Editor/tools/MjTransformationTests.cs.meta
new file mode 100644
index 00000000..4558e3dd
--- /dev/null
+++ b/unity/Tests/Editor/tools/MjTransformationTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 232da11066f724246bf5b820d6647261
+timeCreated: 1551107971
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/tools/MjVFSEditorTests.cs b/unity/Tests/Editor/tools/MjVFSEditorTests.cs
new file mode 100644
index 00000000..2f3b9f58
--- /dev/null
+++ b/unity/Tests/Editor/tools/MjVFSEditorTests.cs
@@ -0,0 +1,62 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Runtime.InteropServices;
+using NUnit.Framework;
+
+namespace Mujoco {
+
+  using static MujocoLib;
+
+  [TestFixture]
+  public class MjVfsTests {
+    private MjVfs _vfs;
+
+    [SetUp]
+    public void SetUp() {
+      _vfs = new MjVfs();
+    }
+
+    [TearDown]
+    public void TearDown() {
+      _vfs.Dispose();
+      _vfs = null;
+    }
+
+    [Test]
+    public unsafe void AddingNewFile() {
+      var filename = "filename";
+      var contents = "contents";
+      _vfs.AddFile(filename, contents);
+      Assert.That(_vfs.FilesCount, Is.EqualTo(1));
+    }
+
+    [Test]
+    public unsafe void LocatingFileUsingMujocoLib() {
+      var filename = "filename";
+      _vfs.AddFile(filename, "contents");
+      Assert.That(_vfs.FindFile(filename), Is.EqualTo(0));
+    }
+
+    [Test]
+    public unsafe void AddedFileContentsAreCorrect() {
+      var filename = "filename";
+      var contents = "contents";
+      _vfs.AddFile(filename, contents);
+      var filedata = Marshal.PtrToStringAnsi(_vfs.Data.filedata[0]);
+      Assert.That(filedata, Is.EqualTo(contents));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/tools/MjVFSEditorTests.cs.meta b/unity/Tests/Editor/tools/MjVFSEditorTests.cs.meta
new file mode 100644
index 00000000..25986b51
--- /dev/null
+++ b/unity/Tests/Editor/tools/MjVFSEditorTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 41b2695e2bc7a4317bc759f1eae39ab2
+timeCreated: 1535647485
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/tools/Resources.meta b/unity/Tests/Editor/tools/Resources.meta
new file mode 100644
index 00000000..76254c0f
--- /dev/null
+++ b/unity/Tests/Editor/tools/Resources.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 676e0a086d0ff32f6b91e644a9fc1f23
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/tools/Resources/ValidModel.xml b/unity/Tests/Editor/tools/Resources/ValidModel.xml
new file mode 100644
index 00000000..ec04ab58
--- /dev/null
+++ b/unity/Tests/Editor/tools/Resources/ValidModel.xml
@@ -0,0 +1,30 @@
+<!--
+ Copyright 2019 DeepMind Technologies Limited
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<mujoco>
+  <option gravity="0 -9.81 0" />
+  <worldbody>
+    <geom name="ground" type="plane" size="5 5 1" euler="-90 0 0"/>
+    <body name="parent" pos="0 10 0">
+      <geom name="parent_shape" type="sphere" size="0.5"/>
+      <joint type="free" />
+      <body name="child" pos="2 1 0">
+        <geom name="child_shape" type="sphere" size="0.5"/>
+        <joint type="hinge" axis="1 0 0"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
diff --git a/unity/Tests/Editor/tools/Resources/ValidModel.xml.meta b/unity/Tests/Editor/tools/Resources/ValidModel.xml.meta
new file mode 100644
index 00000000..be5d47ff
--- /dev/null
+++ b/unity/Tests/Editor/tools/Resources/ValidModel.xml.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4ec05e5bec3e158bb9cf4cc868f75f03
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Editor/tools/XmlElementExtensionsTests.cs b/unity/Tests/Editor/tools/XmlElementExtensionsTests.cs
new file mode 100644
index 00000000..e1d38496
--- /dev/null
+++ b/unity/Tests/Editor/tools/XmlElementExtensionsTests.cs
@@ -0,0 +1,193 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Mujoco {
+
+  [TestFixture]
+  public class XmlElementExtensionsEditorTests {
+    public enum TestEnum { ValueDefault, ValueA }
+
+    private XmlElement _element;
+
+    [SetUp]
+    public void SetUp() {
+      var doc = new XmlDocument();
+      _element = doc.CreateElement("element");
+    }
+
+    [Test]
+    public void ParsingMissingFloatAttribute() {
+      Assert.That(_element.GetFloatAttribute("attrib", 7.0f), Is.EqualTo(7.0f));
+    }
+
+    [TestCase("5.1", 5.1f)]
+    [TestCase("-4.83", -4.83f)]
+    public void ParsingFloatAttribute(string input, float expected) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(_element.GetFloatAttribute("attrib", 7.0f), Is.EqualTo(expected));
+    }
+
+    [TestCase("")]
+    [TestCase("string value")]
+    public void InvalidFloatValueTriggersAnException(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(() => { _element.GetFloatAttribute("attrib", 7.0f); }, Throws.Exception);
+    }
+
+    [Test]
+    public void ParsingMissingEnumAttribute() {
+      Assert.That(_element.GetEnumAttribute<TestEnum>("attrib", TestEnum.ValueDefault),
+                  Is.EqualTo(TestEnum.ValueDefault));
+    }
+
+    [TestCase("ValueA", TestEnum.ValueA)]
+    [TestCase("valuea", TestEnum.ValueA)]
+    public void ParsingEnumAttributeIsCaseInsensitive(string input, TestEnum expected) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(_element.GetEnumAttribute<TestEnum>("attrib", TestEnum.ValueDefault, true),
+                  Is.EqualTo(expected));
+    }
+
+    [TestCase("")]
+    [TestCase("wrong value")]
+    public void InvalidEnumValueTriggersAnException(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(() => { _element.GetEnumAttribute<TestEnum>("attrib", TestEnum.ValueDefault); },
+                  Throws.Exception);
+    }
+
+    [Test]
+    public void ParsingMissingStringAttribute() {
+      Assert.That(_element.GetStringAttribute("attrib", "missing"), Is.EqualTo("missing"));
+    }
+
+    [TestCase("value", "value")]
+    [TestCase("", "")]
+    public void ParsingStringAttributes(string input, string expected) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(_element.GetStringAttribute("attrib", "missing"), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void ParsingMissingVector3Attribute() {
+      Assert.That(_element.GetVector3Attribute("attrib", Vector3.one), Is.EqualTo(Vector3.one));
+    }
+
+    public void ParsingVector3Attributes() {
+      _element.SetAttribute("attrib", "-1 2 3.5");
+      var expected = new Vector3(-1, 2, 3.5f);
+      Assert.That(_element.GetVector3Attribute("attrib", Vector3.one), Is.EqualTo(expected));
+    }
+
+    [TestCase("1 2")]
+    [TestCase("1")]
+    [TestCase("")]
+    public void Vector3WithInsufficientNumberOfComponentsTriggersAnException(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(() => { _element.GetVector3Attribute("attrib", Vector3.one); }, Throws.Exception);
+    }
+
+    [TestCase("a 2 3")]
+    [TestCase("1 b 3")]
+    [TestCase("1 2 c")]
+    public void InvalidVector3ComponentValueTriggersException(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(() => { _element.GetVector3Attribute("attrib", Vector3.one); }, Throws.Exception);
+    }
+
+    public void ParsingVector2Attributes() {
+      _element.SetAttribute("attrib", "-1 2.5");
+      var expected = new Vector3(-1, 2.5f);
+      Assert.That(_element.GetVector2Attribute("attrib", Vector2.one), Is.EqualTo(expected));
+    }
+
+    [TestCase("1")]
+    [TestCase("")]
+    public void Vector2WithInsufficientNumberOfComponentsTriggersAnException(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(() => { _element.GetVector2Attribute("attrib", Vector2.one); }, Throws.Exception);
+    }
+
+    [TestCase("a 2")]
+    [TestCase("1 b")]
+    public void InvalidVector2ComponentValueTriggersException(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(() => { _element.GetVector2Attribute("attrib", Vector2.one); }, Throws.Exception);
+    }
+
+    [Test]
+    public void ParsingMissingQuaternionAttribute() {
+      Assert.That(_element.GetQuaternionAttribute("attrib", Quaternion.identity),
+                  Is.EqualTo(Quaternion.identity));
+    }
+
+    public void ParsingQuaternionAttributes() {
+      _element.SetAttribute("attrib", "0.1 0.2 0.3 0.4");
+      var expected = new Quaternion(0.1f, 0.2f, 0.3f, 0.4f);
+      Assert.That(_element.GetQuaternionAttribute("attrib", Quaternion.identity),
+                  Is.EqualTo(expected));
+    }
+
+    [TestCase("1 2 3")]
+    [TestCase("1 2")]
+    [TestCase("1")]
+    [TestCase("")]
+    public void QuaternionWithInsufficientNumberOfComponentsTriggersAnException(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(() => { _element.GetQuaternionAttribute("attrib", Quaternion.identity); },
+                  Throws.Exception);
+    }
+
+    [TestCase("a 2 3 4")]
+    [TestCase("1 b 3 4")]
+    [TestCase("1 2 c 4")]
+    [TestCase("1 2 3 d")]
+    public void InvalidQuaternionComponentValueTriggersException(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(() => { _element.GetQuaternionAttribute("attrib", Quaternion.identity); },
+                  Throws.Exception);
+    }
+
+    [TestCase("1  2")]
+    [TestCase("1  2  ")]
+    [TestCase("  1 2")]
+    public void FloatArraysCanContainArbitraryNumberOfWhitespaces(string input) {
+      _element.SetAttribute("attrib", input);
+      Assert.That(_element.GetFloatArrayAttribute("attrib", defaultValue: null),
+                  Is.EqualTo(new float[] { 1, 2 }));
+    }
+
+    public void FloatArraysCanBeFilledUpWithDefaultValues() {
+      _element.SetAttribute("attrib", "1 2");
+      var defaultValue = new float[] { 5, 6, 7, 8 };
+      Assert.That(_element.GetFloatArrayAttribute("attrib", defaultValue: defaultValue),
+                  Is.EqualTo(new float[] { 1, 2, 7, 8 }));
+    }
+
+    public void FloatArrayDefaultFillingCanBeSwitchedOff() {
+      _element.SetAttribute("attrib", "1 2");
+      var defaultValue = new float[] { 5, 6, 7, 8 };
+      var result = _element.GetFloatArrayAttribute("attrib", defaultValue: defaultValue,
+                                                   fillMissingValues: false);
+      Assert.That(result, Is.EqualTo(new float[] { 1, 2 }));
+    }
+  }
+}
diff --git a/unity/Tests/Editor/tools/XmlElementExtensionsTests.cs.meta b/unity/Tests/Editor/tools/XmlElementExtensionsTests.cs.meta
new file mode 100644
index 00000000..f8f120a9
--- /dev/null
+++ b/unity/Tests/Editor/tools/XmlElementExtensionsTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c5148652c03104473b634d0ec28103d3
+timeCreated: 1538662593
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Runtime.meta b/unity/Tests/Runtime.meta
new file mode 100644
index 00000000..bc675180
--- /dev/null
+++ b/unity/Tests/Runtime.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a5e91f85801f997319fcb2997dc52842
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Runtime/MjJointTests.cs b/unity/Tests/Runtime/MjJointTests.cs
new file mode 100644
index 00000000..d994bd98
--- /dev/null
+++ b/unity/Tests/Runtime/MjJointTests.cs
@@ -0,0 +1,78 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if UNITY_EDITOR
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjJointStateTests {
+  private MjBody _body;
+  private MjHingeJoint _joint;
+  private MjInertial _inertial;
+  private MjScene _scene;
+
+  [SetUp]
+  public void SetUp() {
+    _scene = MjScene.Instance;
+    _body = new GameObject("body").AddComponent<MjBody>();
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.transform.parent = _body.transform;
+    _inertial = new GameObject("inertial").AddComponent<MjInertial>();
+    _inertial.transform.parent = _body.transform;
+  }
+
+  [TearDown]
+  public void TearDown() {
+    GameObject.DestroyImmediate(_joint.gameObject);
+    GameObject.DestroyImmediate(_inertial.gameObject);
+    GameObject.DestroyImmediate(_body.gameObject);
+    GameObject.DestroyImmediate(MjScene.Instance);
+  }
+
+  [UnityTest]
+  public IEnumerator JointVelocityChangesTheConfiguration() {
+    _joint.Velocity = 10;
+    _scene.CreateScene();
+    yield return new WaitForFixedUpdate();
+    Assert.That(_joint.Configuration, Is.Not.EqualTo(0));
+  }
+
+  [UnityTest]
+  public IEnumerator JointConfigurationIsUsed() {
+    _joint.Configuration = 10;
+    _scene.CreateScene();
+    yield return new WaitForFixedUpdate();
+    Assert.That(_joint.Configuration, Is.Not.EqualTo(0));
+  }
+
+  [UnityTest]
+  public IEnumerator JointConfigurationIsReadOnly() {
+    _scene.CreateScene();
+    _joint.Configuration = 10;
+    yield return new WaitForFixedUpdate();
+    Assert.That(_joint.Configuration, Is.EqualTo(0));
+  }
+}
+}
+
+#endif
diff --git a/unity/Tests/Runtime/MjJointTests.cs.meta b/unity/Tests/Runtime/MjJointTests.cs.meta
new file mode 100644
index 00000000..fd33767e
--- /dev/null
+++ b/unity/Tests/Runtime/MjJointTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: acc8876e5b07dea7d825d8056331b4fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Runtime/MjMeshFilterTests.cs b/unity/Tests/Runtime/MjMeshFilterTests.cs
new file mode 100644
index 00000000..0ba381e5
--- /dev/null
+++ b/unity/Tests/Runtime/MjMeshFilterTests.cs
@@ -0,0 +1,65 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjMeshFilterTests {
+
+  private MjGeom _geom;
+  private MeshFilter _meshFilter;
+
+  [SetUp]
+  public void SetUp() {
+    var gameObject = new GameObject(
+        "object", typeof(MjGeom), typeof(MeshFilter), typeof(MjMeshFilter));
+    _geom = gameObject.GetComponent<MjGeom>();
+    _meshFilter = gameObject.GetComponent<MeshFilter>();
+  }
+
+  [TearDown]
+  public void TearDown() {
+    UnityEngine.Object.DestroyImmediate(_geom.gameObject);
+    GameObject.DestroyImmediate(MjScene.Instance);
+  }
+
+  [UnityTest]
+  public IEnumerator NotMakingUnnecesaryMeshChanges() {
+    yield return null;
+    var firstMesh = _meshFilter.mesh;
+    yield return null;
+    var secondMesh = _meshFilter.mesh;
+    Assert.That(firstMesh, Is.EqualTo(secondMesh));
+  }
+
+  [UnityTest]
+  public IEnumerator DetectingChangesOfGeomShape() {
+    yield return null;
+    var firstMesh = _meshFilter.mesh;
+    _geom.ShapeType = MjShapeComponent.ShapeTypes.Box;
+    yield return null;
+    var secondMesh = _meshFilter.mesh;
+    Assert.That(firstMesh, Is.Not.EqualTo(secondMesh));
+  }
+}
+}
diff --git a/unity/Tests/Runtime/MjMeshFilterTests.cs.meta b/unity/Tests/Runtime/MjMeshFilterTests.cs.meta
new file mode 100644
index 00000000..89c97737
--- /dev/null
+++ b/unity/Tests/Runtime/MjMeshFilterTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9ca786de0abc745edaa19ef76be40ffd
+timeCreated: 1539770521
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Runtime/MjScenePlayTests.cs b/unity/Tests/Runtime/MjScenePlayTests.cs
new file mode 100644
index 00000000..1a69b1a4
--- /dev/null
+++ b/unity/Tests/Runtime/MjScenePlayTests.cs
@@ -0,0 +1,106 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if UNITY_EDITOR
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjScenePlayTests {
+  private MjScene _scene;
+  private MjBody _body;
+  private MjInertial _inertia;
+  private MjHingeJoint _joint;
+
+  [SetUp]
+  public void SetUp() {
+    _scene = MjScene.Instance;
+    _body = new GameObject("body").AddComponent<MjBody>();
+    _inertia = new GameObject("inertia").AddComponent<MjInertial>();
+    _inertia.transform.parent = _body.transform;
+    _joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    _joint.transform.parent = _body.transform;
+  }
+
+  [TearDown]
+  public void TearDown() {
+    GameObject.DestroyImmediate(_joint.gameObject);
+    GameObject.DestroyImmediate(_inertia.gameObject);
+    GameObject.DestroyImmediate(_body.gameObject);
+    GameObject.DestroyImmediate(_scene.gameObject);
+  }
+
+  [UnityTest]
+  public IEnumerator RecreatedScenePreservesPosition() {
+    _joint.Velocity = .1f;
+    _scene.CreateScene();
+    yield return null; // qpos moves, xpos stays at zero
+    yield return null; // now xpos changed
+    var tickedRotation = _body.transform.rotation;
+    _scene.RecreateScene();
+    // xpos is one step behind qpos, so it's not a perfect no-op, hence the high tolerance
+    Assert.That(tickedRotation.x, Is.EqualTo(_body.transform.rotation.x).Within(1e-3f));
+    Assert.That(tickedRotation.y, Is.EqualTo(_body.transform.rotation.y).Within(1e-3f));
+    Assert.That(tickedRotation.z, Is.EqualTo(_body.transform.rotation.z).Within(1e-3f));
+    Assert.That(tickedRotation.w, Is.EqualTo(_body.transform.rotation.w).Within(1e-3f));
+    // Assert.That(tickedRotation, Is.EqualTo(_body.transform.rotation).Using(_quaternionComparer));
+  }
+
+  [UnityTest]
+  public IEnumerator SceneRecreatedWithAddition() {
+    _joint.Velocity = 1;
+    _scene.CreateScene();
+    Assert.That(_scene.SceneRecreationAtLateUpdateRequested, Is.False);
+    var body = new GameObject("body").AddComponent<MjBody>();
+    var inertia = new GameObject("inertia").AddComponent<MjInertial>();
+    inertia.transform.parent = body.transform;
+    var joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    joint.transform.parent = body.transform;
+    yield return null; // call "start"
+    Assert.That(_scene.SceneRecreationAtLateUpdateRequested, Is.True);
+    yield return null; // call "lateUpdate"
+    Assert.That(_scene.SceneRecreationAtLateUpdateRequested, Is.False);
+    UnityEngine.Object.DestroyImmediate(inertia.gameObject);
+    UnityEngine.Object.DestroyImmediate(joint.gameObject);
+    UnityEngine.Object.DestroyImmediate(body.gameObject);
+  }
+
+  [UnityTest]
+  public IEnumerator SceneRecreatedAfterDeletion() {
+    var body = new GameObject("body").AddComponent<MjBody>();
+    var inertia = new GameObject("inertia").AddComponent<MjInertial>();
+    inertia.transform.parent = body.transform;
+    var joint = new GameObject("joint").AddComponent<MjHingeJoint>();
+    joint.transform.parent = body.transform;
+    yield return null;
+    yield return null;
+    Assert.That(_scene.SceneRecreationAtLateUpdateRequested, Is.False);
+    UnityEngine.Object.DestroyImmediate(inertia.gameObject);
+    UnityEngine.Object.DestroyImmediate(joint.gameObject);
+    UnityEngine.Object.DestroyImmediate(body.gameObject);
+    Assert.That(_scene.SceneRecreationAtLateUpdateRequested, Is.True);
+    yield return null; // should result in a new scene
+    Assert.That(_scene.SceneRecreationAtLateUpdateRequested, Is.False);
+  }
+}
+}
+#endif
diff --git a/unity/Tests/Runtime/MjScenePlayTests.cs.meta b/unity/Tests/Runtime/MjScenePlayTests.cs.meta
new file mode 100644
index 00000000..080ddfef
--- /dev/null
+++ b/unity/Tests/Runtime/MjScenePlayTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5235f153ea7908fad80b5c28b3978ac4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Runtime/MjSitePlayTests.cs b/unity/Tests/Runtime/MjSitePlayTests.cs
new file mode 100644
index 00000000..ad37bb9f
--- /dev/null
+++ b/unity/Tests/Runtime/MjSitePlayTests.cs
@@ -0,0 +1,67 @@
+// Copyright 2019 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if UNITY_EDITOR
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Xml;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Mujoco {
+
+[TestFixture]
+public class MjSiteStateSyncTests {
+  private MjBody _body;
+  private MjSite _site;
+  private MjScene _scene;
+
+  [SetUp]
+  public void SetUp() {
+    _scene = MjScene.Instance;
+    _body = new GameObject("body").AddComponent<MjBody>();
+    _site = new GameObject("site").AddComponent<MjSite>();
+    _site.transform.parent = _body.transform;
+  }
+
+  [TearDown]
+  public void TearDown() {
+    GameObject.DestroyImmediate(_site.gameObject);
+    GameObject.DestroyImmediate(_body.gameObject);
+    GameObject.DestroyImmediate(_scene.gameObject);
+    GameObject.DestroyImmediate(MjScene.Instance);
+  }
+
+  [UnityTest]
+  public IEnumerator InitialTransform() {
+    _site.transform.position = new Vector3(1, 2, 3);
+    _scene.CreateScene(); // compilation happens here
+    yield return new WaitForFixedUpdate(); // updating the transform
+    Assert.That(_site.transform.position, Is.EqualTo(new Vector3(1, 2, 3)));
+  }
+
+  [UnityTest]
+  public IEnumerator ChangedTransformIsOverwrittenByItsMjCounterpart() {
+    _scene.CreateScene(); // compilation happens here
+    _site.transform.position = new Vector3(1, 2, 3);
+    yield return new WaitForFixedUpdate(); // updating the transform
+    Assert.That(_site.transform.position, Is.EqualTo(Vector3.zero));
+  }
+}
+}
+
+#endif
diff --git a/unity/Tests/Runtime/MjSitePlayTests.cs.meta b/unity/Tests/Runtime/MjSitePlayTests.cs.meta
new file mode 100644
index 00000000..1422ccab
--- /dev/null
+++ b/unity/Tests/Runtime/MjSitePlayTests.cs.meta
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: add332d9433794539b0daf49d5d388bd
+timeCreated: 1547485698
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/Tests/Runtime/Mujoco.Tests.asmdef b/unity/Tests/Runtime/Mujoco.Tests.asmdef
new file mode 100644
index 00000000..b0e28256
--- /dev/null
+++ b/unity/Tests/Runtime/Mujoco.Tests.asmdef
@@ -0,0 +1,21 @@
+{
+    "name": "Tests.Runtime",
+    "rootNamespace": "",
+    "references": [
+        "UnityEngine.TestRunner",
+        "Mujoco"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/unity/Tests/Runtime/Mujoco.Tests.asmdef.meta b/unity/Tests/Runtime/Mujoco.Tests.asmdef.meta
new file mode 100644
index 00000000..fe77525e
--- /dev/null
+++ b/unity/Tests/Runtime/Mujoco.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 20c866b9eb6a4306297cce0c740191d2
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/unity/package.json b/unity/package.json
new file mode 100644
index 00000000..16e67fa7
--- /dev/null
+++ b/unity/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "org.mujoco",
+  "displayName": "MuJoCo",
+  "version": "2.1.1",
+  "description": "MuJoCo importer and runtime plug-in",
+  "dependencies": {},
+  "author": {
+    "name" : "DeepMind",
+    "email" : "mujoco@deepmind.com",
+    "url" : "https://mujoco.org/"
+  },
+  "changelogUrl": "https://mujoco.readthedocs.io/en/latest/changelog.html",
+  "documentationUrl": "https://mujoco.readthedocs.io/en/latest/unity.html",
+  "license": "Apache-2.0",
+  "licensesUrl": "https://github.com/deepmind/mujoco/blob/main/LICENSE"
+}
diff --git a/unity/package.json.meta b/unity/package.json.meta
new file mode 100644
index 00000000..dc56c33d
--- /dev/null
+++ b/unity/package.json.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 992a3ea023ad4f2dd85be1cb20a4a703
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: