diff --git a/apps/openmw_test_suite/nif/node.hpp b/apps/openmw_test_suite/nif/node.hpp
index b39729c876..c606fe67e5 100644
--- a/apps/openmw_test_suite/nif/node.hpp
+++ b/apps/openmw_test_suite/nif/node.hpp
@@ -63,7 +63,7 @@ namespace Nif::Testing
         value.phase = 0;
         value.timeStart = 0;
         value.timeStop = 0;
-        value.target = NiObjectNETPtr(nullptr);
+        value.mTarget = NiObjectNETPtr(nullptr);
     }
 }
 
diff --git a/components/nif/base.hpp b/components/nif/base.hpp
index 6b4d5710b4..a24359772d 100644
--- a/components/nif/base.hpp
+++ b/components/nif/base.hpp
@@ -40,7 +40,7 @@ namespace Nif
         int flags;
         float frequency, phase;
         float timeStart, timeStop;
-        NiObjectNETPtr target;
+        NiObjectNETPtr mTarget;
 
         void read(NIFStream* nif) override;
         void post(Reader& nif) override;
diff --git a/components/nif/controller.cpp b/components/nif/controller.cpp
index 7a8bb31152..a3c81f96da 100644
--- a/components/nif/controller.cpp
+++ b/components/nif/controller.cpp
@@ -1,6 +1,7 @@
 #include "controller.hpp"
 
 #include "data.hpp"
+#include "exception.hpp"
 #include "node.hpp"
 #include "particle.hpp"
 #include "texture.hpp"
@@ -13,20 +14,17 @@ namespace Nif
         next.read(nif);
 
         flags = nif->getUShort();
-
         frequency = nif->getFloat();
         phase = nif->getFloat();
         timeStart = nif->getFloat();
         timeStop = nif->getFloat();
-
-        target.read(nif);
+        mTarget.read(nif);
     }
 
     void Controller::post(Reader& nif)
     {
-        Record::post(nif);
         next.post(nif);
-        target.post(nif);
+        mTarget.post(nif);
     }
 
     void ControlledBlock::read(NIFStream* nif)
@@ -44,28 +42,28 @@ namespace Nif
         if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 110))
         {
             mBlendInterpolator.read(nif);
-            mBlendIndex = nif->getUShort();
+            nif->read(mBlendIndex);
         }
         if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 106) && nif->getBethVersion() > 0)
-            mPriority = nif->getChar();
+            nif->read(mPriority);
 
         if (nif->getVersion() >= NIFStream::generateVersion(10, 2, 0, 0)
             && nif->getVersion() <= NIFStream::generateVersion(20, 1, 0, 0))
         {
             mStringPalette.read(nif);
-            mNodeNameOffset = nif->getUInt();
-            mPropertyTypeOffset = nif->getUInt();
-            mControllerTypeOffset = nif->getUInt();
-            mControllerIdOffset = nif->getUInt();
-            mInterpolatorIdOffset = nif->getUInt();
+            nif->read(mNodeNameOffset);
+            nif->read(mPropertyTypeOffset);
+            nif->read(mControllerTypeOffset);
+            nif->read(mControllerIdOffset);
+            nif->read(mInterpolatorIdOffset);
         }
         else
         {
-            mNodeName = nif->getString();
-            mPropertyType = nif->getString();
-            mControllerType = nif->getString();
-            mControllerId = nif->getString();
-            mInterpolatorId = nif->getString();
+            nif->read(mNodeName);
+            nif->read(mPropertyType);
+            nif->read(mControllerType);
+            nif->read(mControllerId);
+            nif->read(mInterpolatorId);
         }
     }
 
@@ -80,16 +78,17 @@ namespace Nif
 
     void NiSequence::read(NIFStream* nif)
     {
-        mName = nif->getString();
+        nif->read(mName);
         if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
         {
-            mAccumRootName = nif->getString();
+            nif->read(mAccumRootName);
             mTextKeys.read(nif);
         }
-        size_t numControlledBlocks = nif->getUInt();
+        uint32_t numBlocks;
+        nif->read(numBlocks);
         if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 106))
-            mArrayGrowBy = nif->getUInt();
-        mControlledBlocks.resize(numControlledBlocks);
+            nif->read(mArrayGrowBy);
+        mControlledBlocks.resize(numBlocks);
         for (ControlledBlock& block : mControlledBlocks)
             block.read(nif);
     }
