diff --git a/src/Library/Attacks/AttackData.cpp b/src/Library/Attacks/AttackData.cpp
index c40116b..095cf66 100644
--- a/src/Library/Attacks/AttackData.cpp
+++ b/src/Library/Attacks/AttackData.cpp
@@ -8,10 +8,3 @@ CreatureLib::Library::AttackData::AttackData(const ArbUt::CaseInsensitiveConstSt
                                              const SecondaryEffect* effect, std::unordered_set<uint32_t> flags)
     : _name(name), _type(type), _category(category), _basePower(power), _accuracy(accuracy), _baseUsages(baseUsage),
       _target(target), _priority(priority), _effect(effect), _flags(std::move(flags)) {}
-
-bool CreatureLib::Library::AttackData::HasFlag(const ArbUt::CaseInsensitiveConstString& key) const noexcept {
-    return this->_flags.find(key) != this->_flags.end();
-}
-bool CreatureLib::Library::AttackData::HasFlag(uint32_t key) const noexcept {
-    return this->_flags.find(key) != this->_flags.end();
-}
diff --git a/src/Library/Attacks/AttackData.hpp b/src/Library/Attacks/AttackData.hpp
index 0107301..2ea3c10 100644
--- a/src/Library/Attacks/AttackData.hpp
+++ b/src/Library/Attacks/AttackData.hpp
@@ -42,8 +42,12 @@ namespace CreatureLib::Library {
         }
         inline const std::unique_ptr<const SecondaryEffect>& GetSecondaryEffect() const noexcept { return _effect; }
 
-        bool HasFlag(const ArbUt::CaseInsensitiveConstString& key) const noexcept;
-        bool HasFlag(uint32_t keyHash) const noexcept;
+        inline bool HasFlag(const ArbUt::CaseInsensitiveConstString& key) const noexcept {
+            return this->_flags.find(key) != this->_flags.end();
+        }
+        inline bool HasFlag(uint32_t keyHash) const noexcept {
+            return this->_flags.find(keyHash) != this->_flags.end();
+        }
     };
 }
 
diff --git a/src/Library/Attacks/SecondaryEffect.hpp b/src/Library/Attacks/SecondaryEffect.hpp
index 109b2d0..0a5e922 100644
--- a/src/Library/Attacks/SecondaryEffect.hpp
+++ b/src/Library/Attacks/SecondaryEffect.hpp
@@ -19,7 +19,7 @@ namespace CreatureLib::Library {
                         const ArbUt::List<EffectParameter*>& parameters) noexcept
             : _chance(chance), _effectName(effectName), _parameters(parameters) {}
 