@@ -104,28 +103,30 @@ namespace Nif
     void NiControllerSequence::read(NIFStream* nif)
     {
         NiSequence::read(nif);
+
         if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
             return;
 
-        mWeight = nif->getFloat();
+        nif->read(mWeight);
         mTextKeys.read(nif);
         mExtrapolationMode = static_cast<Controller::ExtrapolationMode>(nif->getUInt());
         mFrequency = nif->getFloat();
         if (nif->getVersion() <= NIFStream::generateVersion(10, 4, 0, 1))
-            mPhase = nif->getFloat();
-        mStartTime = nif->getFloat();
-        mStopTime = nif->getFloat();
-        mPlayBackwards = nif->getVersion() == NIFStream::generateVersion(10, 1, 0, 106) && nif->getBoolean();
+            nif->read(mPhase);
+        nif->read(mStartTime);
+        nif->read(mStopTime);
+        if (nif->getVersion() == NIFStream::generateVersion(10, 1, 0, 106))
+            nif->read(mPlayBackwards);
         mManager.read(nif);
-        mAccumRootName = nif->getString();
+        nif->read(mAccumRootName);
         if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 113)
             && nif->getVersion() <= NIFStream::generateVersion(20, 1, 0, 0))
             mStringPalette.read(nif);
         else if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() >= 24)
         {
-            size_t numAnimNotes = 1;
+            uint16_t numAnimNotes = 1;
             if (nif->getBethVersion() >= 29)
-                numAnimNotes = nif->getUShort();
+                nif->read(numAnimNotes);
 
             nif->skip(4 * numAnimNotes); // BSAnimNotes links
         }
@@ -134,6 +135,7 @@ namespace Nif
     void NiControllerSequence::post(Reader& nif)
     {
         NiSequence::post(nif);
+
         mManager.post(nif);
         mStringPalette.post(nif);
     }
@@ -141,14 +143,16 @@ namespace Nif
     void NiInterpController::read(NIFStream* nif)
     {
         Controller::read(nif);
+
         if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 104)
             && nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 108))
-            mManagerControlled = nif->getBoolean();
+            nif->read(mManagerControlled);
     }
 
     void NiSingleInterpController::read(NIFStream* nif)
     {
         NiInterpController::read(nif);
+
         if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 104))
             mInterpolator.read(nif);
     }
@@ -156,6 +160,7 @@ namespace Nif
     void NiSingleInterpController::post(Reader& nif)
     {
         NiInterpController::post(nif);
+
         mInterpolator.post(nif);
     }
 
@@ -216,6 +221,7 @@ namespace Nif
     void NiParticleSystemController::post(Reader& nif)
     {
         Controller::post(nif);
+
         emitter.post(nif);
         affectors.post(nif);
         colliders.post(nif);
@@ -244,15 +250,17 @@ namespace Nif
     void NiLookAtController::read(NIFStream* nif)
     {
         Controller::read(nif);
+
         if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
-            lookAtFlags = nif->getUShort();
-        target.read(nif);
+            nif->read(mLookAtFlags);
+        mLookAt.read(nif);
     }
 
     void NiLookAtController::post(Reader& nif)
     {
         Controller::post(nif);
-        target.post(nif);
+
+        mLookAt.post(nif);
     }
 
     void NiPathController::read(NIFStream* nif)
@@ -286,6 +294,7 @@ namespace Nif
     void NiUVController::post(Reader& nif)
     {
         Controller::post(nif);
+
         data.post(nif);
     }
 
@@ -323,6 +332,7 @@ namespace Nif
     void NiAlphaController::read(NIFStream* nif)
     {
         NiFloatInterpController::read(nif);
+
         if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
             mData.read(nif);
     }
@@ -330,12 +340,14 @@ namespace Nif
     void NiAlphaController::post(Reader& nif)
     {
         NiFloatInterpController::post(nif);
+
         mData.post(nif);
     }
 
     void NiRollController::read(NIFStream* nif)
     {
         NiSingleInterpController::read(nif);
+
         if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
             mData.read(nif);
     }
@@ -343,49 +355,47 @@ namespace Nif
     void NiRollController::post(Reader& nif)
     {
         NiSingleInterpController::post(nif);
+
         mData.post(nif);
     }
 
     void NiGeomMorpherController::read(NIFStream* nif)
     {
         NiInterpController::read(nif);
+
         if (nif->getVersion() >= NIFFile::NIFVersion::VER_OB_OLD)
-            mUpdateNormals = nif->getUShort() & 1;
+            mUpdateNormals = nif->get<uint16_t>() & 1;
         mData.read(nif);
-        if (nif->getVersion() >= NIFFile::NIFVersion::VER_MW)
+
+        if (nif->getVersion() < NIFFile::NIFVersion::VER_MW)
+            return;
+
+        mAlwaysActive = nif->get<uint8_t>() != 0;
+
+        if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 105))
+            return;
+
+        if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
         {
-            mAlwaysActive = nif->getChar();
-            if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 106))
-            {
-                if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
-                {
-                    readRecordList(nif, mInterpolators);
-                    if (nif->getVersion() >= NIFStream::generateVersion(10, 2, 0, 0) && nif->getBethVersion() > 9)
-                    {
-                        unsigned int numUnknown = nif->getUInt();
-                        nif->skip(4 * numUnknown);
-                    }
-                }
-                else
-                {
-                    std::vector<NiInterpolatorPtr> interpolators;
-                    size_t numInterps = nif->getUInt();
-                    interpolators.resize(numInterps);
-                    mWeights.resize(numInterps);
-                    for (size_t i = 0; i < numInterps; i++)
-                    {
-                        interpolators[i].read(nif);
-                        mWeights[i] = nif->getFloat();
-                    }
-                    mInterpolators = interpolators;
-                }
-            }
+            readRecordList(nif, mInterpolators);
+            if (nif->getVersion() >= NIFStream::generateVersion(10, 2, 0, 0) && nif->getBethVersion() >= 10)
+                nif->skip(4 * nif->get<uint32_t>()); // Unknown
+            return;
+        }
+
+        mInterpolators.resize(nif->get<uint32_t>());
+        mWeights.resize(mInterpolators.size());
+        for (size_t i = 0; i < mInterpolators.size(); i++)
+        {
+            mInterpolators[i].read(nif);
+            nif->read(mWeights[i]);
         }
     }
 
     void NiGeomMorpherController::post(Reader& nif)
     {
         NiInterpController::post(nif);
+
         mData.post(nif);
         postRecordList(nif, mInterpolators);
     }