-        ~SecondaryEffect() {
+        ~SecondaryEffect() noexcept {
             for (auto p : _parameters) {
                 delete p;
             }
diff --git a/src/Library/BaseLibrary.hpp b/src/Library/BaseLibrary.hpp
index 19591d3..4cd6ce8 100644
--- a/src/Library/BaseLibrary.hpp
+++ b/src/Library/BaseLibrary.hpp
@@ -20,7 +20,7 @@ namespace CreatureLib::Library {
     public:
         BaseLibrary(size_t initialCapacity = 32) : _values(initialCapacity), _listValues(initialCapacity) {}
 
-        virtual ~BaseLibrary() { _values.Clear(); }
+        virtual ~BaseLibrary() noexcept { _values.Clear(); }
 
         inline void Insert(const ArbUt::CaseInsensitiveConstString& key, const T* value) {
             AssertNotNull(value)
@@ -33,21 +33,21 @@ namespace CreatureLib::Library {
             _listValues.Append(hashedKey);
         }
 
-        inline void Delete(const ArbUt::CaseInsensitiveConstString& key) {
+        inline void Delete(const ArbUt::CaseInsensitiveConstString& key) noexcept {
             _values.erase(key.GetHash());
             auto k = _listValues.IndexOf(key);
             _listValues.Remove(k);
         }
-        inline void Delete(uint32_t hashedKey) {
+        inline void Delete(uint32_t hashedKey) noexcept {
             _values.Remove(hashedKey);
             auto k = _listValues.IndexOf(hashedKey);
             _listValues.Remove(k);
         }
 
-        bool TryGet(const ArbUt::CaseInsensitiveConstString& name, ArbUt::BorrowedPtr<const T>& out) const {
+        bool TryGet(const ArbUt::CaseInsensitiveConstString& name, ArbUt::BorrowedPtr<const T>& out) const noexcept {
             return TryGet(name.GetHash(), out);
         }
-        bool TryGet(uint32_t hashedKey, ArbUt::BorrowedPtr<const T>& out) const {
+        bool TryGet(uint32_t hashedKey, ArbUt::BorrowedPtr<const T>& out) const noexcept {
             auto find = _values.GetStdMap().find(hashedKey);
             if (find == _values.GetStdMap().end())
                 return false;
@@ -67,17 +67,18 @@ namespace CreatureLib::Library {
             return Get(name);
         }
         [[nodiscard]] inline ArbUt::BorrowedPtr<const T> operator[](uint32_t hashedKey) const { return Get(hashedKey); }
-        [[nodiscard]] inline const ArbUt::Dictionary<uint32_t, const std::unique_ptr<const T>>& GetIterator() const {
+        [[nodiscard]] inline const ArbUt::Dictionary<uint32_t, const std::unique_ptr<const T>>&
+        GetIterator() const noexcept {
             return _values;
         }
 
-        [[nodiscard]] size_t GetCount() const { return _values.Count(); }
+        [[nodiscard]] size_t GetCount() const noexcept { return _values.Count(); }
 
-        inline ArbUt::BorrowedPtr<const T> GetRandomValue(ArbUt::Random rand = ArbUt::Random()) const {
+        inline ArbUt::BorrowedPtr<const T> GetRandomValue(ArbUt::Random rand = ArbUt::Random()) const noexcept {
             auto i = rand.Get(_listValues.Count());
             return _values[_listValues[i]];
         }
-        inline ArbUt::BorrowedPtr<const T> GetRandomValue(ArbUt::Random* rand) const {
+        inline ArbUt::BorrowedPtr<const T> GetRandomValue(ArbUt::Random* rand) const noexcept {
             auto i = rand->Get(_listValues.Count());
             return _values[_listValues[i]];
         }
diff --git a/src/Library/ClampedStatisticSet.hpp b/src/Library/ClampedStatisticSet.hpp
index fc38474..51581a4 100644
--- a/src/Library/ClampedStatisticSet.hpp
+++ b/src/Library/ClampedStatisticSet.hpp
@@ -14,18 +14,19 @@ namespace CreatureLib::Library {
         T _speed;
 
     public:
-        ClampedStatisticSet(T health, T physicalAttack, T physicalDefense, T magicalAttack, T magicalDefense, T speed)
+        inline ClampedStatisticSet(T health, T physicalAttack, T physicalDefense, T magicalAttack, T magicalDefense,
+                                   T speed) noexcept
             : _health(health), _physicalAttack(physicalAttack), _physicalDefense(physicalDefense),
               _magicalAttack(magicalAttack), _magicalDefense(magicalDefense), _speed(speed) {}
-        ClampedStatisticSet()
+        inline ClampedStatisticSet() noexcept
             : _health(0), _physicalAttack(0), _physicalDefense(0), _magicalAttack(0), _magicalDefense(0), _speed(0) {}
 
-        inline T GetHealth() const { return _health; }
-        inline T GetPhysicalAttack() const { return _physicalAttack; }
-        inline T GetPhysicalDefense() const { return _physicalDefense; }
-        inline T GetMagicalAttack() const { return _magicalAttack; }
-        inline T GetMagicalDefense() const { return _magicalDefense; }
-        inline T GetSpeed() const { return _speed; }
+        inline T GetHealth() const noexcept { return _health; }
+        inline T GetPhysicalAttack() const noexcept { return _physicalAttack; }
+        inline T GetPhysicalDefense() const noexcept { return _physicalDefense; }
+        inline T GetMagicalAttack() const noexcept { return _magicalAttack; }
+        inline T GetMagicalDefense() const noexcept { return _magicalDefense; }
+        inline T GetSpeed() const noexcept { return _speed; }
 
         [[nodiscard]] inline T GetStat(Statistic stat) const {
             switch (stat) {
diff --git a/src/Library/CreatureData/CreatureSpecies.cpp b/src/Library/CreatureData/CreatureSpecies.cpp
index 224772d..3ce9012 100644
--- a/src/Library/CreatureData/CreatureSpecies.cpp
+++ b/src/Library/CreatureData/CreatureSpecies.cpp
@@ -11,13 +11,11 @@ CreatureSpecies::CreatureSpecies(uint16_t id, const ArbUt::CaseInsensitiveConstS
     SetVariant("default"_cnc, defaultVariant);
 }
 
-bool CreatureSpecies::HasVariant(const ArbUt::CaseInsensitiveConstString& name) const { return _variants.Has(name); }
-
 bool CreatureSpecies::TryGetVariant(const ArbUt::CaseInsensitiveConstString& name,
-                                    ArbUt::BorrowedPtr<const SpeciesVariant>& out) const {
+                                    ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept {
     return TryGetVariant(name.GetHash(), out);
 }
-bool CreatureSpecies::TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr<const SpeciesVariant>& out) const {
+bool CreatureSpecies::TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept {
     auto find = _variants.GetStdMap().find(hash);
     if (find == _variants.end())
         return false;
@@ -25,13 +23,6 @@ bool CreatureSpecies::TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr<const Spec
     return true;
 }
 
-ArbUt::BorrowedPtr<const SpeciesVariant>
-CreatureSpecies::GetVariant(const ArbUt::CaseInsensitiveConstString& name) const {
-    return _variants.Get(name);
-}
-ArbUt::BorrowedPtr<const SpeciesVariant> CreatureSpecies::GetVariant(uint32_t key) const { return _variants.Get(key); }
-bool CreatureSpecies::HasVariant(uint32_t hash) const { return _variants.Has(hash); }
-
 void CreatureSpecies::SetVariant(const ArbUt::CaseInsensitiveConstString& name, const SpeciesVariant* variant) {
     _variants.GetStdMap().insert({name, std::unique_ptr<const SpeciesVariant>(variant)});
 }
diff --git a/src/Library/CreatureData/CreatureSpecies.hpp b/src/Library/CreatureData/CreatureSpecies.hpp
index f7efbec..5e143a4 100644
--- a/src/Library/CreatureData/CreatureSpecies.hpp
+++ b/src/Library/CreatureData/CreatureSpecies.hpp
@@ -28,27 +28,33 @@ namespace CreatureLib::Library {
                         const SpeciesVariant* defaultVariant, float genderRatio,
                         const ArbUt::CaseInsensitiveConstString& growthRate, uint8_t captureRate);
 
-        virtual ~CreatureSpecies() { _variants.Clear(); }
+        virtual ~CreatureSpecies() noexcept { _variants.Clear(); }
 
-        inline uint16_t GetId() const { return _id; }
-        inline float GetGenderRate() const { return _genderRate; }
-        inline const ArbUt::CaseInsensitiveConstString& GetGrowthRate() const { return _growthRate; }
-        inline uint8_t GetCaptureRate() const { return _captureRate; }
+        inline uint16_t GetId() const noexcept { return _id; }
+        inline float GetGenderRate() const noexcept { return _genderRate; }
+        inline const ArbUt::CaseInsensitiveConstString& GetGrowthRate() const noexcept { return _growthRate; }
+        inline uint8_t GetCaptureRate() const noexcept { return _captureRate; }
 
-        [[nodiscard]] bool HasVariant(const ArbUt::CaseInsensitiveConstString& key) const;
-        [[nodiscard]] bool HasVariant(uint32_t hash) const;
+        [[nodiscard]] inline bool HasVariant(const ArbUt::CaseInsensitiveConstString& key) const noexcept {
+            return _variants.Has(key);
+        }
+        [[nodiscard]] inline bool HasVariant(uint32_t hash) const noexcept { return _variants.Has(hash); }
         [[nodiscard]] bool TryGetVariant(const ArbUt::CaseInsensitiveConstString& name,
-                                         ArbUt::BorrowedPtr<const SpeciesVariant>& out) const;
-        [[nodiscard]] bool TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr<const SpeciesVariant>& out) const;
-        [[nodiscard]] ArbUt::BorrowedPtr<const SpeciesVariant>
-        GetVariant(const ArbUt::CaseInsensitiveConstString& key) const;
-        [[nodiscard]] ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(uint32_t key) const;
-        [[nodiscard]] Gender GetRandomGender(ArbUt::Random& rand) const;
-        [[nodiscard]] const ArbUt::CaseInsensitiveConstString& GetName() const { return _name; }
+                                         ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept;
+        [[nodiscard]] bool TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept;
+        [[nodiscard]] inline ArbUt::BorrowedPtr<const SpeciesVariant>
+        GetVariant(const ArbUt::CaseInsensitiveConstString& key) const {
+            return _variants.Get(key);
+        }
+        [[nodiscard]] inline ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(uint32_t key) const {
+            return _variants.Get(key);
+        }
+        [[nodiscard]] Gender GetRandomGender(ArbUt::Random& rand) const noexcept;
+        [[nodiscard]] inline const ArbUt::CaseInsensitiveConstString& GetName() const { return _name; }
 
         void SetVariant(const ArbUt::CaseInsensitiveConstString& name, const SpeciesVariant* variant);
 
-        const ArbUt::Dictionary<uint32_t, std::unique_ptr<const SpeciesVariant>>& GetVariantsIterator() const {
+        inline const ArbUt::Dictionary<uint32_t, std::unique_ptr<const SpeciesVariant>>& GetVariantsIterator() const {
             return _variants;
         }
     };
diff --git a/src/Library/CreatureData/LearnableAttacks.cpp b/src/Library/CreatureData/LearnableAttacks.cpp
index 4f2d2ec..16c6ac3 100644
--- a/src/Library/CreatureData/LearnableAttacks.cpp
+++ b/src/Library/CreatureData/LearnableAttacks.cpp
@@ -11,8 +11,4 @@ void LearnableAttacks::AddLevelAttack(uint8_t level, const AttackData* attack) {
         _learnedByLevel.Insert(level, levelData);
     }
     _distinctAttacks.insert(attack);
-}
-
-const ArbUt::List<const AttackData*>& LearnableAttacks::GetAttacksForLevel(uint8_t level) const {
-    return _learnedByLevel.Get(level);
-}
+}
\ No newline at end of file
diff --git a/src/Library/CreatureData/LearnableAttacks.hpp b/src/Library/CreatureData/LearnableAttacks.hpp
index 128e3e0..e075014 100644
--- a/src/Library/CreatureData/LearnableAttacks.hpp
+++ b/src/Library/CreatureData/LearnableAttacks.hpp
@@ -29,7 +29,9 @@ namespace CreatureLib::Library {
 
         void AddLevelAttack(uint8_t level, const AttackData* attack);
 
-        const ArbUt::List<const AttackData*>& GetAttacksForLevel(uint8_t level) const;
+        inline const ArbUt::List<const AttackData*>& GetAttacksForLevel(uint8_t level) const {
+            return _learnedByLevel.Get(level);
+        }
 
         virtual const AttackData* GetRandomAttack(ArbUt::Random& rand) const {
             if (_distinctAttacks.empty()) {
diff --git a/src/Library/CreatureData/SpeciesVariant.cpp b/src/Library/CreatureData/SpeciesVariant.cpp
index fa46866..7ac09e3 100644
--- a/src/Library/CreatureData/SpeciesVariant.cpp
+++ b/src/Library/CreatureData/SpeciesVariant.cpp
@@ -1,16 +1,5 @@
 #include "SpeciesVariant.hpp"
 #include <algorithm>
-#include <utility>
-
-const ArbUt::List<uint8_t>& CreatureLib::Library::SpeciesVariant::GetTypes() const { return _types; }
-
-size_t CreatureLib::Library::SpeciesVariant::GetTypeCount() const { return _types.Count(); }
-
-uint8_t CreatureLib::Library::SpeciesVariant::GetType(size_t index) const { return _types[index]; }
-
-uint16_t CreatureLib::Library::SpeciesVariant::GetStatistic(CreatureLib::Library::Statistic stat) const {
-    return _baseStatistics.GetStat(stat);
-}
 
 const CreatureLib::Library::TalentIndex
 CreatureLib::Library::SpeciesVariant::GetTalentIndex(const ArbUt::CaseInsensitiveConstString& talent) const {
@@ -25,23 +14,4 @@ CreatureLib::Library::SpeciesVariant::GetTalentIndex(const ArbUt::CaseInsensitiv
         }
     }
     throw CreatureException("The given talent is not a valid talent for this creature.");
-}
-
-CreatureLib::Library::TalentIndex CreatureLib::Library::SpeciesVariant::GetRandomTalent(ArbUt::Random* rand) const {
-    return TalentIndex(false, rand->Get(_talents.Count()));
-}
-
-const std::unique_ptr<const CreatureLib::Library::LearnableAttacks>&
-CreatureLib::Library::SpeciesVariant::GetLearnableAttacks() const {
-    return _attacks;
-}
-
-CreatureLib::Library::SpeciesVariant::SpeciesVariant(ArbUt::CaseInsensitiveConstString name, float height, float weight,
-                                                     uint32_t baseExperience, ArbUt::List<uint8_t> types,
-                                                     CreatureLib::Library::StatisticSet<uint16_t> baseStats,
-                                                     ArbUt::List<ArbUt::CaseInsensitiveConstString> talents,
-                                                     ArbUt::List<ArbUt::CaseInsensitiveConstString> secretTalents,
-                                                     const LearnableAttacks* attacks)
-    : _name(std::move(name)), _height(height), _weight(weight), _baseExperience(baseExperience),
-      _types(std::move(types)), _baseStatistics(baseStats), _talents(std::move(talents)),
-      _secretTalents(std::move(secretTalents)), _attacks(attacks) {}
+}
\ No newline at end of file
diff --git a/src/Library/CreatureData/SpeciesVariant.hpp b/src/Library/CreatureData/SpeciesVariant.hpp
index 5232968..d7fea6d 100644
--- a/src/Library/CreatureData/SpeciesVariant.hpp
+++ b/src/Library/CreatureData/SpeciesVariant.hpp
@@ -28,11 +28,14 @@ namespace CreatureLib::Library {
         std::unique_ptr<const LearnableAttacks> _attacks;
 
     public:
-        SpeciesVariant(ArbUt::CaseInsensitiveConstString name, float height, float weight, uint32_t baseExperience,
-                       ArbUt::List<uint8_t> types, Library::StatisticSet<uint16_t> baseStats,
-                       ArbUt::List<ArbUt::CaseInsensitiveConstString> talents,
-                       ArbUt::List<ArbUt::CaseInsensitiveConstString> secretTalents, const LearnableAttacks* attacks);
-
+        SpeciesVariant(const ArbUt::CaseInsensitiveConstString& name, float height, float weight,
+                       uint32_t baseExperience, const ArbUt::List<uint8_t>& types,
+                       Library::StatisticSet<uint16_t> baseStats,
+                       const ArbUt::List<ArbUt::CaseInsensitiveConstString>& talents,
+                       const ArbUt::List<ArbUt::CaseInsensitiveConstString>& secretTalents,
+                       const LearnableAttacks* attacks)
+            : _name(name), _height(height), _weight(weight), _baseExperience(baseExperience), _types((types)),
+              _baseStatistics(baseStats), _talents(talents), _secretTalents(secretTalents), _attacks(attacks){};
         virtual ~SpeciesVariant() = default;
 
         inline const ArbUt::CaseInsensitiveConstString& GetName() const { return _name; }
@@ -40,12 +43,14 @@ namespace CreatureLib::Library {
         inline float GetWeight() const { return _weight; }
         inline uint32_t GetBaseExperience() const { return _baseExperience; }
 
-        [[nodiscard]] size_t GetTypeCount() const;
-        [[nodiscard]] uint8_t GetType(size_t index) const;
-        [[nodiscard]] const ArbUt::List<uint8_t>& GetTypes() const;
-        [[nodiscard]] uint16_t GetStatistic(Library::Statistic stat) const;
-        [[nodiscard]] const size_t GetTalentCount() const { return _talents.Count(); }
-        [[nodiscard]] const size_t GetSecretTalentCount() const { return _secretTalents.Count(); }
+        [[nodiscard]] inline size_t GetTypeCount() const { return _types.Count(); }
+        [[nodiscard]] inline uint8_t GetType(size_t index) const { return _types[index]; }
+        [[nodiscard]] inline const ArbUt::List<uint8_t>& GetTypes() const { return _types; }
+        [[nodiscard]] inline uint16_t GetStatistic(Library::Statistic stat) const {
+            return _baseStatistics.GetStat(stat);
+        }
+        [[nodiscard]] inline const size_t GetTalentCount() const noexcept { return _talents.Count(); }
+        [[nodiscard]] inline const size_t GetSecretTalentCount() const noexcept { return _secretTalents.Count(); }
         [[nodiscard]] const ArbUt::CaseInsensitiveConstString& GetTalent(const TalentIndex& index) const {
             if (index.IsSecret() && _secretTalents.Count() > 0) {
                 auto i = index.GetIndex();
@@ -60,8 +65,13 @@ namespace CreatureLib::Library {
         }
         [[nodiscard]] const TalentIndex GetTalentIndex(const ArbUt::CaseInsensitiveConstString& talent) const;
 
-        [[nodiscard]] const std::unique_ptr<const CreatureLib::Library::LearnableAttacks>& GetLearnableAttacks() const;
-        [[nodiscard]] TalentIndex GetRandomTalent(ArbUt::Random* rand) const;
+        [[nodiscard]] inline ArbUt::BorrowedPtr<const CreatureLib::Library::LearnableAttacks>
+        GetLearnableAttacks() const {
+            return _attacks;
+        }
+        [[nodiscard]] inline TalentIndex GetRandomTalent(ArbUt::Random* rand) const noexcept {
+            return TalentIndex(false, rand->Get(_talents.Count()));
+        }
         [[nodiscard]] inline const ArbUt::List<ArbUt::CaseInsensitiveConstString>& GetTalents() const {
             return _talents;
         }
diff --git a/src/Library/CreatureData/TalentIndex.hpp b/src/Library/CreatureData/TalentIndex.hpp
index 683f259..d911a40 100644
--- a/src/Library/CreatureData/TalentIndex.hpp
+++ b/src/Library/CreatureData/TalentIndex.hpp
@@ -8,10 +8,10 @@ namespace CreatureLib::Library {
         uint8_t _index;
 
     public:
-        TalentIndex() : _secret(false), _index(0){};
-        TalentIndex(bool secret, uint8_t index) : _secret(secret), _index(index) {}
-        constexpr inline bool IsSecret() const { return _secret; }
-        constexpr inline bool GetIndex() const { return _index; }
+        inline TalentIndex() noexcept : _secret(false), _index(0){};
+        inline TalentIndex(bool secret, uint8_t index) noexcept : _secret(secret), _index(index) {}
+        constexpr inline bool IsSecret() const noexcept { return _secret; }
+        constexpr inline bool GetIndex() const noexcept { return _index; }
     };
 }
 
diff --git a/src/Library/DataLibrary.hpp b/src/Library/DataLibrary.hpp
index 646fccd..8ec3905 100644
--- a/src/Library/DataLibrary.hpp
+++ b/src/Library/DataLibrary.hpp
@@ -28,16 +28,24 @@ namespace CreatureLib::Library {
 
         virtual ~DataLibrary() {}
 
-        [[nodiscard]] const std::unique_ptr<const LibrarySettings>& GetSettings() const noexcept { return _settings; }
-        [[nodiscard]] const std::unique_ptr<const SpeciesLibrary>& GetSpeciesLibrary() const noexcept {
+        [[nodiscard]] inline const std::unique_ptr<const LibrarySettings>& GetSettings() const noexcept {
+            return _settings;
+        }
+        [[nodiscard]] inline const std::unique_ptr<const SpeciesLibrary>& GetSpeciesLibrary() const noexcept {
             return _species;
         }
-        [[nodiscard]] const std::unique_ptr<const AttackLibrary>& GetAttackLibrary() const noexcept { return _attacks; }
-        [[nodiscard]] const std::unique_ptr<const ItemLibrary>& GetItemLibrary() const noexcept { return _items; }
-        [[nodiscard]] const std::unique_ptr<const GrowthRateLibrary>& GetGrowthRates() const noexcept {
+        [[nodiscard]] inline const std::unique_ptr<const AttackLibrary>& GetAttackLibrary() const noexcept {
+            return _attacks;
+        }
+        [[nodiscard]] inline const std::unique_ptr<const ItemLibrary>& GetItemLibrary() const noexcept {
+            return _items;
+        }
+        [[nodiscard]] inline const std::unique_ptr<const GrowthRateLibrary>& GetGrowthRates() const noexcept {
             return _growthRates;
         }
-        [[nodiscard]] const std::unique_ptr<const TypeLibrary>& GetTypeLibrary() const noexcept { return _typeLibrary; }
+        [[nodiscard]] inline const std::unique_ptr<const TypeLibrary>& GetTypeLibrary() const noexcept {
+            return _typeLibrary;
+        }
     };
 }
 
diff --git a/src/Library/EffectParameter.hpp b/src/Library/EffectParameter.hpp
index 7cc52ca..074d947 100644
--- a/src/Library/EffectParameter.hpp
+++ b/src/Library/EffectParameter.hpp
@@ -14,16 +14,16 @@ namespace CreatureLib::Library {
         std::variant<bool, int64_t, float, ArbUt::CaseInsensitiveConstString> _value;
 
     public:
-        EffectParameter() : _type(EffectParameterType::None){};
-        explicit EffectParameter(bool b) : _type(EffectParameterType::Bool), _value(b){};
-        explicit EffectParameter(int64_t i) : _type(EffectParameterType::Int), _value(i){};
-        explicit EffectParameter(float f) : _type(EffectParameterType::Float), _value(f){};
-        explicit EffectParameter(const ArbUt::CaseInsensitiveConstString& s)
+        inline EffectParameter() : _type(EffectParameterType::None){};
+        inline explicit EffectParameter(bool b) : _type(EffectParameterType::Bool), _value(b){};
+        inline explicit EffectParameter(int64_t i) : _type(EffectParameterType::Int), _value(i){};
+        inline explicit EffectParameter(float f) : _type(EffectParameterType::Float), _value(f){};
+        inline explicit EffectParameter(const ArbUt::CaseInsensitiveConstString& s)
             : _type(EffectParameterType::String), _value(s){};
         EffectParameter(const EffectParameter& other) = delete;
         EffectParameter& operator=(const EffectParameter& other) = delete;
 
-        EffectParameterType GetType() const noexcept { return _type; }
+        inline EffectParameterType GetType() const noexcept { return _type; }
         bool AsBool() const {
             if (_type != EffectParameterType::Bool) {
                 std::stringstream ss;
diff --git a/src/Library/GrowthRates/ExternGrowthRate.hpp b/src/Library/GrowthRates/ExternGrowthRate.hpp
index 2c8c076..3e2a603 100644
--- a/src/Library/GrowthRates/ExternGrowthRate.hpp
+++ b/src/Library/GrowthRates/ExternGrowthRate.hpp
@@ -9,7 +9,7 @@ namespace CreatureLib::Library {
         uint32_t (*_calcExperience)(uint8_t level);
 
     public:
-        ExternGrowthRate(uint8_t (*calcLevel)(uint32_t), uint32_t (*calcExperience)(uint8_t level))
+        inline ExternGrowthRate(uint8_t (*calcLevel)(uint32_t), uint32_t (*calcExperience)(uint8_t level))
             : _calcLevel(calcLevel), _calcExperience(calcExperience) {
             AssertNotNull(calcLevel)
             AssertNotNull(calcExperience)
diff --git a/src/Library/Items/Item.cpp b/src/Library/Items/Item.cpp
deleted file mode 100644
index b81d9c7..0000000
--- a/src/Library/Items/Item.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "Item.hpp"
-
-bool CreatureLib::Library::Item::HasFlag(const ArbUt::CaseInsensitiveConstString& flag) const noexcept {
-    return this->_flags.find(flag) != this->_flags.end();
-}
-bool CreatureLib::Library::Item::HasFlag(uint32_t flag) const noexcept {
-    return this->_flags.find(flag) != this->_flags.end();
-}
-
-CreatureLib::Library::Item::Item(const ArbUt::CaseInsensitiveConstString& name,
-                                 CreatureLib::Library::ItemCategory category,
-                                 CreatureLib::Library::BattleItemCategory battleCategory, int32_t price,
-                                 const std::unordered_set<uint32_t>& flags)
-    : _name(name), _category(category), _battleCategory(battleCategory), _price(price), _flags(flags) {}
diff --git a/src/Library/Items/Item.hpp b/src/Library/Items/Item.hpp
index 149cb29..3c736d0 100644
--- a/src/Library/Items/Item.hpp
+++ b/src/Library/Items/Item.hpp
@@ -17,16 +17,20 @@ namespace CreatureLib::Library {
         std::unordered_set<uint32_t> _flags;
 
     public:
-        Item(const ArbUt::CaseInsensitiveConstString& name, ItemCategory category, BattleItemCategory battleCategory,
-             int32_t price, const std::unordered_set<uint32_t>& flags);
+        inline Item(const ArbUt::CaseInsensitiveConstString& name, ItemCategory category,
+                    BattleItemCategory battleCategory, int32_t price,
+                    const std::unordered_set<uint32_t>& flags) noexcept
+            : _name(name), _category(category), _battleCategory(battleCategory), _price(price), _flags(flags) {}
 
         inline const ArbUt::CaseInsensitiveConstString& GetName() const noexcept { return _name; }
         inline ItemCategory GetCategory() const noexcept { return _category; }
         inline BattleItemCategory GetBattleCategory() const noexcept { return _battleCategory; }
         inline const int32_t GetPrice() const noexcept { return _price; }
 
-        bool HasFlag(const ArbUt::CaseInsensitiveConstString& flag) const noexcept;
-        bool HasFlag(uint32_t flag) const noexcept;
+        bool HasFlag(const ArbUt::CaseInsensitiveConstString& flag) const noexcept {
+            return this->_flags.find(flag) != this->_flags.end();
+        }
+        bool HasFlag(uint32_t flag) const noexcept { return this->_flags.find(flag) != this->_flags.end(); }
     };
 }
 
diff --git a/src/Library/LibrarySettings.hpp b/src/Library/LibrarySettings.hpp
index 69e845a..6dbf264 100644
--- a/src/Library/LibrarySettings.hpp
+++ b/src/Library/LibrarySettings.hpp
@@ -12,9 +12,9 @@ namespace CreatureLib::Library {
         LibrarySettings(uint8_t maximalLevel, uint8_t maximalMoves)
             : _maximalLevel(maximalLevel), _maximalMoves(maximalMoves) {}
 
-        inline uint8_t GetMaximalLevel() const { return _maximalLevel; }
+        inline uint8_t GetMaximalLevel() const noexcept { return _maximalLevel; }
 
-        inline uint8_t GetMaximalMoves() const { return _maximalMoves; }
+        inline uint8_t GetMaximalMoves() const noexcept { return _maximalMoves; }
     };
 }
 
diff --git a/src/Library/StatisticSet.hpp b/src/Library/StatisticSet.hpp
index 74e048f..e9eb3bd 100644
--- a/src/Library/StatisticSet.hpp
+++ b/src/Library/StatisticSet.hpp
@@ -16,18 +16,18 @@ namespace CreatureLib::Library {
         T _speed;
 
     public:
-        StatisticSet(T health, T physicalAttack, T physicalDefense, T magicalAttack, T magicalDefense, T speed)
+        StatisticSet(T health, T physicalAttack, T physicalDefense, T magicalAttack, T magicalDefense, T speed) noexcept
             : _health(health), _physicalAttack(physicalAttack), _physicalDefense(physicalDefense),
               _magicalAttack(magicalAttack), _magicalDefense(magicalDefense), _speed(speed) {}
-        StatisticSet()
+        StatisticSet() noexcept
             : _health(0), _physicalAttack(0), _physicalDefense(0), _magicalAttack(0), _magicalDefense(0), _speed(0) {}
 
-        inline T GetHealth() const { return _health; }
-        inline T GetPhysicalAttack() const { return _physicalAttack; }
-        inline T GetPhysicalDefense() const { return _physicalDefense; }
-        inline T GetMagicalAttack() const { return _magicalAttack; }
-        inline T GetMagicalDefense() const { return _magicalDefense; }
-        inline T GetSpeed() const { return _speed; }
+        inline T GetHealth() const noexcept { return _health; }
+        inline T GetPhysicalAttack() const noexcept { return _physicalAttack; }
+        inline T GetPhysicalDefense() const noexcept { return _physicalDefense; }
+        inline T GetMagicalAttack() const noexcept { return _magicalAttack; }
+        inline T GetMagicalDefense() const noexcept { return _magicalDefense; }
+        inline T GetSpeed() const noexcept { return _speed; }
 
         [[nodiscard]] inline T GetStat(Statistic stat) const {
             switch (stat) {
diff --git a/src/Library/TypeLibrary.cpp b/src/Library/TypeLibrary.cpp
index b6cadd1..4f7cc8b 100644
--- a/src/Library/TypeLibrary.cpp
+++ b/src/Library/TypeLibrary.cpp
@@ -1,22 +1,8 @@
 #include "TypeLibrary.hpp"
 #include <Arbutils/Assert.hpp>
-#include <numeric>
 
 using namespace CreatureLib::Library;
 
-float TypeLibrary::GetEffectiveness(uint8_t attacking, const std::unordered_set<uint8_t>& defensive) const {
-    return std::accumulate(
-        defensive.begin(), defensive.end(), (float)1,
-        [this, attacking](float init, uint8_t defense) { return init * GetSingleEffectiveness(attacking, defense); });
-}
-
-float TypeLibrary::GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) const {
-    return _effectiveness[attacking][defensive];
-}
-
-uint8_t TypeLibrary::GetTypeId(const ArbUt::CaseInsensitiveConstString& key) const { return _types.Get(key); }
-uint8_t TypeLibrary::GetTypeId(uint32_t s) const { return _types.Get(s); }
-
 uint8_t TypeLibrary::RegisterType(const ArbUt::CaseInsensitiveConstString& key) {
     _types.Insert(key, _types.Count());
     _effectiveness.Resize(_types.Count());
diff --git a/src/Library/TypeLibrary.hpp b/src/Library/TypeLibrary.hpp
index b189f4d..9db4c55 100644
--- a/src/Library/TypeLibrary.hpp
+++ b/src/Library/TypeLibrary.hpp
@@ -4,6 +4,7 @@
 #include <Arbutils/Collections/Dictionary.hpp>
 #include <Arbutils/Collections/List.hpp>
 #include <Arbutils/ConstString.hpp>
+#include <numeric>
 #include <unordered_set>
 #include <vector>
 
@@ -15,10 +16,18 @@ namespace CreatureLib::Library {
     public:
         TypeLibrary(size_t initialCapacity = 20) : _types(ArbUt::Dictionary<uint32_t, uint8_t>(initialCapacity)) {}
 
-        uint8_t GetTypeId(const ArbUt::CaseInsensitiveConstString& s) const;
-        uint8_t GetTypeId(uint32_t s) const;
-        [[nodiscard]] float GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) const;
-        [[nodiscard]] float GetEffectiveness(uint8_t attacking, const std::unordered_set<uint8_t>& defensive) const;
+        inline uint8_t GetTypeId(const ArbUt::CaseInsensitiveConstString& key) const { return _types.Get(key); }
+        inline uint8_t GetTypeId(uint32_t s) const { return _types.Get(s); }
+        [[nodiscard]] inline float GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) const {
+            return _effectiveness[attacking][defensive];
+        }
+        [[nodiscard]] inline float GetEffectiveness(uint8_t attacking,
+                                                    const std::unordered_set<uint8_t>& defensive) const {
+            return std::accumulate(defensive.begin(), defensive.end(), (float)1,
+                                   [this, attacking](float init, uint8_t defense) {
+                                       return init * GetSingleEffectiveness(attacking, defense);
+                                   });
+        }
 
         uint8_t RegisterType(const ArbUt::CaseInsensitiveConstString& typeName);
         uint8_t RegisterType(uint32_t typeHash);