@@ -393,6 +403,7 @@ namespace Nif
     void NiVisController::read(NIFStream* nif)
     {
         NiBoolInterpController::read(nif);
+
         if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
             mData.read(nif);
     }
@@ -400,17 +411,19 @@ namespace Nif
     void NiVisController::post(Reader& nif)
     {
         NiBoolInterpController::post(nif);
+
         mData.post(nif);
     }
 
     void NiFlipController::read(NIFStream* nif)
     {
         NiFloatInterpController::read(nif);
-        mTexSlot = nif->getUInt();
+
+        mTexSlot = static_cast<NiTexturingProperty::TextureType>(nif->get<uint32_t>());
         if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
         {
-            timeStart = nif->getFloat();
-            mDelta = nif->getFloat();
+            nif->read(timeStart);
+            nif->read(mDelta);
         }
         readRecordList(nif, mSources);
     }
@@ -418,14 +431,16 @@ namespace Nif
     void NiFlipController::post(Reader& nif)
     {
         NiFloatInterpController::post(nif);
+
         postRecordList(nif, mSources);
     }
 
     void NiTextureTransformController::read(NIFStream* nif)
     {
         NiFloatInterpController::read(nif);
-        mShaderMap = nif->getBoolean();
-        nif->read(mTexSlot);
+
+        nif->read(mShaderMap);
+        mTexSlot = static_cast<NiTexturingProperty::TextureType>(nif->get<uint32_t>());
         nif->read(mTransformMember);
         if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
             mData.read(nif);
@@ -434,31 +449,41 @@ namespace Nif
     void NiTextureTransformController::post(Reader& nif)
     {
         NiFloatInterpController::post(nif);
+
         mData.post(nif);
     }
 
     void bhkBlendController::read(NIFStream* nif)
     {
         Controller::read(nif);
-        nif->getUInt(); // Zero
+
+        uint32_t numKeys;
+        nif->read(numKeys);
+        // Is this possible?
+        if (numKeys != 0)
+            throw Nif::Exception(
+                "Unsupported keys in bhkBlendController " + std::to_string(recIndex), nif->getFile().getFilename());
     }
 
     void BSEffectShaderPropertyFloatController::read(NIFStream* nif)
     {
         NiFloatInterpController::read(nif);
+
         nif->read(mControlledVariable);
     }
 
     void BSEffectShaderPropertyColorController::read(NIFStream* nif)
     {
         NiPoint3InterpController::read(nif);
+
         nif->read(mControlledColor);
     }
 
     void NiControllerManager::read(NIFStream* nif)
     {
         Controller::read(nif);
-        mCumulative = nif->getBoolean();
+
+        nif->read(mCumulative);
         readRecordList(nif, mSequences);
         mObjectPalette.read(nif);
     }
@@ -466,6 +491,7 @@ namespace Nif
     void NiControllerManager::post(Reader& nif)
     {
         Controller::post(nif);
+
         postRecordList(nif, mSequences);
         mObjectPalette.post(nif);
     }
diff --git a/components/nif/controller.hpp b/components/nif/controller.hpp
index 1a6847a5b7..730cda5bd6 100644
--- a/components/nif/controller.hpp
+++ b/components/nif/controller.hpp
@@ -14,14 +14,14 @@ namespace Nif
         NiInterpolatorPtr mInterpolator;
         ControllerPtr mController;
         NiBlendInterpolatorPtr mBlendInterpolator;
-        unsigned short mBlendIndex;
-        unsigned char mPriority;
+        uint16_t mBlendIndex;
+        uint8_t mPriority;
         NiStringPalettePtr mStringPalette;
-        size_t mNodeNameOffset;
-        size_t mPropertyTypeOffset;
-        size_t mControllerTypeOffset;
-        size_t mControllerIdOffset;
-        size_t mInterpolatorIdOffset;
+        uint32_t mNodeNameOffset;
+        uint32_t mPropertyTypeOffset;
+        uint32_t mControllerTypeOffset;
+        uint32_t mControllerIdOffset;
+        uint32_t mInterpolatorIdOffset;
         std::string mNodeName;
         std::string mPropertyType;
         std::string mControllerType;
@@ -38,7 +38,7 @@ namespace Nif
         std::string mName;
         std::string mAccumRootName;
         ExtraPtr mTextKeys;
-        unsigned int mArrayGrowBy;
+        uint32_t mArrayGrowBy;
         std::vector<ControlledBlock> mControlledBlocks;
 
         void read(NIFStream* nif) override;
@@ -197,8 +197,15 @@ namespace Nif
 
     struct NiLookAtController : public Controller
     {
-        NiAVObjectPtr target;
-        unsigned short lookAtFlags{ 0 };
+        enum Flags
+        {
+            Flag_Flip = 0x1,
+            Flag_LookYAxis = 0x2,
+            Flag_LookZAxis = 0x4,
+        };
+
+        uint16_t mLookAtFlags{ 0 };
+        NiAVObjectPtr mLookAt;
 
         void read(NIFStream* nif) override;
         void post(Reader& nif) override;
@@ -267,7 +274,7 @@ namespace Nif
 
     struct NiFlipController : public NiFloatInterpController
     {
-        int mTexSlot; // NiTexturingProperty::TextureType
+        NiTexturingProperty::TextureType mTexSlot;
         float mDelta; // Time between two flips. delta = (start_time - stop_time) / num_sources
         NiSourceTextureList mSources;
 
@@ -278,8 +285,8 @@ namespace Nif
     struct NiTextureTransformController : public NiFloatInterpController
     {
         bool mShaderMap;
-        int mTexSlot; // NiTexturingProperty::TextureType
-        unsigned int mTransformMember;
+        NiTexturingProperty::TextureType mTexSlot;
+        uint32_t mTransformMember;
         NiFloatDataPtr mData;
 
         void read(NIFStream* nif) override;
@@ -293,14 +300,14 @@ namespace Nif
 
     struct BSEffectShaderPropertyFloatController : public NiFloatInterpController
     {
-        unsigned int mControlledVariable;
+        uint32_t mControlledVariable;
 
         void read(NIFStream* nif) override;
     };
 
     struct BSEffectShaderPropertyColorController : public NiPoint3InterpController
     {
-        unsigned int mControlledColor;
+        uint32_t mControlledColor;
 
         void read(NIFStream* nif) override;
     };
@@ -310,10 +317,12 @@ namespace Nif
         bool mCumulative;
         NiControllerSequenceList mSequences;
         NiDefaultAVObjectPalettePtr mObjectPalette;
+
         void read(NIFStream* nif) override;
         void post(Reader& nif) override;
     };
 
+    // Abstract
     struct NiInterpolator : public Record
     {
     };
diff --git a/components/nif/property.hpp b/components/nif/property.hpp
index 90f1e9ffb5..d9574f31d6 100644
--- a/components/nif/property.hpp
+++ b/components/nif/property.hpp
@@ -79,7 +79,7 @@ namespace Nif
          * 5 - Bump map texture
          * 6 - Decal texture
          */
-        enum TextureType
+        enum TextureType : uint32_t
         {
             BaseTexture = 0,
             DarkTexture = 1,