diff --git a/Doxyfile b/Doxyfile
index 44468a071b..6417b0167a 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -947,6 +947,7 @@ INPUT = src \
         include \
         modules \
         apps \
+        ext/ghoul \
         support/doxygen/README.md
 
 # This tag can be used to specify the character encoding of the source files
@@ -987,9 +988,7 @@ INPUT_FILE_ENCODING =
 # provided as doxygen C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
 # *.f18, *.f, *.for, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice.
 
-FILE_PATTERNS = *.cpp \
-                *.h \
-                *.inl
+FILE_PATTERNS = *.cpp *.h *.inl
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.
@@ -1020,16 +1019,16 @@ EXCLUDE_SYMLINKS = NO
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories for example use the pattern */test/*
 
-EXCLUDE_PATTERNS = ext/* \
-                   bin/* \
-                   build/* \
-                   config/* \
-                   gui/* \
-                   kernels/* \
-                   data/* \
-                   scripts/* \
-                   shaders/* \
-                   **/ext/**
+EXCLUDE_PATTERNS = */ext/curl \
+                   */ext/date \
+                   */ext/json \
+                   */ext/spice \
+                   */ext/vld \
+                   */ext/tinythread \
+                   */ext/ghoul/ext/* \
+                   */modules/*/ext/* \
+                   */apps/OpenSpace-MinVR/ext/* \
+                   */apps/OpenSpace/ext/sgct/ext/*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the
diff --git a/ext/ghoul b/ext/ghoul
index fbd80eae0f..c2992bd52f 160000
--- a/ext/ghoul
+++ b/ext/ghoul
@@ -1 +1 @@
-Subproject commit fbd80eae0ff589a9fa2fb5e2c8af8e4491fe4e2d
+Subproject commit c2992bd52f7c4e29a85dcbe44e3e6a89ffec0c19
diff --git a/include/openspace/documentation/documentation.h b/include/openspace/documentation/documentation.h
index c8c7385613..28d2029922 100644
--- a/include/openspace/documentation/documentation.h
+++ b/include/openspace/documentation/documentation.h
@@ -56,11 +56,16 @@ struct TestResult {
     struct Offense {
         /// The Reason for the offense
         enum class Reason {
-            Unknown,          ///< Unknown reason
-            MissingKey,       ///< The offending key that was requested was not found
-            WrongType,        ///< The key's value was not of the expected type
-            Verification,     ///< The value did not pass a necessary non-type verifier
-            UnknownIdentifier ///< The identifier for a ReferencingVerifier did not exist
+            /// Unknown reason
+            Unknown,
+            /// The offending key that was requested was not found
+            MissingKey,
+            /// The key's value was not of the expected type
+            WrongType,
+            /// The value did not pass a necessary non-type verifier
+            Verification,
+            /// The identifier for a ReferencingVerifier did not exist
+            UnknownIdentifier
         };
         /// The offending key that caused the Offense. In the case of a nested table,
         /// this value will be the fully qualified name of the key
@@ -80,7 +85,8 @@ struct TestResult {
     struct Warning {
         /// The reason for the warning
         enum class Reason {
-            Deprecated ///< The value is marked as deprecated and should not used
+            /// The value is marked as deprecated and should not used
+            Deprecated
         };
 
         /// The offending key that caused the Warning. In the case of a nested table,
@@ -90,7 +96,6 @@ struct TestResult {
         Reason reason;
     };
 
-
     /// Is `true` if the TestResult is positive, `false` otherwise
     bool success = false;
     /// Contains a list of offenses that were found in the test. Is empty if
@@ -130,10 +135,10 @@ void logError(const SpecificationError& error, std::string component = "");
  * DocumentationEntry::Wildcard, any key in the containing Documentation will be tested
  * against the provided verifier. The most convenient way of creating DocumentationEntry%s
  * is by using an inline initializer list such as:
- *\verbatim
-DocumentationEntry e = { "key", new IntVerifier, "Documentation text", Optional::Yes };
-\endverbatim
-
+ * ```
+ * DocumentationEntry e = { "key", new IntVerifier, "Documentation text", Optional::Yes };
+ * ```
+ *
  * Furthermore, these initializer lists can be crated all at once for a Documentation.
  * Even if the Verifier%s are specified using the `new` operators, they will not leak
  * memory as the DocumentationEntry takes ownership of them in the constructor.
@@ -190,8 +195,7 @@ struct DocumentationEntry {
      * \pre \p k must not be empty
      * \pre \p v must not be nullptr
      */
-    DocumentationEntry(std::string k, Verifier* v, Optional opt,
-        std::string doc = "");
+    DocumentationEntry(std::string k, Verifier* v, Optional opt, std::string doc = "");
 
     /// The key that is described by this DocumentationEntry
     std::string key;
@@ -203,7 +207,6 @@ struct DocumentationEntry {
     std::string documentation;
 };
 
-
 /**
  * This struct contains the documentation and specification for a ghoul::Dictionary. It is
  * used to impose restrictions on keys and values and determine whether a given
@@ -211,16 +214,16 @@ struct DocumentationEntry {
  * #testSpecificationAndThrow methods). Each Documentation consists of a human-readable
  * `name`, and a list of DocumentationEntry%s that each describe a single key value. The
  * most convenient way of creating a Documentation is by using nested initializer lists:
- *\verbatim
-Documentation doc = {
-    "Documentation for an arbitrary dictionary",
-    { // A list of DocumentationEntry%s; also specified using initializer lists
-        { "key1", new IntVerifier, "Documentation key1", Optional::Yes },
-        { "key2", new FloatVerifier, "Documentation key2" },
-        { "key3", new StringVerifier }
-    }
-};
-\endverbatim
+ * ```
+ * Documentation doc = {
+ *     "Documentation for an arbitrary dictionary",
+ *     { // A list of DocumentationEntry%s; also specified using initializer lists
+ *         { "key1", new IntVerifier, "Documentation key1", Optional::Yes },
+ *         { "key2", new FloatVerifier, "Documentation key2" },
+ *         { "key3", new StringVerifier }
+ *     }
+ * };
+ * ```
  *
  * If multiple DocumentationEntries cover the same key, they are all evaluated for that
  * specific key. The same holds true if there is a DocumentationEntry with a
diff --git a/include/openspace/documentation/documentationengine.h b/include/openspace/documentation/documentationengine.h
index 88ec3042c7..a21f563b90 100644
--- a/include/openspace/documentation/documentationengine.h
+++ b/include/openspace/documentation/documentationengine.h
@@ -47,8 +47,7 @@ public:
          * Constructor of a DuplicateDocumentationException storing the offending
          * Documentation for later use.
          *
-         * \param doc The Documentation whose identifier was previously
-         *        registered
+         * \param doc The Documentation whose identifier was previously registered
          */
         DuplicateDocumentationException(Documentation doc);
 
@@ -92,7 +91,6 @@ public:
     nlohmann::json generateJsonJson() const;
 
 private:
-
     /// The list of all Documentation%s that are stored by the DocumentationEngine
     std::vector<Documentation> _documentations;
 
diff --git a/include/openspace/documentation/verifier.h b/include/openspace/documentation/verifier.h
index 5eeeba1c1b..fc7cc06b71 100644
--- a/include/openspace/documentation/verifier.h
+++ b/include/openspace/documentation/verifier.h
@@ -58,7 +58,7 @@ public:
      * \return A TestResult struct that contains information about whether the key adheres
      *         to the demands of the specific Verifier. If it does not,
      *         TestResult::offenders will either contain \p key or, in the case of a
-     *         TableVerifier, a list of all offending subkeys as fully qualified names.
+     *         TableVerifier, a list of all offending subkeys as fully qualified names
      *
      * \post If the return values' TestResult::success is `true`, its
      *      TestResult::offenders is empty
@@ -98,6 +98,7 @@ public:
  * The base class Verifier for all Verifier%s that have to test against a specific value
  * type. This Verifier tests whether a given key exists and whether it has the same type
  * as the template parameter `T`.
+ *
  * \tparam T The type against which the key's value is tested
  */
 template <typename T>
@@ -112,7 +113,7 @@ public:
      * \param dictionary The ghoul::Dictionary that contains the \p key to be tested
      * \param key The key inside the \p dictinoary that is to be tested
      * \return A TestResult that contains the information whether the \p key exists in the
-     *         \p dictionary and whether the key's value's type agrees with `T`.
+     *         \p dictionary and whether the key's value's type agrees with `T`
      *
      * \post The return values' TestResult::success is either `true` and
      *       TestResult::offenders is empty, or it is `false` and TestResult::offenders
@@ -220,7 +221,7 @@ public:
 
 /**
  * A Verifier that checks whether a given key inside a ghoul::Dictionary is a string and
- * a valid date time
+ * a valid date time.
  */
 class DateTimeVerifier : public StringVerifier {
 public:
@@ -312,21 +313,27 @@ public:
 // Vector verifiers
 //----------------------------------------------------------------------------------------
 
-/// This Verifier checks whether the value is of type `glm::tvec2<T>`
+/**
+ * This Verifier checks whether the value is of type `glm::tvec2<T>`.
+ */
 template <typename T>
 class Vector2Verifier : public TemplateVerifier<glm::tvec2<T>> {
 public:
     std::string type() const override;
 };
 
-/// This Verifier checks whether the value is of type `glm::tvec3<T>`
+/**
+ * This Verifier checks whether the value is of type `glm::tvec3<T>`.
+ */
 template <typename T>
 class Vector3Verifier : public TemplateVerifier<glm::tvec3<T>> {
 public:
     std::string type() const override;
 };
 
-/// This Verifier checks whether the value is of type `glm::tvec4<T>`
+/**
+ * This Verifier checks whether the value is of type `glm::tvec4<T>`.
+ */
 template <typename T>
 class Vector4Verifier : public TemplateVerifier<glm::tvec4<T>> {
 public:
@@ -351,7 +358,7 @@ public:
 
 /**
  * A Verifier that checks whether all values contained in a Table are of
- * type `glm::tvec2<T>`
+ * type `glm::tvec2<T>`.
  */
 template <typename T>
 class Vector2ListVerifier : public TableVerifier {
@@ -369,7 +376,7 @@ public:
 
 /**
  * A Verifier that checks whether all values contained in a Table are of
- * type `glm::tvec3<T>`
+ * type `glm::tvec3<T>`.
  */
 template <typename T>
 class Vector3ListVerifier : public TableVerifier {
@@ -387,7 +394,7 @@ public:
 
 /**
  * A Verifier that checks whether all values contained in a Table are of
- * type `glm::tvec4<T>`
+ * type `glm::tvec4<T>`.
  */
 template <typename T>
 class Vector4ListVerifier : public TableVerifier {
@@ -408,7 +415,7 @@ public:
 //----------------------------------------------------------------------------------------
 
 /**
- * This Verifier checks whether the value is of type `glm::mat2x2<T>`
+ * This Verifier checks whether the value is of type `glm::mat2x2<T>`.
  */
 template <typename T>
 class Matrix2x2Verifier : public TemplateVerifier<glm::tmat2x2<T>> {
@@ -417,7 +424,7 @@ public:
 };
 
 /**
- * This Verifier checks whether the value is of type `glm::mat2x3<T>`
+ * This Verifier checks whether the value is of type `glm::mat2x3<T>`.
  */
 template <typename T>
 class Matrix2x3Verifier : public TemplateVerifier<glm::tmat2x3<T>> {
@@ -426,7 +433,7 @@ public:
 };
 
 /**
- * This Verifier checks whether the value is of type `glm::mat2x4<T>`
+ * This Verifier checks whether the value is of type `glm::mat2x4<T>`.
  */
 template <typename T>
 class Matrix2x4Verifier : public TemplateVerifier<glm::tmat2x4<T>> {
@@ -435,7 +442,7 @@ public:
 };
 
 /**
- * This Verifier checks whether the value is of type `glm::mat3x2<T>`
+ * This Verifier checks whether the value is of type `glm::mat3x2<T>`.
  */
 template <typename T>
 class Matrix3x2Verifier : public TemplateVerifier<glm::tmat3x2<T>> {
@@ -444,7 +451,7 @@ public:
 };
 
 /**
- * This Verifier checks whether the value is of type `glm::mat3x3<T>`
+ * This Verifier checks whether the value is of type `glm::mat3x3<T>`.
  */
 template <typename T>
 class Matrix3x3Verifier : public TemplateVerifier<glm::tmat3x3<T>> {
@@ -453,7 +460,7 @@ public:
 };
 
 /**
- * This Verifier checks whether the value is of type `glm::mat3x4<T>`
+ * This Verifier checks whether the value is of type `glm::mat3x4<T>`.
  */
 template <typename T>
 class Matrix3x4Verifier : public TemplateVerifier<glm::tmat3x4<T>> {
@@ -462,7 +469,7 @@ public:
 };
 
 /**
- * This Verifier checks whether the value is of type `glm::mat4x2<T>`
+ * This Verifier checks whether the value is of type `glm::mat4x2<T>`.
  */
 template <typename T>
 class Matrix4x2Verifier : public TemplateVerifier<glm::tmat4x2<T>> {
@@ -471,7 +478,7 @@ public:
 };
 
 /**
- * This Verifier checks whether the value is of type `glm::mat4x3<T>`
+ * This Verifier checks whether the value is of type `glm::mat4x3<T>`.
  */
 template <typename T>
 class Matrix4x3Verifier : public TemplateVerifier<glm::tmat4x3<T>> {
@@ -480,7 +487,7 @@ public:
 };
 
 /**
- * This Verifier checks whether the value is of type `glm::mat4x4<T>`
+ * This Verifier checks whether the value is of type `glm::mat4x4<T>`.
  */
 template <typename T>
 class Matrix4x4Verifier : public TemplateVerifier<glm::tmat4x4<T>> {
@@ -513,6 +520,7 @@ public:
     /**
      * Constructor for an OperatorVerifier. As all operators need to compare the incoming
      * value to a stored value, we require the comparison \p value to be passed in here.
+     *
      * \param value The value against which the tested value is compared using the
      *        `Operator`
      */
@@ -530,7 +538,7 @@ public:
      *         \p key%'s value has the wrong type, it will be added to the TestResult's
      *         offense list with the reason TestResult::Offense::Reason::WrongType; if the
      *         `Operator` returns false, it will be added with the reason
-     *         TestResult::Offense::Verification instead.
+     *         TestResult::Offense::Verification instead
      */
     TestResult operator()(const ghoul::Dictionary& dictionary,
         const std::string& key) const override;
@@ -683,7 +691,7 @@ public:
      *         \p key%'s value has the wrong type, it will be added to the TestResult's
      *         offense list with the reason TestResult::Offense::Reason::WrongType; if the
      *         value is not in the list, it will be added with the reason
-     *         TestResult::Offense::Verification instead.
+     *         TestResult::Offense::Verification instead
      */
     TestResult operator()(const ghoul::Dictionary& dictionary,
         const std::string& key) const override;
@@ -725,7 +733,7 @@ public:
      *         \p key%'s value has the wrong type, it will be added to the TestResult's
      *         offense list with the reason TestResult::Offense::Reason::WrongType; if the
      *         value is in the list, it will be added with the reason
-     *         TestResult::Offense::Verification instead.
+     *         TestResult::Offense::Verification instead
      */
     TestResult operator()(const ghoul::Dictionary& dictionary,
         const std::string& key) const override;
@@ -777,7 +785,7 @@ public:
      *         offense list with the reason TestResult::Offense::Reason::WrongType; if the
      *         value is outside the range defined by the lower and upper limits passed to
      *         the constructor, it will be added with the reason
-     *         TestResult::Offense::Verification instead.
+     *         TestResult::Offense::Verification instead
      */
     TestResult operator()(const ghoul::Dictionary& dictionary,
         const std::string& key) const override;
@@ -827,7 +835,7 @@ public:
      *         offense list with the reason TestResult::Offense::Reason::WrongType; if the
      *         value is greater or equal to the lower limit and less or equal to the upper
      *         limit, it will be added with the reason TestResult::Offense::Verification
-     *         instead.
+     *         instead
      */
     TestResult operator()(const ghoul::Dictionary& dictionary,
         const std::string& key) const override;
@@ -863,7 +871,7 @@ public:
      * passed to the user when a documentation is requested.
      *
      * \param annotation The annotation that is stored and returned to the user when it
-     *        is requested.
+     *        is requested
      *
      * \pre annotation must not be empty
      */
@@ -961,7 +969,7 @@ public:
      *         TestResult::offenses list contains \p with a reason of
      *         TestResult::Offense::Reason::Verification. If \p key%'s value passes either
      *         of the two Verifier%s, the result's TestResult::success is `true` and the
-     *         TestResult::offenses is empty.
+     *         TestResult::offenses is empty
      */
     TestResult operator()(const ghoul::Dictionary& dictionary,
         const std::string& key) const override;
@@ -972,118 +980,271 @@ public:
     std::vector<std::shared_ptr<Verifier>> values;
 };
 
-/// A short-hand definition for a Verifier checking for `glm::bvec2`
+/**
+ * A short-hand definition for a Verifier checking for `glm::bvec2`.
+ */
 using BoolVector2Verifier = Vector2Verifier<bool>;
-/// A short-hand definition for a Verifier checking for `glm::ivec2`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::ivec2`.
+ */
 using IntVector2Verifier = Vector2Verifier<int>;
-/// A short-hand definition for a Verifier checking for `glm::dvec2`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dvec2`.
+ */
 using DoubleVector2Verifier = Vector2Verifier<double>;
-/// A short-hand definition for a Verifier checking for `glm::bvec3`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::bvec3`.
+ */
 using BoolVector3Verifier = Vector3Verifier<bool>;
-/// A short-hand definition for a Verifier checking for `glm::ivec3`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::ivec3`.
+ */
 using IntVector3Verifier = Vector3Verifier<int>;
-/// A short-hand definition for a Verifier checking for `glm::dvec3`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dvec3`.
+ */
 using DoubleVector3Verifier = Vector3Verifier<double>;
-/// A short-hand definition for a Verifier checking for `glm::bvec4`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::bvec4`.
+ */
 using BoolVector4Verifier = Vector4Verifier<bool>;
-/// A short-hand definition for a Verifier checking for `glm::ivec4`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::ivec4`.
+ */
 using IntVector4Verifier = Vector4Verifier<int>;
-/// A short-hand definition for a Verifier checking for `glm::dvec4`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dvec4`.
+ */
 using DoubleVector4Verifier = Vector4Verifier<double>;
 
-/// A short-hand definition for a Verifier checking for `glm::dmat2x2`
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat2x2`.
+ */
 using DoubleMatrix2x2Verifier = Matrix2x2Verifier<double>;
+
 using DoubleMatrix2Verifier = DoubleMatrix2x2Verifier;
-/// A short-hand definition for a Verifier checking for `glm::dmat2x3`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat2x3`.
+ */
 using DoubleMatrix2x3Verifier = Matrix2x3Verifier<double>;
-/// A short-hand definition for a Verifier checking for `glm::dmat2x4`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat2x4`.
+ */
 using DoubleMatrix2x4Verifier = Matrix2x4Verifier<double>;
-/// A short-hand definition for a Verifier checking for `glm::dmat3x2`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat3x2`.
+ */
 using DoubleMatrix3x2Verifier = Matrix3x2Verifier<double>;
-/// A short-hand definition for a Verifier checking for `glm::dmat3x3`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat3x3`.
+ */
 using DoubleMatrix3x3Verifier = Matrix3x3Verifier<double>;
+
 using DoubleMatrix3Verifier = DoubleMatrix3x3Verifier;
-/// A short-hand definition for a Verifier checking for `glm::dmat3x4`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat3x4`.
+ */
 using DoubleMatrix3x4Verifier = Matrix3x4Verifier<double>;
-/// A short-hand definition for a Verifier checking for `glm::dmat4x2`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat4x2`.
+ */
 using DoubleMatrix4x2Verifier = Matrix4x2Verifier<double>;
-/// A short-hand definition for a Verifier checking for `glm::dmat4x3`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat4x3`.
+ */
 using DoubleMatrix4x3Verifier = Matrix4x3Verifier<double>;
-/// A short-hand definition for a Verifier checking for `glm::dmat4x4`
+
+/**
+ * A short-hand definition for a Verifier checking for `glm::dmat4x4`.
+ */
 using DoubleMatrix4x4Verifier = Matrix4x4Verifier<double>;
+
 using DoubleMatrix4Verifier = DoubleMatrix4x4Verifier;
 
-/// A short-hand definition for a LessVerifier with a type check for `int`
+/**
+ * A short-hand definition for a LessVerifier with a type check for `int`.
+ */
 using IntLessVerifier = LessVerifier<IntVerifier>;
-/// A short-hand definition for a LessVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a LessVerifier with a type check for `double`.
+ */
 using DoubleLessVerifier = LessVerifier<DoubleVerifier>;
-/// A short-hand definition for a LessEqualVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a LessEqualVerifier with a type check for `int`.
+ */
 using IntLessEqualVerifier = LessEqualVerifier<IntVerifier>;
-/// A short-hand definition for a LessEqualVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a LessEqualVerifier with a type check for `double`.
+ */
 using DoubleLessEqualVerifier = LessEqualVerifier<DoubleVerifier>;
-/// A short-hand definition for a GreaterVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a GreaterVerifier with a type check for `int`.
+ */
 using IntGreaterVerifier = GreaterVerifier<IntVerifier>;
-/// A short-hand definition for a GreaterVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a GreaterVerifier with a type check for `double`.
+ */
 using DoubleGreaterVerifier = GreaterVerifier<DoubleVerifier>;
-/// A short-hand definition for a GreaterEqualVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a GreaterEqualVerifier with a type check for `int`.
+ */
 using IntGreaterEqualVerifier = GreaterEqualVerifier<IntVerifier>;
-/// A short-hand definition for a GreaterEqualVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a GreaterEqualVerifier with a type check for `double`.
+ */
 using DoubleGreaterEqualVerifier = GreaterEqualVerifier<DoubleVerifier>;
-/// A short-hand definition for a EqualVerifier with a type check for `bool`
+
+/**
+ * A short-hand definition for a EqualVerifier with a type check for `bool`.
+ */
 using BoolEqualVerifier = EqualVerifier<BoolVerifier>;
-/// A short-hand definition for a EqualVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a EqualVerifier with a type check for `int`.
+ */
 using IntEqualVerifier = EqualVerifier<IntVerifier>;
-/// A short-hand definition for a EqualVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a EqualVerifier with a type check for `double`.
+ */
 using DoubleEqualVerifier = EqualVerifier<DoubleVerifier>;
-/// A short-hand definition for a EqualVerifier with a type check for `string`
+
+/**
+ * A short-hand definition for a EqualVerifier with a type check for `string`.
+ */
 using StringEqualVerifier = EqualVerifier<StringVerifier>;
-/// A short-hand definition for a UnequalVerifier with a type check for `bool`
+
+/**
+ * A short-hand definition for a UnequalVerifier with a type check for `bool`.
+ */
 using BoolUnequalVerifier = UnequalVerifier<BoolVerifier>;
-/// A short-hand definition for a UnequalVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a UnequalVerifier with a type check for `int`.
+ */
 using IntUnequalVerifier = UnequalVerifier<IntVerifier>;
-/// A short-hand definition for a UnequalVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a UnequalVerifier with a type check for `double`.
+ */
 using DoubleUnequalVerifier = UnequalVerifier<DoubleVerifier>;
-/// A short-hand definition for a UnequalVerifier with a type check for `string`
+
+/**
+ * A short-hand definition for a UnequalVerifier with a type check for `string`.
+ */
 using StringUnequalVerifier = UnequalVerifier<StringVerifier>;
 
-/// A short-hand definition for a InListVerifier with a type check for `bool`
+/**
+ * A short-hand definition for a InListVerifier with a type check for `bool`.
+ */
 using BoolInListVerifier = InListVerifier<BoolVerifier>;
-/// A short-hand definition for a InListVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a InListVerifier with a type check for `int`.
+ */
 using IntInListVerifier = InListVerifier<IntVerifier>;
-/// A short-hand definition for a InListVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a InListVerifier with a type check for `double`.
+ */
 using DoubleInListVerifier = InListVerifier<DoubleVerifier>;
-/// A short-hand definition for a InListVerifier with a type check for `string`
+
+/**
+ * A short-hand definition for a InListVerifier with a type check for `string`.
+ */
 using StringInListVerifier = InListVerifier<StringVerifier>;
-/// A short-hand definition for a NotInListVerifier with a type check for `bool`
+
+/**
+ * A short-hand definition for a NotInListVerifier with a type check for `bool`.
+ */
 using BoolNotInListVerifier = NotInListVerifier<BoolVerifier>;
-/// A short-hand definition for a NotInListVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a NotInListVerifier with a type check for `int`.
+ */
 using IntNotInListVerifier = NotInListVerifier<IntVerifier>;
-/// A short-hand definition for a NotInListVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a NotInListVerifier with a type check for `double`.
+ */
 using DoubleNotInListVerifier = NotInListVerifier<DoubleVerifier>;
-/// A short-hand definition for a NotInListVerifier with a type check for `string`
+
+/**
+ * A short-hand definition for a NotInListVerifier with a type check for `string`.
+ */
 using StringNotInListVerifier = NotInListVerifier<StringVerifier>;
 
-/// A short-hand definition for a InRangeVerifier with a type check for `int`
+/**
+ * A short-hand definition for a InRangeVerifier with a type check for `int`.
+ */
 using IntInRangeVerifier = InRangeVerifier<IntVerifier>;
-/// A short-hand definition for a InRangeVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a InRangeVerifier with a type check for `double`.
+ */
 using DoubleInRangeVerifier = InRangeVerifier<DoubleVerifier>;
-/// A short-hand definition for a InRangeVerifier with a type check for `vec2`
+
+/**
+ * A short-hand definition for a InRangeVerifier with a type check for `vec2`.
+ */
 using Vec2InRangeVerifier = InRangeVerifier<DoubleVector2Verifier>;
-/// A short-hand definition for a NotInRangeVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a NotInRangeVerifier with a type check for `int`.
+ */
 using IntNotInRangeVerifier = NotInRangeVerifier<IntVerifier>;
-/// A short-hand definition for a NotInRangeVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a NotInRangeVerifier with a type check for `double`.
+ */
 using DoubleNotInRangeVerifier = NotInRangeVerifier<DoubleVerifier>;
 
-/// A short-hand definition for a AnnotationVerifier with a type check for `bool`
+/**
+ * A short-hand definition for a AnnotationVerifier with a type check for `bool`.
+ */
 using BoolAnnotationVerifier = AnnotationVerifier<BoolVerifier>;
-/// A short-hand definition for a AnnotationVerifier with a type check for `int`
+
+/**
+ * A short-hand definition for a AnnotationVerifier with a type check for `int`.
+ */
 using IntAnnotationVerifier = AnnotationVerifier<IntVerifier>;
-/// A short-hand definition for a AnnotationVerifier with a type check for `double`
+
+/**
+ * A short-hand definition for a AnnotationVerifier with a type check for `double`.
+ */
 using DoubleAnnotationVerifier = AnnotationVerifier<DoubleVerifier>;
-/// A short-hand definition for a AnnotationVerifier with a type check for `string`
+
+/**
+ * A short-hand definition for a AnnotationVerifier with a type check for `string`.
+ */
 using StringAnnotationVerifier = AnnotationVerifier<StringVerifier>;
-/// A short-hand definition for a AnnotationVerifier with a type check for
-/// `ghoul::Dictionary`
+
+/**
+ * A short-hand definition for a AnnotationVerifier with a type check for
+ * `ghoul::Dictionary`
+ */
 using TableAnnotationVerifier = AnnotationVerifier<TableVerifier>;
 
 // Definitions of external templates that are instantiated in the cpp file
diff --git a/include/openspace/engine/globalscallbacks.h b/include/openspace/engine/globalscallbacks.h
index a0f606b65c..4dba55e44e 100644
--- a/include/openspace/engine/globalscallbacks.h
+++ b/include/openspace/engine/globalscallbacks.h
@@ -66,11 +66,10 @@ inline std::vector<std::function<void(TouchInput)>>* touchExit;
 /**
  * If the framerate becomes slow, Chromium Embedded Framework (used in Web Browser Module)
  * needs to perform its message loop work more frequently than once per frame. If this
- * method is not called frequently enough, the GUI will become much less responsive.
- * A future more long-term may decouple the browser's message work loop from the main
- * render loop altogehter using a separate thread.
- * Currently, this method is called from within the RenderEngine,
- * between calls to individual renderables.
+ * method is not called frequently enough, the GUI will become much less responsive. A
+ * future more long-term may decouple the browser's message work loop from the main render
+ * loop altogehter using a separate thread. Currently, this method is called from within
+ * the RenderEngine, between calls to individual renderables.
  */
 extern void (*webBrowserPerformanceHotfix)();
 
diff --git a/include/openspace/engine/logfactory.h b/include/openspace/engine/logfactory.h
index 3216e44e32..e4cce1ba43 100644
--- a/include/openspace/engine/logfactory.h
+++ b/include/openspace/engine/logfactory.h
@@ -43,12 +43,14 @@ namespace documentation { struct Documentation; }
  * logfile should be created. Both logs can be customized using the `Append`,
  * `TimeStamping`, `DateStamping`, `CategoryStamping`, and `LogLevelStamping` values.
  *
- * \param  dictionary The dictionary from which the ghoul::logging::Log should be created
+ * \param dictionary The dictionary from which the ghoul::logging::Log should be created
  * \return The created ghoul::logging::Log
- * \post   The return value will not be `nullptr`
- * \throw  ghoul::RuntimeError If there was an error creating the ghoul::logging::Log
- * \sa     ghoul::logging::TextLog
- * \sa     ghoul::logging::HTMLLog
+ *
+ * \post The return value will not be `nullptr`
+ * \throw ghoul::RuntimeError If there was an error creating the ghoul::logging::Log
+ *
+ * \sa ghoul::logging::TextLog
+ * \sa ghoul::logging::HTMLLog
  */
 std::unique_ptr<ghoul::logging::Log> createLog(const ghoul::Dictionary& dictionary);
 
diff --git a/include/openspace/engine/moduleengine.h b/include/openspace/engine/moduleengine.h
index 8a37586007..4bfe52c166 100644
--- a/include/openspace/engine/moduleengine.h
+++ b/include/openspace/engine/moduleengine.h
@@ -45,9 +45,9 @@ namespace scripting { struct LuaLibrary; }
  * The ModuleEngine is the central repository for registering and accessing
  * OpenSpaceModule for the current application run. By initializing (#initialize) the
  * ModuleEngine, the default set of OpenSpaceModule%s as generated by CMake in the
- * `moduleregistration.h` file is automatically registered and created.
- * Additional OpenSpaceModule%s can be registered with the #registerModule function, which
- * will internally call the OpenSpaceModule::initialize method.
+ * `moduleregistration.h` file is automatically registered and created. Additional
+ * OpenSpaceModule%s can be registered with the #registerModule function, which will
+ * internally call the OpenSpaceModule::initialize method.
  */
 class ModuleEngine : public properties::PropertyOwner {
 public:
@@ -55,11 +55,10 @@ public:
 
     /**
      * Registers all of the OpenSpaceModule%s which are created by the CMake configuration
-     * and stored in the `moduleregistration.h` file. For all of those modules
-     * the OpenSpaceModule::initialize method with will called.
+     * and stored in the `moduleregistration.h` file. For all of those modules the
+     * OpenSpaceModule::initialize method with will called.
      *
-     * \throw ghoul::RuntimeError If two modules in the default modules have the same
-     *        name
+     * \throw ghoul::RuntimeError If two modules in the default modules have the same name
     */
     void initialize(const std::map<std::string, ghoul::Dictionary>& moduleConfigurations);
 
@@ -104,7 +103,7 @@ public:
      * to have the public static member variable `name` which must be equal to
      * the name of the module used in its constructor.
      *
-     * \return a pointer to the module of the given subclass
+     * \return A pointer to the module of the given subclass
      */
     template <class ModuleSubClass>
     ModuleSubClass* module() const;
@@ -118,9 +117,9 @@ public:
     ghoul::systemcapabilities::Version requiredOpenGLVersion() const;
 
     /**
-    * Returns the Lua library that contains all Lua functions available to affect the
-    * modules.
-    */
+     * Returns the Lua library that contains all Lua functions available to affect the
+     * modules.
+     */
     static scripting::LuaLibrary luaLibrary();
 
 private:
diff --git a/include/openspace/engine/openspaceengine.h b/include/openspace/engine/openspaceengine.h
index 73a97a54e8..291a65aefa 100644
--- a/include/openspace/engine/openspaceengine.h
+++ b/include/openspace/engine/openspaceengine.h
@@ -51,15 +51,17 @@ class Scene;
 
 namespace scripting { struct LuaLibrary; }
 
-  // Structure that is responsible for the delayed shutdown of the application
+/**
+ * Structure that is responsible for the delayed shutdown of the application.
+ */
 struct ShutdownInformation {
-    // Whether the application is currently in shutdown mode (i.e. counting down the
-    // timer and closing it at '0'
+    /// Whether the application is currently in shutdown mode (i.e. counting down the
+    /// timer and closing it at '0'
     bool inShutdown = false;
-    // Total amount of time the application will wait before actually shutting down
+    /// Total amount of time the application will wait before actually shutting down
     float waitTime = 0.f;
-    // Current state of the countdown; if it reaches '0', the application will
-    // close
+    /// Current state of the countdown; if it reaches '0', the application will
+    /// close
     float timer = 0.f;
 };
 
@@ -73,9 +75,11 @@ struct CommandlineArguments {
 
 class OpenSpaceEngine : public properties::PropertyOwner {
 public:
-    // A mode that specifies which part of the system is currently in control.
-    // The mode can be used to limit certain features, like setting time, navigation
-    // or triggering scripts
+    /**
+     * A mode that specifies which part of the system is currently in control. The mode
+     * can be used to limit certain features, like setting time, navigation or triggering
+     * scripts.
+     */
     enum class Mode {
         UserControl = 0,
         SessionRecordingPlayback,
@@ -180,7 +184,8 @@ private:
  * Sets the camera position using the time contents of a profile. The function will
  * set an absolute position or a go-to-geolocation command using the globebrowsing
  * module.
- * \param p The Profile to be read.
+ *
+ * \param p The Profile to be read
  */
 void setCameraFromProfile(const Profile& p);
 
@@ -188,21 +193,21 @@ void setCameraFromProfile(const Profile& p);
  * Reads a list of modules from a profile, and executes scripts based on whether or
  * not the corresponding module is loaded.
  *
- * \param p The Profile to be read.
+ * \param p The Profile to be read
  */
 void setModulesFromProfile(const Profile& p);
 
 /**
  * Registers actions from the contents of a profile.
  *
- * \param p The Profile to be read.
+ * \param p The Profile to be read
  */
 void setActionsFromProfile(const Profile& p);
 
 /**
  * Registers keybindings from the contents of a profile.
  *
- * \param p The Profile to be read.
+ * \param p The Profile to be read
  */
 void setKeybindingsFromProfile(const Profile& p);
 
@@ -211,7 +216,7 @@ void setKeybindingsFromProfile(const Profile& p);
  * If any nodes are listed, a script to mark these will be queued with the
  * script engine.
  *
- * \param p The Profile to be read.
+ * \param p The Profile to be read
  */
 void setMarkInterestingNodesFromProfile(const Profile& p);
 
@@ -220,7 +225,7 @@ void setMarkInterestingNodesFromProfile(const Profile& p);
  * at the end of the initialization. Any openspace lua commands are allowed,
  * and will be added to the script queue.
  *
- * \param p The Profile to be read.
+ * \param p The Profile to be read
  */
 void setAdditionalScriptsFromProfile(const Profile& p);
 
diff --git a/include/openspace/engine/syncengine.h b/include/openspace/engine/syncengine.h
index 1b5107d4ba..fb6d9933f2 100644
--- a/include/openspace/engine/syncengine.h
+++ b/include/openspace/engine/syncengine.h
@@ -36,72 +36,71 @@ namespace openspace {
 class Syncable;
 
 /**
- * Manages a collection of `Syncable`s and ensures they are synchronized
- * over SGCT nodes. Encoding/Decoding order is handles internally.
+ * Manages a collection of `Syncable`s and ensures they are synchronized over SGCT nodes.
+ * Encoding/Decoding order is handles internally.
  */
 class SyncEngine {
 public:
     BooleanType(IsMaster);
 
     /**
-     * Creates a new SyncEngine which a buffer size of \p syncBufferSize
+     * Creates a new SyncEngine which a buffer size of \p syncBufferSize.
+     *
      * \pre syncBufferSize must be bigger than 0
      */
     SyncEngine(unsigned int syncBufferSize);
 
     /**
-     * Encodes all added Syncables in the injected `SyncBuffer`.
-     * This method is only called on the SGCT master node
+     * Encodes all added Syncables in the injected `SyncBuffer`. This method is only
+     * called on the SGCT master node.
      */
     std::vector<std::byte> encodeSyncables();
 
     /**
-     * Decodes the `SyncBuffer` into the added Syncables.
-     * This method is only called on the SGCT client nodes
+     * Decodes the `SyncBuffer` into the added Syncables. This method is only called on
+     * the SGCT client nodes.
      */
     void decodeSyncables(std::vector<std::byte> data);
 
     /**
-     * Invokes the presync method of all added Syncables
+     * Invokes the presync method of all added Syncables.
      */
     void preSynchronization(IsMaster isMaster);
 
     /**
-     * Invokes the postsync method of all added Syncables
+     * Invokes the postsync method of all added Syncables.
      */
     void postSynchronization(IsMaster isMaster);
 
     /**
      * Add a Syncable to be synchronized over the SGCT cluster.
-     * \pre syncable must not be nullptr
+     *
+     * \pre syncable must not be `nullptr`
      */
     void addSyncable(Syncable* syncable);
 
     /**
-     * Add multiple Syncables to be synchronized over the SGCT cluster
+     * Add multiple Syncables to be synchronized over the SGCT cluster.
+     *
      * \pre syncables must not contain any nullptr
      */
     void addSyncables(const std::vector<Syncable*>& syncables);
 
     /**
-     * Remove a Syncable from being synchronized over the SGCT cluster
+     * Remove a Syncable from being synchronized over the SGCT cluster.
      */
     void removeSyncable(Syncable* syncable);
 
     /**
-    * Remove multiple Syncables from being synchronized over the SGCT cluster
+    * Remove multiple Syncables from being synchronized over the SGCT cluster.
     */
     void removeSyncables(const std::vector<Syncable*>& syncables);
 
 private:
-    /**
-     * Vector of Syncables. The vectors ensures consistent encode/decode order
-     */
+    /// Vector of Syncables. The vectors ensures consistent encode/decode order.
     std::vector<Syncable*> _syncables;
 
-    /**
-     * Databuffer used in encoding/decoding
-     */
+    /// Databuffer used in encoding/decoding
     SyncBuffer _syncBuffer;
 };
 
diff --git a/include/openspace/events/event.h b/include/openspace/events/event.h
index 08f15512d9..9f2f344bae 100644
--- a/include/openspace/events/event.h
+++ b/include/openspace/events/event.h
@@ -111,7 +111,7 @@ void logAllEvents(const Event* e);
 //
 
 /**
- * This event is created whenever a new scene graph node is added to the system.  By the
+ * This event is created whenever a new scene graph node is added to the system. By the
  * time this event is signalled, the scene graph node has already been created and added
  * to the scene.
  */
@@ -130,7 +130,7 @@ struct EventSceneGraphNodeAdded : public Event {
 };
 
 /**
- * This event is created whenever a scene graph node was removed.  By the time this event
+ * This event is created whenever a scene graph node was removed. By the time this event
  * is signalled, the scene graph node has already been removed.
  */
 struct EventSceneGraphNodeRemoved : public Event {
@@ -164,7 +164,7 @@ struct EventParallelConnection : public Event {
     /**
      * Creates an instance of an EventParallelConnection event.
      *
-     * \param state_ The new state of the parallel connection system;  is one of
+     * \param state_ The new state of the parallel connection system; is one of
      *        `Established`, `Lost`, `HostshipGained`, or `HostshipLost`
      */
     explicit EventParallelConnection(State state_);
@@ -201,8 +201,8 @@ struct EventApplicationShutdown : public Event {
     /**
      * Creates an instance of an EventApplicationShutdown event.
      *
-     * \param state_ The next state of the application shutdown sequence;  is one of
-     *        `Started`, `Aborted`,  or `Finished`
+     * \param state_ The next state of the application shutdown sequence; is one of
+     *        `Started`, `Aborted`, or `Finished`
      */
     explicit EventApplicationShutdown(State state_);
     const State state;
@@ -210,7 +210,7 @@ struct EventApplicationShutdown : public Event {
 
 /**
  * This event is created when a new screenspace renderable has been created.  By the time
- * this event is craeted, the screenspace renderable is already registered and available.
+ * this event is created, the screenspace renderable is already registered and available.
  */
 struct EventScreenSpaceRenderableAdded : public Event {
     static constexpr Type Type = Event::Type::ScreenSpaceRenderableAdded;
@@ -229,7 +229,7 @@ struct EventScreenSpaceRenderableAdded : public Event {
 /**
  * This event is created when a screenspace renderable has been removed from the system.
  * When this event is created, the screenspace renderable has already been removed and is
- * no longer available
+ * no longer available.
  */
 struct EventScreenSpaceRenderableRemoved : public Event {
     static constexpr Type Type = Event::Type::ScreenSpaceRenderableRemoved;
@@ -248,18 +248,18 @@ struct EventScreenSpaceRenderableRemoved : public Event {
  * distances. Right now, only movement relative to camera's focus node is considered.
  * Each scene graph node has an interaction sphere radius that serves as the reference
  * distance for all spheres.
-```
-Diagram of events for a camera moving from right-to-left. Interaction sphere is 'O' in
-middle, and ')' are spherical boundaries. The approach factor, reach factor, and
-interaction sphere radius are all taken from the current focus node.
-
-|<------------------->|  Approach factor * Interaction sphere
-             |<------>|  Reach Factor * Interaction sphere
-
-(                       (           O          )                       )
-^                       ^                      ^                       ^
-Exiting                 Receding               Reaching                Approaching
-```
+ * ```
+ * Diagram of events for a camera moving from right-to-left. Interaction sphere is 'O' in
+ * middle, and ')' are spherical boundaries. The approach factor, reach factor, and
+ * interaction sphere radius are all taken from the current focus node.
+ *
+ * |<------------------->|  Approach factor * Interaction sphere
+ *              |<------>|  Reach Factor * Interaction sphere
+ *
+ * (                       (           O          )                       )
+ * ^                       ^                      ^                       ^
+ * Exiting                 Receding               Reaching                Approaching
+ * ```
  */
 struct EventCameraFocusTransition : public Event {
     static constexpr Type Type = Event::Type::CameraFocusTransition;
@@ -347,7 +347,7 @@ struct EventPlanetEclipsed : public Event {
 
 /**
  * This event is created when the interpolation of a property value is finished. If the
- * interpolation time of a property change is 0s, this event is not fired
+ * interpolation time of a property change is 0s, this event is not fired.
  */
 struct EventInterpolationFinished : public Event {
     static constexpr Type Type = Event::Type::InterpolationFinished;
@@ -562,7 +562,7 @@ struct EventCameraPathFinished : public Event {
 };
 
 /**
- * This event is created when the a camera moves location
+ * This event is created when the a camera moves location.
  */
 struct EventCameraMovedPosition : public Event {
     static constexpr Type Type = Event::Type::CameraMovedPosition;
diff --git a/include/openspace/events/eventengine.h b/include/openspace/events/eventengine.h
index 212a0305af..b0a84b79c3 100644
--- a/include/openspace/events/eventengine.h
+++ b/include/openspace/events/eventengine.h
@@ -48,7 +48,7 @@ public:
      * This function returns the first event stored in the EventEngine, or `nullptr` if
      * no event exists. To navigate the full list of events, you can access the returned
      * Event's next function. If the end of the list is reached, the next pointer will be
-     * a nullptr
+     * a `nullptr`.
      *
      * \return The first event stored in the EventEngine or nullptr if no event exists
      */
@@ -57,11 +57,11 @@ public:
     /**
      * Publish a new event of type T by providing optional arguments Args to the Event's
      * constructor. An example of usage is
-     * `engine.publishEvent<MyEvent>("a", 2.0);` which would call the
-     * constructor of `MyEvent` with a `const char*` and `double` parameter.
+     * `engine.publishEvent<MyEvent>("a", 2.0);` which would call the constructor of
+     * `MyEvent` with a `const char*` and `double` parameter.
      *
-     * \param args The arguments that are passed to the constructor of T
      * \tparam T The subclass of Event that is to be published
+     * \param args The arguments that are passed to the constructor of T
      */
     template <typename T, typename... Args>
     void publishEvent(Args&&... args);
@@ -101,7 +101,7 @@ public:
     /**
      * Removing registration for a specific event identified by the \p identifier.
      *
-     * \param identifier The unique identifier of the event that should be removed.
+     * \param identifier The unique identifier of the event that should be removed
      */
     void unregisterEventAction(uint32_t identifier);
 
@@ -130,7 +130,7 @@ public:
 
     /**
      * Triggers all actions that are registered for events that are in the current event
-     * queue
+     * queue.
      */
     void triggerActions() const;
 
@@ -144,10 +144,9 @@ private:
     /// The last event in the chain of events stored in the memory pool
     events::Event* _lastEvent = nullptr;
 
-
-    // The type is duplicated in the ActionInfo as well, but we want it in the ActionInfo
-    // to be able to return them to a caller and we want it in this unordered_map to make
-    // the lookup really fast. So having this extra wasted memory is probably worth it
+    /// The type is duplicated in the ActionInfo as well, but we want it in the ActionInfo
+    /// to be able to return them to a caller and we want it in this unordered_map to make
+    /// the lookup really fast. So having this extra wasted memory is probably worth it
     std::unordered_map<events::Event::Type, std::vector<ActionInfo>> _eventActions;
 
     static uint32_t nextRegisteredEventId;
diff --git a/include/openspace/interaction/camerainteractionstates.h b/include/openspace/interaction/camerainteractionstates.h
index b220db6115..5e31c37c5f 100644
--- a/include/openspace/interaction/camerainteractionstates.h
+++ b/include/openspace/interaction/camerainteractionstates.h
@@ -33,9 +33,9 @@ namespace openspace::interaction {
 class CameraInteractionStates {
 public:
     /**
-     * \param sensitivity
-     * \param velocityScaleFactor can be set to 60 to remove the inertia of the
-     * interaction. Lower value will make it harder to move the camera.
+     * \param sensitivity Interaction sensitivity
+     * \param velocityScaleFactor Can be set to 60 to remove the inertia of the
+     *        interaction. Lower value will make it harder to move the camera
      */
     CameraInteractionStates(double sensitivity, double velocityScaleFactor);
     virtual ~CameraInteractionStates() = default;
@@ -54,9 +54,9 @@ public:
 
     void resetVelocities();
 
-    /*
-     * Returns true if any of the velocities are larger than zero,
-     * i.e. wether an interaction happened
+    /**
+     * Returns true if any of the velocities are larger than zero, i.e. wether an
+     * interaction happened.
      */
     bool hasNonZeroVelocities(bool checkOnlyMovement = false);
 
diff --git a/include/openspace/interaction/delayedvariable.h b/include/openspace/interaction/delayedvariable.h
index 7f71c8f13b..67046c7bdf 100644
--- a/include/openspace/interaction/delayedvariable.h
+++ b/include/openspace/interaction/delayedvariable.h
@@ -28,9 +28,9 @@
 namespace openspace::interaction {
 
 /**
- * Class that acts as a smoothing filter to a variable. The filter has a step
- * response on a form that resembles the function y = 1-e^(-t/scale). The variable
- * will be updated as soon as it is set to a value (calling the set() function).
+ * Class that acts as a smoothing filter to a variable. The filter has a step response on
+ * a form that resembles the function y = 1-e^(-t/scale). The variable will be updated as
+ * soon as it is set to a value (calling the set() function).
  */
 template <typename T, typename ScaleType>
 class DelayedVariable {
diff --git a/include/openspace/interaction/interactionmonitor.h b/include/openspace/interaction/interactionmonitor.h
index 9cd80e210d..6cc2907a0e 100644
--- a/include/openspace/interaction/interactionmonitor.h
+++ b/include/openspace/interaction/interactionmonitor.h
@@ -52,7 +52,7 @@ public:
 
     /*
      * Called from all places we want to mark activity from. Updates the last registered
-     * interaction time
+     * interaction time.
      */
     void markInteraction();
 
diff --git a/include/openspace/interaction/interpolator.h b/include/openspace/interaction/interpolator.h
index 867b63ab66..d017bd8618 100644
--- a/include/openspace/interaction/interpolator.h
+++ b/include/openspace/interaction/interpolator.h
@@ -29,7 +29,7 @@
 
 namespace openspace::interaction {
 
-/*
+/**
  * Interpolates a typename T using a transfer function.
  */
 template <typename T>
diff --git a/include/openspace/interaction/joystickinputstate.h b/include/openspace/interaction/joystickinputstate.h
index 76f68ff437..6c9cd42fa0 100644
--- a/include/openspace/interaction/joystickinputstate.h
+++ b/include/openspace/interaction/joystickinputstate.h
@@ -37,7 +37,7 @@ namespace openspace::interaction {
 
 /**
  * Actions that any button of a joystick can have. Each button must be in one of these
- * states
+ * states.
  */
 enum class JoystickAction : uint8_t {
     /// Idle state if the button is unpressed and has been unpressed since last frame
@@ -81,7 +81,7 @@ struct JoystickInputStates : public std::array<JoystickInputState, MaxJoysticks>
     static constexpr int MaxNumJoysticks = 16;
 
     /**
-     * This function return the number of axes the joystick with the given name has
+     * This function return the number of axes the joystick with the given name has.
      *
      * \param joystickName The name of the joystick to check how many axes it has,
      *        if empty the max number of axes for all joysticks are returned
@@ -90,7 +90,7 @@ struct JoystickInputStates : public std::array<JoystickInputState, MaxJoysticks>
     int numAxes(const std::string& joystickName = "") const;
 
     /**
-     * This function return the number of buttons the joystick with the given name has
+     * This function return the number of buttons the joystick with the given name has.
      *
      * \param joystickName The name of the joystick to check how many buttons it has,
      *        if empty the max number of buttons for all joysticks are returned
diff --git a/include/openspace/interaction/sessionrecording.h b/include/openspace/interaction/sessionrecording.h
index 0741e4e6f6..284ea1e459 100644
--- a/include/openspace/interaction/sessionrecording.h
+++ b/include/openspace/interaction/sessionrecording.h
@@ -72,9 +72,9 @@ public:
         double timeSim;
     };
 
-    /*
-     * Struct for storing a script substring that, if found in a saved script,
-     * will be replaced by its substringReplacement counterpart.
+    /**
+     * Struct for storing a script substring that, if found in a saved script, will be
+     * replaced by its substringReplacement counterpart.
      */
     struct ScriptSubstringReplace {
         std::string substringFound;
@@ -110,9 +110,9 @@ public:
     void deinitialize();
 
     /**
-     * This is called with every rendered frame. If in recording state, the camera
-     * state will be saved to the recording file (if its state has changed since last).
-     * If in playback state, the next keyframe will be used (if it is time to do so).
+     * This is called with every rendered frame. If in recording state, the camera state
+     * will be saved to the recording file (if its state has changed since last). If in
+     * playback state, the next keyframe will be used (if it is time to do so).
      */
     void preSynchronization();
 
@@ -123,12 +123,12 @@ public:
     void render();
 
     /**
-     * Current time based on playback mode
+     * Current time based on playback mode.
      */
     double currentTime() const;
 
     /**
-     * Fixed delta time set by user for use during saving of frame during playback mode
+     * Fixed delta time set by user for use during saving of frame during playback mode.
      */
     double fixedDeltaTimeDuringFrameOutput() const;
 
@@ -140,9 +140,8 @@ public:
      * However, during playback it is incremented by the fixed framerate of the playback
      * rather than the actual clock value (as in normal operation).
      *
-     * \returns number of microseconds elapsed since playback started in terms of the
-     *          number of rendered frames multiplied by the fixed time increment per
-     *          frame
+     * \return Number of microseconds elapsed since playback started in terms of the
+     *         number of rendered frames multiplied by the fixed time increment per frame
      */
     std::chrono::steady_clock::time_point currentPlaybackInterpolationTime() const;
 
@@ -151,28 +150,27 @@ public:
      * used when playback is set to be in the mode where a screenshot is captured with
      * every rendered frame (enableTakeScreenShotDuringPlayback() is used to enable this
      * mode). At the start of playback, this timer is set to the value of the current
-     * applicationTime function provided by the window delegate (used during normal
-     * mode or playback). However, during playback it is incremented by the fixed
-     * framerate of the playback rather than the actual clock value.
+     * applicationTime function provided by the window delegate (used during normal mode
+     * or playback). However, during playback it is incremented by the fixed framerate of
+     * the playback rather than the actual clock value.
      *
-     * \returns application time in seconds, for use in playback-with-frames mode
+     * \return Application time in seconds, for use in playback-with-frames mode
      */
     double currentApplicationInterpolationTime() const;
 
     /**
-     * Starts a recording session, which will save data to the provided filename
-     * according to the data format specified, and will continue until recording is
-     * stopped using stopRecording() method.
+     * Starts a recording session, which will save data to the provided filename according
+     * to the data format specified, and will continue until recording is stopped using
+     * stopRecording() method.
      *
-     * \param filename file saved with recorded keyframes.
-     *
-     * \returns true if recording to file starts without errors.
+     * \param filename File saved with recorded keyframes
+     * \return `true` if recording to file starts without errors
      */
     bool startRecording(const std::string& filename);
 
     /**
-     * Starts a recording session, which will save data to the provided filename
-     * in ASCII data format until recording is stopped using stopRecording() method.
+     * Starts a recording session, which will save data to the provided filename in ASCII
+     * data format until recording is stopped using stopRecording() method.
      *
      * \param dataMode The format in which the session recording is stored
      */
@@ -187,23 +185,23 @@ public:
     /**
      * Used to check if a session recording is in progress.
      *
-     * \return true if recording is in progress
+     * \return `true` if recording is in progress
      */
     bool isRecording() const;
 
     /**
      * Starts a playback session, which can run in one of three different time modes.
      *
-     * \param filename file containing recorded keyframes to play back. The file path
-     *                 is relative to the base recordings directory specified in the
-     *                 config file by the RECORDINGS variable
-     * \param timeMode which of the 3 time modes to use for time reference during
-     * \param forceSimTimeAtStart if true simulation time is forced to that of playback
+     * \param filename File containing recorded keyframes to play back. The file path is
+     *                 relative to the base recordings directory specified in the config
+     *                 file by the RECORDINGS variable
+     * \param timeMode Which of the 3 time modes to use for time reference during
+     * \param forceSimTimeAtStart If true simulation time is forced to that of playback
      *        playback: recorded time, application time, or simulation time. See the
      *        LuaLibrary entry for SessionRecording for details on these time modes
-     * \param loop if true then the file will playback in loop mode, continuously
-     *             looping back to the beginning until it is manually stopped
-     * \param shouldWaitForFinishedTiles if true, the playback will wait for tiles to be
+     * \param loop If true then the file will playback in loop mode, continuously looping
+     *        back to the beginning until it is manually stopped
+     * \param shouldWaitForFinishedTiles If true, the playback will wait for tiles to be
      *        finished before progressing to the next frame. This value is only used when
      *        `enableTakeScreenShotDuringPlayback` was called before. Otherwise this value
      *        will be ignored
@@ -214,8 +212,8 @@ public:
         bool forceSimTimeAtStart, bool loop, bool shouldWaitForFinishedTiles);
 
     /**
-     * Used to stop a playback in progress. If open, the playback file will be closed,
-     * and all keyframes deleted from memory.
+     * Used to stop a playback in progress. If open, the playback file will be closed, and
+     * all keyframes deleted from memory.
      */
     void stopPlayback();
 
@@ -227,33 +225,34 @@ public:
     bool isPlaybackPaused();
 
     /**
-     * Pauses a playback session. This does both the normal pause functionality of
-     * setting simulation delta time to zero, and pausing the progression through the
-     * timeline.
+     * Pauses a playback session. This does both the normal pause functionality of setting
+     * simulation delta time to zero, and pausing the progression through the timeline.
      *
-     * \param pause if true, then will set playback timeline progression to zero
+     * \param pause If `true`, then will set playback timeline progression to zero
      */
     void setPlaybackPause(bool pause);
 
     /**
-     * Enables that rendered frames should be saved during playback
+     * Enables that rendered frames should be saved during playback.
+     *
      * \param fps Number of frames per second.
      */
     void enableTakeScreenShotDuringPlayback(int fps);
 
     /**
-     * Used to disable that renderings are saved during playback
+     * Used to disable that renderings are saved during playback.
      */
     void disableTakeScreenShotDuringPlayback();
 
     /**
      * Used to check if a session playback is in progress.
-     * \returns true if playback is in progress.
+     *
+     * \return `true` if playback is in progress
      */
     bool isPlayingBack() const;
 
     /**
-     * Is saving frames during playback
+     * Is saving frames during playback.
      */
     bool isSavingFramesDuringPlayback() const;
 
@@ -289,15 +288,14 @@ public:
 
     /**
      * \return The Lua library that contains all Lua functions available to affect the
-     * interaction
+     *         interaction
      */
     static openspace::scripting::LuaLibrary luaLibrary();
 
     /**
      * Used to request a callback for notification of playback state change.
      *
-     * \param cb function handle for callback
-     *
+     * \param cb Function handle for callback
      * \return CallbackHandle value of callback number
      */
     CallbackHandle addStateChangeCallback(StateChangeCallback cb);
@@ -305,14 +303,14 @@ public:
     /**
      * Removes the callback for notification of playback state change.
      *
-     * \param callback function handle for the callback
+     * \param callback Function handle for the callback
      */
     void removeStateChangeCallback(CallbackHandle callback);
 
     /**
      * Provides list of available playback files.
      *
-     * \return vector of filenames in recordings dir
+     * \return Vector of filenames in recordings dir
      */
     std::vector<std::string> playbackList() const;
 
@@ -320,12 +318,11 @@ public:
      * Reads a camera keyframe from a binary format playback file, and populates input
      * references with the parameters of the keyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a camera keyframe which contains camera details
-     * \param file an ifstream reference to the playback file being read
-     * \param lineN keyframe number in playback file where this keyframe resides
-     *
-     * \return true if data read has no errors
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a camera keyframe which contains camera details
+     * \param file An ifstream reference to the playback file being read
+     * \param lineN Keyframe number in playback file where this keyframe resides
+     * \return `true` if data read has no errors
      */
     bool readCameraKeyframeBinary(Timestamps& times,
         datamessagestructures::CameraKeyframe& kf, std::ifstream& file, int lineN);
@@ -334,12 +331,11 @@ public:
      * Reads a camera keyframe from an ascii format playback file, and populates input
      * references with the parameters of the keyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a camera keyframe which contains camera details
-     * \param currentParsingLine string containing the most current line that was read
-     * \param lineN line number in playback file where this keyframe resides
-     *
-     * \return true if data read has no errors
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a camera keyframe which contains camera details
+     * \param currentParsingLine String containing the most current line that was read
+     * \param lineN Line number in playback file where this keyframe resides
+     * \return `true` if data read has no errors
      */
     bool readCameraKeyframeAscii(Timestamps& times,
         datamessagestructures::CameraKeyframe& kf, std::string currentParsingLine,
@@ -349,12 +345,11 @@ public:
      * Reads a time keyframe from a binary format playback file, and populates input
      * references with the parameters of the keyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a time keyframe which contains time details
-     * \param file an ifstream reference to the playback file being read
-     * \param lineN keyframe number in playback file where this keyframe resides
-     *
-     * \return true if data read has no errors
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a time keyframe which contains time details
+     * \param file An ifstream reference to the playback file being read
+     * \param lineN Keyframe number in playback file where this keyframe resides
+     * \return `true` if data read has no errors
      */
     bool readTimeKeyframeBinary(Timestamps& times,
         datamessagestructures::TimeKeyframe& kf, std::ifstream& file, int lineN);
@@ -363,12 +358,11 @@ public:
      * Reads a time keyframe from an ascii format playback file, and populates input
      * references with the parameters of the keyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a time keyframe which contains time details
-     * \param currentParsingLine string containing the most current line that was read
-     * \param lineN line number in playback file where this keyframe resides
-     *
-     * \return true if data read has no errors
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a time keyframe which contains time details
+     * \param currentParsingLine String containing the most current line that was read
+     * \param lineN Line number in playback file where this keyframe resides
+     * \return `true` if data read has no errors
      */
     bool readTimeKeyframeAscii(Timestamps& times,
         datamessagestructures::TimeKeyframe& kf, std::string currentParsingLine,
@@ -378,13 +372,12 @@ public:
      * Reads a script keyframe from a binary format playback file, and populates input
      * references with the parameters of the keyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a script keyframe which contains the size of the script
-     *        (in chars) and the text itself
-     * \param file an ifstream reference to the playback file being read
-     * \param lineN keyframe number in playback file where this keyframe resides
-     *
-     * \return true if data read has no errors
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a script keyframe which contains the size of the script (in
+     *        chars) and the text itself
+     * \param file An ifstream reference to the playback file being read
+     * \param lineN Keyframe number in playback file where this keyframe resides
+     * \return `true` if data read has no errors
      */
     bool readScriptKeyframeBinary(Timestamps& times,
         datamessagestructures::ScriptMessage& kf, std::ifstream& file, int lineN);
@@ -393,36 +386,35 @@ public:
      * Reads a script keyframe from an ascii format playback file, and populates input
      * references with the parameters of the keyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a script keyframe which contains the size of the script
-     *        (in chars) and the text itself
-     * \param currentParsingLine string containing the most current line that was read
-     * \param lineN line number in playback file where this keyframe resides
-     *
-     * \return true if data read has no errors
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a script keyframe which contains the size of the script (in
+     *        chars) and the text itself
+     * \param currentParsingLine String containing the most current line that was read
+     * \param lineN Line number in playback file where this keyframe resides
+     * \return `true` if data read has no errors
      */
     bool readScriptKeyframeAscii(Timestamps& times,
         datamessagestructures::ScriptMessage& kf, std::string currentParsingLine,
         int lineN);
 
     /**
-     * Writes a camera keyframe to a binary format recording file using a CameraKeyframe
+     * Writes a camera keyframe to a binary format recording file using a CameraKeyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a camera keyframe which contains the camera details
-     * \param kfBuffer a buffer temporarily used for preparing data to be written
-     * \param file an ofstream reference to the recording file being written-to
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a camera keyframe which contains the camera details
+     * \param kfBuffer A buffer temporarily used for preparing data to be written
+     * \param file An ofstream reference to the recording file being written-to
      */
     void saveCameraKeyframeBinary(Timestamps& times,
         datamessagestructures::CameraKeyframe& kf, unsigned char* kfBuffer,
         std::ofstream& file);
 
     /**
-     * Writes a camera keyframe to an ascii format recording file using a CameraKeyframe
+     * Writes a camera keyframe to an ascii format recording file using a CameraKeyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a camera keyframe which contains the camera details
-     * \param file an ofstream reference to the recording file being written-to
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a camera keyframe which contains the camera details
+     * \param file An ofstream reference to the recording file being written-to
      */
     void saveCameraKeyframeAscii(Timestamps& times,
         datamessagestructures::CameraKeyframe& kf, std::ofstream& file);
@@ -430,113 +422,111 @@ public:
     /**
      * Writes a time keyframe to a binary format recording file using a TimeKeyframe
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a time keyframe which contains the time details
-     * \param kfBuffer a buffer temporarily used for preparing data to be written
-     * \param file an ofstream reference to the recording file being written-to
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a time keyframe which contains the time details
+     * \param kfBuffer A buffer temporarily used for preparing data to be written
+     * \param file An ofstream reference to the recording file being written-to
      */
     void saveTimeKeyframeBinary(Timestamps& times,
         datamessagestructures::TimeKeyframe& kf, unsigned char* kfBuffer,
         std::ofstream& file);
 
     /**
-     * Writes a time keyframe to an ascii format recording file using a TimeKeyframe
+     * Writes a time keyframe to an ascii format recording file using a TimeKeyframe.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param kf reference to a time keyframe which contains the time details
-     * \param file an ofstream reference to the recording file being written-to
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param kf Reference to a time keyframe which contains the time details
+     * \param file An ofstream reference to the recording file being written-to
      */
     void saveTimeKeyframeAscii(Timestamps& times,
         datamessagestructures::TimeKeyframe& kf, std::ofstream& file);
 
     /**
-     * Writes a script keyframe to a binary format recording file using a ScriptMessage
+     * Writes a script keyframe to a binary format recording file using a ScriptMessage.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param sm reference to a ScriptMessage object which contains the script details
-     * \param smBuffer a buffer temporarily used for preparing data to be written
-     * \param file an ofstream reference to the recording file being written-to
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param sm Reference to a ScriptMessage object which contains the script details
+     * \param smBuffer A buffer temporarily used for preparing data to be written
+     * \param file An ofstream reference to the recording file being written-to
      */
     void saveScriptKeyframeBinary(Timestamps& times,
         datamessagestructures::ScriptMessage& sm, unsigned char* smBuffer,
         std::ofstream& file);
 
     /**
-     * Writes a script keyframe to an ascii format recording file using a ScriptMessage
+     * Writes a script keyframe to an ascii format recording file using a ScriptMessage.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param sm reference to a ScriptMessage which contains the script details
-     * \param file an ofstream reference to the recording file being written-to
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param sm Reference to a ScriptMessage which contains the script details
+     * \param file An ofstream reference to the recording file being written-to
      */
     void saveScriptKeyframeAscii(Timestamps& times,
         datamessagestructures::ScriptMessage& sm, std::ofstream& file);
 
     /**
      * Since session recordings only record changes, the initial conditions aren't
-     * preserved when a playback starts. This function is called whenever a property
-     * value is set and a recording is in progress. Before the set happens, this
-     * function will read the current value of the property and store it so that when
-     * the recording is finished, the initial state will be added as a set property
-     * command at the beginning of the recording file, to be applied when playback
-     * starts.
+     * preserved when a playback starts. This function is called whenever a property value
+     * is set and a recording is in progress. Before the set happens, this function will
+     * read the current value of the property and store it so that when the recording is
+     * finished, the initial state will be added as a set property command at the
+     * beginning of the recording file, to be applied when playback starts.
      *
      * \param prop The property being set
      */
     void savePropertyBaseline(properties::Property& prop);
 
     /**
-     * Reads header information from a session recording file
+     * Reads header information from a session recording file.
      *
-     * \param stream reference to ifstream that contains the session recording file data
-     * \param readLen_chars number of characters to be read, which may be the expected
+     * \param stream Reference to ifstream that contains the session recording file data
+     * \param readLen_chars Number of characters to be read, which may be the expected
      *        length of the header line, or an arbitrary number of characters within it
      */
     static std::string readHeaderElement(std::ifstream& stream, size_t readLen_chars);
 
     /**
-     * Reads header information from a session recording file
+     * Reads header information from a session recording file.
      *
-     * \param stream reference to ifstream that contains the session recording file
-     *        data
-     * \param readLen_chars number of characters to be read, which may be the expected
+     * \param stream Reference to ifstream that contains the session recording file data
+     * \param readLen_chars Number of characters to be read, which may be the expected
      *        length of the header line, or an arbitrary number of characters within it
      */
     static std::string readHeaderElement(std::stringstream& stream, size_t readLen_chars);
 
     /**
-     * Writes a header to a binary recording file buffer
+     * Writes a header to a binary recording file buffer.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param type single character signifying the keyframe type
-     * \param kfBuffer the char buffer holding the recording info to be written
-     * \param idx index into write buffer (this is updated with the num of chars written)
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param type Single character signifying the keyframe type
+     * \param kfBuffer The char buffer holding the recording info to be written
+     * \param idx Index into write buffer (this is updated with the num of chars written)
      */
     static void saveHeaderBinary(Timestamps& times, char type, unsigned char* kfBuffer,
         size_t& idx);
 
     /**
-     * Writes a header to an ascii recording file buffer
+     * Writes a header to an ASCII recording file buffer.
      *
-     * \param times reference to a timestamps structure which contains recorded times
-     * \param type string signifying the keyframe type
-     * \param line the stringstream buffer being written to
+     * \param times Reference to a timestamps structure which contains recorded times
+     * \param type String signifying the keyframe type
+     * \param line The stringstream buffer being written to
      */
     static void saveHeaderAscii(Timestamps& times, const std::string& type,
         std::stringstream& line);
 
     /**
-     * Saves a keyframe to an ascii recording file
+     * Saves a keyframe to an ASCII recording file.
      *
-     * \param entry the ascii string version of the keyframe (any type)
-     * \param file ofstream object to write to
+     * \param entry The ASCII string version of the keyframe (any type)
+     * \param file `std::ofstream` object to write to
      */
     static void saveKeyframeToFile(std::string entry, std::ofstream& file);
 
     /**
-     * Checks if a specified recording file ends with a particular file extension
+     * Checks if a specified recording file ends with a particular file extension.
      *
-     * \param filename the name of the file to record to
-     * \param extension the file extension to check for
+     * \param filename The name of the file to record to
+     * \param extension The file extension to check for
      */
     static bool hasFileExtension(std::string filename, std::string extension);
 
@@ -545,10 +535,9 @@ public:
      * (will determine the file format conversion to convert from based on the file's
      * header version number).
      *
-     * \param filename name of the file to convert
+     * \param filename Name of the file to convert
      * \param depth iteration number to prevent runaway recursion (init call with zero)
-     *
-     * \return string containing the filename of the previous conversion step. This is
+     * \return String containing the filename of the previous conversion step. This is
      *         used if there are multiple conversion steps where each step has to use
      *         the output of the previous.
      */
@@ -558,43 +547,42 @@ public:
      * Converts file format of a session recording file to the current format version
      * (will determine the file format conversion to convert from based on the file's
      * header version number). Accepts a relative path (currently from task runner dir)
-     * rather than a path assumed to be relative to ${RECORDINGS}.
+     * rather than a path assumed to be relative to `${RECORDINGS}`.
      *
      * \param filenameRelative name of the file to convert
      */
     void convertFileRelativePath(std::string filenameRelative);
 
     /**
-     * Goes to legacy session recording inherited class, and calls its convertFile()
+     * Goes to legacy session recording inherited class, and calls its #convertFile
      * method, and then returns the resulting conversion filename.
      *
-     * \param filename name of the file to convert
-     * \param depth iteration number to prevent runaway recursion (init call with zero)
-     *
+     * \param filename Name of the file to convert
+     * \param depth Iteration number to prevent runaway recursion (init call with zero)
      * \return string containing the filename of the conversion
      */
     virtual std::string getLegacyConversionResult(std::string filename, int depth);
 
-    /*
-     * Version string for file format version currently supported by this class
+    /**
+     * Version string for file format version currently supported by this class.
      *
      * \return string of the file format version this class supports
      */
     virtual std::string fileFormatVersion();
 
-    /*
-     * Version string for file format version that a conversion operation will convert
-     * to (e.g. upgrades to this version). This is only relevant for inherited classes
-     * that support conversion from legacy versions (if called in the base class, it
-     * will return its own current version).
+    /**
+     * Version string for file format version that a conversion operation will convert to
+     * (e.g. upgrades to this version). This is only relevant for inherited classes that
+     * support conversion from legacy versions (if called in the base class, it will
+     * return its own current version).
      *
      * \return string of the file format version this class supports
      */
     virtual std::string targetFileFormatVersion();
 
-    /*
-     * Determines a filename for the conversion result based on the original filename
-     * and the file format version number.
+    /**
+     * Determines a filename for the conversion result based on the original filename and
+     the file format version number.
      *
      * \param filename source filename to be converted
      *
@@ -776,6 +764,7 @@ protected:
         "NavigationHandler.OrbitalNavigator.RetargetAnchor",
         "NavigationHandler.OrbitalNavigator.RetargetAim"
     };
+
     //A script that begins with an exact match of any of the strings contained in
     // _scriptRejects will not be recorded
     const std::vector<std::string> _scriptRejects = {
@@ -791,12 +780,14 @@ protected:
         "Anchor",
         "Aim"
     };
+
     //Any script snippet included in this vector will be trimmed from any script
     // from the script manager, before it is recorded in the session recording file.
     // The remainder of the script will be retained.
     const std::vector<std::string> _scriptsToBeTrimmed = {
         "openspace.sessionRecording.togglePlaybackPause"
     };
+
     //Any script snippet included in this vector will be trimmed from any script
     // from the script manager, before it is recorded in the session recording file.
     // The remainder of the script will be retained.
diff --git a/include/openspace/interaction/websocketinputstate.h b/include/openspace/interaction/websocketinputstate.h
index af010226e7..0b57864a23 100644
--- a/include/openspace/interaction/websocketinputstate.h
+++ b/include/openspace/interaction/websocketinputstate.h
@@ -37,7 +37,7 @@ namespace openspace::interaction {
 
 /**
  * Actions that any button of a websocket can have. Each button must be in one of these
- * states
+ * states.
  */
 enum class WebsocketAction : uint8_t {
     /// Idle state if the button is unpressed and has been unpressed since last frame
diff --git a/include/openspace/mission/mission.h b/include/openspace/mission/mission.h
index 281fe107ae..731e1951a3 100644
--- a/include/openspace/mission/mission.h
+++ b/include/openspace/mission/mission.h
@@ -51,8 +51,8 @@ struct Milestone {
  * phases within phases. Designed for WORM usage (Write Once, Read Multiple), and,
  * therefore, has only accessors.
  *
- * Each MissionPhase is characterized by its MissionPhase::name, a TimeRange, an
- * optional MissionPhase::description, and optional subphases.
+ * Each MissionPhase is characterized by its MissionPhase::name, a TimeRange, an optional
+ * MissionPhase::description, and optional subphases.
  */
 class MissionPhase {
 public:
@@ -147,6 +147,7 @@ public:
     /**
      * Returns the Documentation that describes the ghoul::Dictionarty that this
      * MissionPhase can be constructed from.
+     *
      * \return The Documentation that describes the required structure for a Dictionary
      */
     static documentation::Documentation Documentation();
@@ -161,7 +162,7 @@ protected:
      * \param trace The list of MissionPhase%s that are active during the time \p time
      * \param maxDepth The maximum depth of levels that will be considered
      *
-     * \pre maxDepth must not be negative
+     * \pre \p maxDepth must not be negative
      */
     void phaseTrace(double time, Trace& trace, int maxDepth) const;
 
diff --git a/include/openspace/mission/missionmanager.h b/include/openspace/mission/missionmanager.h
index 6e7d395b34..e7a3f9f1bc 100644
--- a/include/openspace/mission/missionmanager.h
+++ b/include/openspace/mission/missionmanager.h
@@ -78,18 +78,18 @@ public:
     * Sets the mission with the name \p missionName as the current mission. The current
     * mission is what is return by `currentMission()`.
     *
-    * \pre missionName must not be empty
+    * \pre \p missionName must not be empty
     */
     void setCurrentMission(const std::string& missionName);
 
     /**
-     * Returns true if a current mission exists
+     * Returns true if a current mission exists.
      */
     bool hasCurrentMission() const;
 
     /**
-     * Returns the latest mission specified to `setCurrentMission()`. If no mission has
-     * been specified, the first mission loaded will be returned. If no mission has been
+     * Returns the latest mission specified to #setCurrentMission. If no mission has been
+     * specified, the first mission loaded will be returned. If no mission has been
      * loaded, a warning will be printed and a dummy mission will be returned.
      */
     const Mission& currentMission();
@@ -99,7 +99,6 @@ public:
      */
     const std::map<std::string, Mission>& missionMap();
 
-
     static scripting::LuaLibrary luaLibrary();
 
 private:
diff --git a/include/openspace/navigation/keyframenavigator.h b/include/openspace/navigation/keyframenavigator.h
index e38fba0bfb..9bb1a3ee4f 100644
--- a/include/openspace/navigation/keyframenavigator.h
+++ b/include/openspace/navigation/keyframenavigator.h
@@ -60,13 +60,14 @@ public:
     };
 
     /**
-    * Update camera position using the next camera pose keyframe from the timeline.
-    * Returns true if camera was set to a pose from the next keyframe.
-    * Returns false if no keyframes are available after the current time.
-    * \param camera A reference to the camera object to have its pose updated.
-    * \param ignoreFutureKeyframes true if only past keyframes are to be used.
-    * \returns true only if a new future keyframe is available to set camera pose.
-    */
+     * Update camera position using the next camera pose keyframe from the timeline.
+     * Returns true if camera was set to a pose from the next keyframe. Returns false if
+     * no keyframes are available after the current time.
+     *
+     * \param camera A reference to the camera object to have its pose updated
+     * \param ignoreFutureKeyframes `true` if only past keyframes are to be used
+     * \return true only if a new future keyframe is available to set camera pose
+     */
     bool updateCamera(Camera& camera, bool ignoreFutureKeyframes);
     static bool updateCamera(Camera* camera, const CameraPose prevPose,
         const CameraPose nextPose, double t, bool ignoreFutureKeyframes);
diff --git a/include/openspace/navigation/navigationhandler.h b/include/openspace/navigation/navigationhandler.h
index fa32df0e4d..ebec211fd3 100644
--- a/include/openspace/navigation/navigationhandler.h
+++ b/include/openspace/navigation/navigationhandler.h
@@ -151,7 +151,7 @@ public:
      * Set camera state from a provided navigation state next frame. The actual position
      * will computed from the scene in the same frame as it is set.
      *
-     * \param state the navigation state to compute a camera positon from
+     * \param state The navigation state to compute a camera positon from
      */
     void setNavigationStateNextFrame(const NavigationState& state);
 
@@ -161,14 +161,14 @@ public:
      * node info. The actual position will computed from the scene in the same frame as
      * it is set.
      *
-     * \param spec the node specification from which to compute the resulting camera pose
+     * \param spec The node specification from which to compute the resulting camera pose
      */
     void setCameraFromNodeSpecNextFrame(NodeCameraStateSpec spec);
 
     /**
-    * \return The Lua library that contains all Lua functions available to affect the
-    * interaction
-    */
+     * \return The Lua library that contains all Lua functions available to affect the
+     *         interaction
+     */
     static scripting::LuaLibrary luaLibrary();
 
 private:
diff --git a/include/openspace/navigation/orbitalnavigator.h b/include/openspace/navigation/orbitalnavigator.h
index 0d5f440cb9..334c8cb400 100644
--- a/include/openspace/navigation/orbitalnavigator.h
+++ b/include/openspace/navigation/orbitalnavigator.h
@@ -43,9 +43,9 @@
 #include <optional>
 
 namespace openspace {
-    class SceneGraphNode;
     class Camera;
     struct CameraPose;
+    class SceneGraphNode;
     struct SurfacePositionHandle;
 } // namespace
 
@@ -87,10 +87,10 @@ public:
     void updateCameraScalingFromAnchor(double deltaTime);
     void resetVelocities();
 
-    /*
+    /**
      * This function should be called on every camera interaction: for example when
-     * navigating using an input device, changing the focus node or starting a path or
-     * a session recording playback
+     * navigating using an input device, changing the focus node or starting a path or a
+     * session recording playback
      */
     void updateOnCameraInteraction();
 
@@ -143,16 +143,15 @@ public:
     glm::quat anchorNodeToCameraRotation() const;
 
     /**
-     * Compute a camera position that pushed the camera position to
-     * a valid position over the anchor node, accounting for the
-     * minimal allowed distance
+     * Compute a camera position that pushed the camera position to a valid position over
+     * the anchor node, accounting for the minimal allowed distance
      */
     glm::dvec3 pushToSurfaceOfAnchor(const glm::dvec3& cameraPosition) const;
 
     /**
-    * \return the Lua library that contains all Lua functions available to affect the
-    * OrbitalNavigator
-    */
+     * \return The Lua library that contains all Lua functions available to affect the
+     *         OrbitalNavigator
+     */
     static scripting::LuaLibrary luaLibrary();
 
 private:
@@ -184,12 +183,11 @@ private:
 
     Friction _friction;
 
-    // Anchor: Node to follow and orbit
+    /// Anchor: Node to follow and orbit
     properties::StringProperty _anchor;
 
-    // Aim: Node to look at (when camera direction is reset),
-    // Empty string means same as anchor.
-    // If these are the same node we call it the `focus` node
+    /// Aim: Node to look at (when camera direction is reset), empty string means same as
+    /// anchor. If these are the same node we call it the `focus` node
     properties::StringProperty _aim;
 
     // Reset camera direction to the anchor node.
@@ -283,6 +281,7 @@ private:
      * Decomposes the camera's rotation in to a global and a local rotation defined by
      * CameraRotationDecomposition. The global rotation defines the rotation so that the
      * camera points towards the reference position.
+     *
      * The local rotation defines the differential from the global to the current total
      * rotation so that `cameraRotation = globalRotation * localRotation`.
      */
@@ -290,40 +289,42 @@ private:
         glm::dvec3 reference);
 
     /**
-     * Composes a pair of global and local rotations into a quaternion that can be used
-     * as the world rotation for a camera.
+     * Composes a pair of global and local rotations into a quaternion that can be used as
+     * the world rotation for a camera.
      */
     glm::dquat composeCameraRotation(const CameraRotationDecomposition& composition);
 
-    /*
-     * Moves and rotates the camera around the anchor node in order to maintain the
-     * screen space position of the aim node. Also interpolates to the aim node, when
-     * retargeting the aim.
+    /**
+     * Moves and rotates the camera around the anchor node in order to maintain the screen
+     * space position of the aim node. Also interpolates to the aim node, when retargeting
+     * the aim.
      */
     CameraPose followAim(CameraPose pose, glm::dvec3 cameraToAnchor,
         Displacement anchorToAim);
 
-    /*
-     * Perform a camera roll on the local camera rotation
-     * \returns a local camera rotation modified with a roll.
+    /**
+     * Perform a camera roll on the local camera rotation.
+     *
+     * \return A local camera rotation modified with a roll
      */
     glm::dquat roll(double deltaTime, const glm::dquat& localCameraRotation) const;
 
     /**
      * Performs rotation around the cameras x and y axes.
-     * \returns a local camera rotation modified with two degrees of freedom.
+     *
+     * \return A local camera rotation modified with two degrees of freedom
      */
     glm::dquat rotateLocally(double deltaTime,
         const glm::dquat& localCameraRotation) const;
 
     /**
      * Interpolates the camera rotation based on active interpolators.
-     * \returns a new rotation quaternion
+     *
+     * \return A new rotation quaternion
      */
     glm::dquat interpolateLocalRotation(double deltaTime,
         const glm::dquat& localCameraRotation);
 
-
     Displacement interpolateRetargetAim(double deltaTime, CameraPose pose,
         glm::dvec3 cameraToAnchor, Displacement anchorToAim);
 
@@ -332,7 +333,7 @@ private:
 
     /**
      * Modify the camera position and global rotation to rotate around the up vector
-     * of the current anchor based on x-wise input
+     * of the current anchor based on x-wise input.
      *
      * The up-vector to rotate around is determined by the "_upToUseForRotation" property
      */
@@ -344,18 +345,18 @@ private:
      * result in an orbital rotation around the object. This function does not affect the
      * rotation but only the position.
      *
-     * \return a position vector adjusted in the horizontal direction.
+     * \return A position vector adjusted in the horizontal direction.
      */
     glm::dvec3 translateHorizontally(double deltaTime, double speedScale,
         const glm::dvec3& cameraPosition, const glm::dvec3& objectPosition,
         const glm::dquat& globalCameraRotation,
         const SurfacePositionHandle& positionHandle) const;
 
-    /*
+    /**
      * Adds rotation to the camera position so that it follows the rotation of the anchor
-     * node defined by the differential anchorNodeRotationDiff.
+     * node defined by the differential \p anchorNodeRotationDiff.
      *
-     * \return a position updated with the rotation defined by anchorNodeRotationDiff
+     * \return A position updated with the rotation defined by \p anchorNodeRotationDiff
      */
     glm::dvec3 followAnchorNodeRotation(const glm::dvec3& cameraPosition,
         const glm::dvec3& objectPosition, const glm::dquat& anchorNodeRotationDiff) const;
@@ -363,7 +364,7 @@ private:
     /**
      * Updates the global rotation so that it points towards the anchor node.
      *
-     * \return a global rotation quaternion defining a rotation towards the anchor node
+     * \return A global rotation quaternion defining a rotation towards the anchor node
      */
     glm::dquat rotateGlobally(const glm::dquat& globalCameraRotation,
         const glm::dquat& aimNodeRotationDiff,
@@ -371,7 +372,8 @@ private:
 
     /**
      * Translates the camera position towards or away from the anchor node.
-     * \returns a position vector adjusted in the vertical direction.
+     *
+     * \return A position vector adjusted in the vertical direction.
      */
     glm::dvec3 translateVertically(double deltaTime, const glm::dvec3& cameraPosition,
         const glm::dvec3& objectPosition,
@@ -380,7 +382,7 @@ private:
     /**
      * Rotates the camera around the out vector of the surface.
      *
-     * \return a quaternion adjusted to rotate around the out vector of the surface
+     * \return A quaternion adjusted to rotate around the out vector of the surface
      */
     glm::dquat rotateHorizontally(double deltaTime,
         const glm::dquat& globalCameraRotation,
@@ -389,7 +391,7 @@ private:
     /**
      * Push the camera out to the surface of the object.
      *
-     * \return a position vector adjusted to be at least _minimumAllowedDistance meters
+     * \return A position vector adjusted to be at least _minimumAllowedDistance meters
      *         above the actual surface of the object
      */
     glm::dvec3 pushToSurface(const glm::dvec3& cameraPosition,
@@ -417,7 +419,7 @@ private:
     void resetIdleBehavior();
 
     /**
-     * Apply the currently selected idle behavior to the position and rotations
+     * Apply the currently selected idle behavior to the position and rotations.
      */
     void applyIdleBehavior(double deltaTime, glm::dvec3& position,
         glm::dquat& localRotation, glm::dquat& globalRotation);
@@ -441,8 +443,8 @@ private:
      * vector coincides with the axis, and should be used with care.
      *
      * Used for:
-     * IdleBehavior::Behavior::OrbitAtConstantLat (axis = north = z-axis) and
-     * IdleBehavior::Behavior::OrbitAroundUp (axis = up = y-axis)
+     *   - IdleBehavior::Behavior::OrbitAtConstantLat (axis = north = z-axis) and
+     *   - IdleBehavior::Behavior::OrbitAroundUp (axis = up = y-axis)
      *
      * \param axis The axis to arbit around, given in model coordinates of the anchor
      * \param angle The rotation angle to use for the motion
diff --git a/include/openspace/navigation/path.h b/include/openspace/navigation/path.h
index 0d9851f6c1..5be7c88fca 100644
--- a/include/openspace/navigation/path.h
+++ b/include/openspace/navigation/path.h
@@ -44,12 +44,12 @@ public:
         AvoidCollision = 0,
         ZoomOutOverview,
         Linear,
-        AvoidCollisionWithLookAt // @TODO (2021-08-13, emmbr) This type right now leads
-                                 // to rapid rotations, but is useful in specific
-                                 // scenarios, e.g. close to surfaces. Later we want to
-                                 // remove it, and create a curve type that looks nicely
-                                 // at the targets when moving, avoids collisions and
-                                 // doesn't introduce sudden large changes in rotation
+
+        // @TODO (2021-08-13, emmbr) This type right now leads to rapid rotations, but is
+        // useful in specific scenarios, e.g. close to surfaces. Later we want to remove
+        // it, and create a curve type that looks nicely at the targets when moving,
+        // avoids collisions and doesn't introduce sudden large changes in rotation
+        AvoidCollisionWithLookAt
     };
 
     Path(Waypoint start, Waypoint end, Type type,
@@ -59,55 +59,55 @@ public:
     Waypoint endPoint() const;
 
     /**
-     * Return the total length of the the curve for the path, in meters
+     * Return the total length of the the curve for the path, in meters.
      */
     double pathLength() const;
 
     /**
      * Return a vector of positions corresponding to the control points of the path's
-     * spline curve
+     * spline curve.
      */
     std::vector<glm::dvec3> controlPoints() const;
 
     /**
      * Take a step along the current path, corresponding to the delta time step \p dt, and
      * return the resulting camera pose. The \p speedScale is a factor that will be
-     * multiplied with the traversal speed
+     * multiplied with the traversal speed.
      */
     CameraPose traversePath(double dt, float speedScale = 1.f);
 
     /**
      * Function that can be used to permaturely quit a path, for example when skipping
-     * to the end
+     * to the end.
      */
     void quitPath();
 
     /**
      * Return the identifer of the node that is the current appropriate anchor node, of
      * the start and end waypoint's reference node. Dtermined based on how far along the
-     * path we have traveled
+     * path we have traveled.
      */
     std::string currentAnchor() const;
 
     /**
-     * Return wether the path has reached its end point or not
+     * Return wether the path has reached its end point or not.
      */
     bool hasReachedEnd() const;
 
     /**
      * Compute the interpolated camera pose at a certain distance along a *linear*
      * path. Note that the linear path is a special case, to avoid risks of precision
-     * problems for long paths
+     * problems for long paths.
      */
     CameraPose linearInterpolatedPose(double distance, double displacement);
 
     /**
-     * Compute the interpolated camera pose at a certain distance along the path
+     * Compute the interpolated camera pose at a certain distance along the path.
      */
     CameraPose interpolatedPose(double distance) const;
 
     /**
-     * Reset variables used to play back path
+     * Reset variables used to play back path.
      */
     void resetPlaybackVariables();
 
@@ -116,49 +116,49 @@ public:
 private:
     /**
      * Interpolate between the paths start and end rotation using the approach that
-     * corresponds to the path's curve type. The interpolation parameter \p t is the
-     * same as for the position interpolation, i.e. the relative traveled distance
-     * along the path, in [0, 1]
+     * corresponds to the path's curve type. The interpolation parameter \p t is the same
+     * as for the position interpolation, i.e. the relative traveled distance along the
+     * path, in [0, 1].
      *
-     * \param t The interpolation parameter, given as the relative traveled distance
-                along the path, in [0, 1]
+     * \param t The interpolation parameter, given as the relative traveled distance along
+     *        the path, in [0, 1]
      */
     glm::dquat interpolateRotation(double t) const;
 
     /**
-     * Compute the interpolated rotation quaternion using an eased SLERP approach
+     * Compute the interpolated rotation quaternion using an eased SLERP approach.
      *
-     * \param t The interpolation variable for the rotatation interpolation.
-     *          Should be the relative traveled distance, in [0, 1]
+     * \param t The interpolation variable for the rotatation interpolation. Should be the
+     *        relative traveled distance, in [0, 1]
      */
     glm::dquat easedSlerpRotation(double t) const;
 
     /**
-     * Compute the interpolated rotation quaternion using a method that is customized
-     * for linear paths. The camera will first interpoalte to look at the targetted
-     * node, and keep doing so for most of the path. At the end, when within a certain
-     * distance from the target, the rotation is interpolated so that the camera ends up
-     * in the target pose at the end of the path.
+     * Compute the interpolated rotation quaternion using a method that is customized for
+     * linear paths. The camera will first interpoalte to look at the targetted node, and
+     * keep doing so for most of the path. At the end, when within a certain distance from
+     * the target, the rotation is interpolated so that the camera ends up in the target
+     * pose at the end of the path.
      *
-     * \param t The interpolation variable for the rotatation interpolation.
-     *          Should be the relative traveled distance, in [0, 1]
+     * \param t The interpolation variable for the rotatation interpolation. Should be the
+     *        relative traveled distance, in [0, 1]
      */
     glm::dquat linearPathRotation(double t) const;
 
     /**
      * Compute the interpolated rotation quaternion using an approach that first
-     * interpolates to look at the start node, and then the end node, before
-     * interpolating to the end rotation
+     * interpolates to look at the start node, and then the end node, before interpolating
+     * to the end rotation.
      *
-     * \param t The interpolation variable for the rotatation interpolation.
-     *          Should be the relative traveled distance, in [0, 1]
+     * \param t The interpolation variable for the rotatation interpolation. Should be the
+     *        relative traveled distance, in [0, 1]
      */
     glm::dquat lookAtTargetsRotation(double t) const;
 
     /**
      * Evaluate the current traversal speed along the path, based on the currently
-     * traveled distance. The final speed will be scaled to match the desired duration
-     * for the path (which might have been specified by the user)
+     * traveled distance. The final speed will be scaled to match the desired duration for
+     * the path (which might have been specified by the user).
      *
      * \param traveledDistance The current distance traveled along the path, in meters
      */
@@ -180,13 +180,13 @@ private:
 };
 
 /**
- * Create a path based on an instruction given as a dictionary. (See top of cpp file
- * for documentation on keys and values for the dictionary.)
- * If /p forceType is specified, that type will primarily be used as the type for the
- * created path. Secondly, the type will be read from the dictionary, and lastly it will
- * use the default from PathNavigator.
+ * Create a path based on an instruction given as a dictionary (see top of cpp file
+ * for documentation on keys and values for the dictionary). If \p forceType is specified,
+ * that type will primarily be used as the type for the created path. Secondly, the type
+ * will be read from the dictionary, and lastly it will use the default from
+ * PathNavigator.
  *
- * \return the created path
+ * \return The created path
  */
 Path createPathFromDictionary(const ghoul::Dictionary& dictionary,
     std::optional<Path::Type> forceType = std::nullopt);
diff --git a/include/openspace/navigation/pathcurve.h b/include/openspace/navigation/pathcurve.h
index 7e8e549e71..5aa8deed13 100644
--- a/include/openspace/navigation/pathcurve.h
+++ b/include/openspace/navigation/pathcurve.h
@@ -46,7 +46,7 @@ public:
     virtual ~PathCurve() = 0;
 
     /**
-     * Return the length of the curve, in meters
+     * Return the length of the curve, in meters.
      */
     double length() const;
 
@@ -56,7 +56,7 @@ public:
      * the full length of the path.
      *
      * Can be overridden by subclasses that want more control over the position
-     * interpolation
+     * interpolation.
      */
     virtual glm::dvec3 positionAt(double relativeDistance) const;
 
@@ -66,27 +66,26 @@ public:
      * position. Note that u does not correspond to the relatively traveled distance.
      *
      * Can be overridden by subclasses that want more control over the position
-     * interpolation
+     * interpolation.
      */
     virtual glm::dvec3 interpolate(double u) const;
 
     /**
-     * Return the positions defining the control points for the spline interpolation
+     * Return the positions defining the control points for the spline interpolation.
      */
     std::vector<glm::dvec3> points() const;
 
 protected:
     /**
-     * Precompute information related to the spline parameters that are
-     * needed for arc length reparameterization. Must be called after
-     * control point creation.
+     * Precompute information related to the spline parameters that are needed for arc
+     * length reparameterization. Must be called after control point creation.
      */
     void initializeParameterData();
 
     /**
-     * Compute curve parameter u that matches the input arc length s.
-     * Input s is a length value in meters, in the range [0, _totalLength].
-     * The returned curve parameter u is in range [0, 1].
+     * Compute curve parameter u that matches the input arc length s. Input s is a length
+     * value in meters, in the range [0, _totalLength]. The returned curve parameter u is
+     * in range [0, 1].
      */
     double curveParameter(double s) const;
 
diff --git a/include/openspace/navigation/pathnavigator.h b/include/openspace/navigation/pathnavigator.h
index 97a19ba703..1cd6082035 100644
--- a/include/openspace/navigation/pathnavigator.h
+++ b/include/openspace/navigation/pathnavigator.h
@@ -81,24 +81,25 @@ public:
     const std::vector<SceneGraphNode*>& relevantNodes();
 
     /**
-    * Find a node close to the given node. Closeness is determined by a factor times
-    * the bounding sphere of the object
-    * \return pointer to the SGN if one was found, nullptr otherwise
-    */
+     * Find a node close to the given node. Closeness is determined by a factor times
+     * the bounding sphere of the object.
+     *
+     * \return Pointer to the SGN if one was found, nullptr otherwise
+     */
     static SceneGraphNode* findNodeNearTarget(const SceneGraphNode* node);
 
     /**
-    * \return The Lua library that contains all Lua functions available to affect the
-    * path navigation
-    */
+     * \return The Lua library that contains all Lua functions available to affect the
+     *         path navigation
+     */
     static scripting::LuaLibrary luaLibrary();
 
 private:
     void handlePathEnd();
 
     /**
-    * Populate list of nodes that are relevant for collision checks, etc
-    */
+     * Populate list of nodes that are relevant for collision checks, etc.
+     */
     void findRelevantNodes();
 
     void removeRollRotation(CameraPose& pose, double deltaTime);
diff --git a/include/openspace/navigation/waypoint.h b/include/openspace/navigation/waypoint.h
index c884adad20..57dca42b10 100644
--- a/include/openspace/navigation/waypoint.h
+++ b/include/openspace/navigation/waypoint.h
@@ -59,7 +59,7 @@ private:
 /**
  * Compute a waypoint from the current camera position.
  *
- * \return the computed WayPoint
+ * \return The computed WayPoint
  */
 Waypoint waypointFromCamera();
 
@@ -76,14 +76,14 @@ struct NodeCameraStateSpec {
  * where the camera will be facing the given node. If there is a 'Sun' node in the scene,
  * it will possibly be used to compute a position on the lit side of the object.
  *
- * \param spec details about the node and state to create the waypoint from. Minimal
- *             information is the identifier of the node, but a position or height
- *             above the bounding sphere may also be given.
- * \param startPoint an optional previous waypoint. If not specified, the current camera
+ * \param spec Details about the node and state to create the waypoint from. Minimal
+ *             information is the identifier of the node, but a position or height above
+ *             the bounding sphere may also be given.
+ * \param startPoint An optional previous waypoint. If not specified, the current camera
  *                   position will be used.
- * \param useLinear if true, the new waypoint will be computed along a straight line
+ * \param useLinear If `true`, the new waypoint will be computed along a straight line
  *                  from the start waypoint to the scene graph node or position.
- * \return the computed WayPoint
+ * \return The computed WayPoint
  */
 Waypoint computeWaypointFromNodeInfo(const NodeCameraStateSpec& spec,
     std::optional<Waypoint> startPoint = std::nullopt, bool useLinear = false);
diff --git a/include/openspace/network/messagestructures.h b/include/openspace/network/messagestructures.h
index 909e7284bd..2e6999523e 100644
--- a/include/openspace/network/messagestructures.h
+++ b/include/openspace/network/messagestructures.h
@@ -66,7 +66,7 @@ struct CameraKeyframe {
 
     double _timestamp = 0.0;
 
-    void serialize(std::vector<char> &buffer) const {
+    void serialize(std::vector<char>& buffer) const {
         // Add position
         buffer.insert(
             buffer.end(),
diff --git a/include/openspace/network/messagestructureshelper.h b/include/openspace/network/messagestructureshelper.h
index 3c0c2678d2..3133c87923 100644
--- a/include/openspace/network/messagestructureshelper.h
+++ b/include/openspace/network/messagestructureshelper.h
@@ -30,25 +30,27 @@
 namespace openspace::datamessagestructures {
 
 /**
- * Method that creates a CameraKeyframe object and populates
- * it with the current properties of the camera from the navigation handler.
- * \returns CameraKeyframe with current state from NavigationHandler
+ * Method that creates a CameraKeyframe object and populates it with the current
+ * properties of the camera from the navigation handler.
+ *
+ * \return CameraKeyframe with current state from NavigationHandler
 */
 CameraKeyframe generateCameraKeyframe();
 
 /**
- * Method that creates a TimeKeyframe object and populates
- * it with the current time values from the application time manager.
- * \returns TimeKeyframe The time keyframe
+ * Method that creates a TimeKeyframe object and populates it with the current time values
+ * from the application time manager.
+ *
+ * \return TimeKeyframe The time keyframe
  */
 TimeKeyframe generateTimeKeyframe();
 
 /**
- * Method that creates a ScriptMessage object from a given script
- * string, and populates the ScriptMessage with the script and timestamp
- * of the current application time.
+ * Method that creates a ScriptMessage object from a given script string, and populates
+ * the ScriptMessage with the script and timestamp of the current application time.
+ *
  * \param script The script to execute in std::string form
- * \returns ScriptMessage The ScriptMessage data structure with script
+ * \return ScriptMessage The ScriptMessage data structure with script
  */
 ScriptMessage generateScriptMessage(std::string script);
 
diff --git a/include/openspace/network/parallelpeer.h b/include/openspace/network/parallelpeer.h
index 9a0d3ab599..2e852d2808 100644
--- a/include/openspace/network/parallelpeer.h
+++ b/include/openspace/network/parallelpeer.h
@@ -66,9 +66,9 @@ public:
     double latencyStandardDeviation() const;
 
     /**
-    * Returns the Lua library that contains all Lua functions available to affect the
-    * remote OS parallel connection.
-    */
+     * Returns the Lua library that contains all Lua functions available to affect the
+     * remote OS parallel connection.
+     */
     static scripting::LuaLibrary luaLibrary();
     ParallelConnection::Status status();
     int nConnections();
diff --git a/include/openspace/properties/numericalproperty.h b/include/openspace/properties/numericalproperty.h
index 2ae25ae160..dc7cc814c1 100644
--- a/include/openspace/properties/numericalproperty.h
+++ b/include/openspace/properties/numericalproperty.h
@@ -73,9 +73,10 @@ protected:
     std::string generateAdditionalJsonDescription() const override;
 
     /**
-     * convert a lua formatted value to a JSON formatted value
-     * @param luaValue
-     * @return a json formatted string representation of the given lua value
+     * convert a lua formatted value to a JSON formatted value.
+     *
+     * \param luaValue
+     * \return A JSON formatted string representation of the given Lua value
      */
     std::string luaToJson(std::string luaValue) const;
 
diff --git a/include/openspace/properties/optionproperty.h b/include/openspace/properties/optionproperty.h
index 2bb2366324..f115c05608 100644
--- a/include/openspace/properties/optionproperty.h
+++ b/include/openspace/properties/optionproperty.h
@@ -33,15 +33,15 @@ namespace openspace::properties {
 
 /**
  * The OptionProperty is a property that provides a number of predefined (using the
- * addOption method) options consisting of a `description` and a `value`. The available
+ * #addOption method) options consisting of a `description` and a `value`. The available
  * options can be queried using the options method. Only values representing valid options
- * can be used to set this property, or an error will be logged
+ * can be used to set this property, or an error will be logged.
  */
 class OptionProperty : public IntProperty {
 public:
     /**
-     * The struct storing a single option consisting of an integer `value` and a
-     * `string` description.
+     * The struct storing a single option consisting of an integer `value` and a `string`
+     * description.
      */
     struct Option {
         int value;
@@ -57,7 +57,8 @@ public:
      * The constructor delegating the `identifier` and the `guiName` to its super class.
      *
      * \param info The PropertyInfo structure that contains all the required static
-     *        information for initializing this Property.
+     *        information for initializing this Property
+     *
      * \pre \p info.identifier must not be empty
      * \pre \p info.guiName must not be empty
      */
@@ -67,7 +68,7 @@ public:
     * The constructor delegating the `identifier` and the `guiName` to its super class.
     *
     * \param info The PropertyInfo structure that contains all the required static
-    *        information for initializing this Property.
+    *        information for initializing this Property
     * \param displayType Optional DisplayType for GUI (default RADIO)
     *
     * \pre \p info.identifier must not be empty
@@ -123,7 +124,7 @@ public:
     const std::vector<Option>& options() const;
 
     /**
-     * This function removes all previous options from the OptionProperty
+     * This function removes all previous options from the OptionProperty.
      */
     void clearOptions();
 
@@ -151,10 +152,10 @@ public:
     const Option& option() const;
 
     /**
-    * Get the description of the option that matches `value`.
-    *
-    * \param value The value of the option
-    */
+     * Get the description of the option that matches `value`.
+     *
+     * \param value The value of the option
+     */
     std::string getDescriptionByValue(int value);
 
 private:
diff --git a/include/openspace/properties/property.h b/include/openspace/properties/property.h
index 4a5fc2a18c..3ec4521a14 100644
--- a/include/openspace/properties/property.h
+++ b/include/openspace/properties/property.h
@@ -41,8 +41,8 @@ class PropertyOwner;
 /**
  * A property encapsulates a value which should be user-changeable. A property almost
  * always belongs to a PropertyOwner who has taken ownership (setPropertyOwner) of the
- * Property. Per PropertyOwner, the `identifier` needs to be unique and can be
- * used as a URI. This class is an abstract base class and each subclass (most notable
+ * Property. Per PropertyOwner, the `identifier` needs to be unique and can be used as a
+ * URI. This class is an abstract base class and each subclass (most notable
  * TemplateProperty) needs to implement the methods Property::className, Property::get,
  * Property::set, Property::type(), Property::getLuaValue, Property::setLuaValue,
  * Property::getStringValue, and Property::typeLua to make full use of the infrastructure.
@@ -56,24 +56,32 @@ class PropertyOwner;
  * which might be used in GUI representations. One example would be a glm::vec4 property,
  * (Vec4Property) that can either represent a 4-dimensional position, a powerscaled
  * coordinate, a light position, or other things, requiring different GUI representations.
+ *
  * \see TemplateProperty
  * \see PropertyOwner
  */
 class Property {
 public:
     /**
-    * The visibility classes for Property%s. The classes are strictly ordered as
-    * Hidden > Developer > AdvancedUser > User > NoviceUser > Always
-    */
+     * The visibility classes for Property%s. The classes are strictly ordered as
+     * Hidden > Developer > AdvancedUser > User > NoviceUser > Always
+     */
     enum class Visibility {
-        Hidden = 5, ///< Never visible
-        Developer = 4, ///< Visible in Developer mode
-        AdvancedUser = 3, ///< Visible in Advanced User mode
-        User = 2, ///< Visible in User mode
-        NoviceUser = 1, ///< Visible in Novice User mode
-        Always = 0,  ///< Visible for all types, no matter what
+        /// Never visible
+        Hidden = 5,
+        /// Visible in Developer mode
+        Developer = 4,
+        /// Visible in Advanced User mode
+        AdvancedUser = 3,
+        /// Visible in User mode
+        User = 2,
+        /// Visible in Novice User mode
+        NoviceUser = 1,
+        /// Visible for all types, no matter what
+        Always = 0,
 
-        Default = Always ///< The default visibility for properties
+        /// The default visibility for properties
+        Default = Always
     };
 
     /**
@@ -81,8 +89,10 @@ public:
      * identifier, a GUI name and descriptive text that are both user facing.
      */
     struct PropertyInfo {
-        /// GCC requires an explicit constructor here, as it does not handle the default
-        /// argument for the struct initialization
+        /**
+         * GCC requires an explicit constructor here, as it does not handle the default
+         * argument for the struct initialization.
+         */
         constexpr PropertyInfo(const char* ident, const char* gui, const char* desc)
             : identifier(ident)
             , guiName(gui)
@@ -208,9 +218,9 @@ public:
      * Returns the Lua type that will be put onto the stack in the Property::getLua method
      * and which will be consumed by the Property::setLuaValue method. The returned value
      * can belong to the set of Lua types: `LUA_TNONE`, `LUA_TNIL`, `LUA_TBOOLEAN`,
-     * `LUA_TLIGHTUSERDATA`, `LUA_TNUMBER`, `LUA_TSTRING`, `LUA_TTABLE`,
-     * `LUA_TFUNCTION`, `LUA_TUSERDATA`, or `LUA_TTHREAD`. The default implementation
-     * will return `LUA_TNONE`.
+     * `LUA_TLIGHTUSERDATA`, `LUA_TNUMBER`, `LUA_TSTRING`, `LUA_TTABLE`, `LUA_TFUNCTION`,
+     * `LUA_TUSERDATA`, or `LUA_TTHREAD`. The default implementation will return
+     * `LUA_TNONE`.
      *
      * \return The Lua type that will be consumed or produced by the Property::getLuaValue
      *         and Property::setLuaValue methods.
@@ -237,18 +247,18 @@ public:
      *        Property::setLuaValue methods.
      * \return An OnChangeHandle that can be used in subsequent calls to remove a callback
      *
-     * \pre The callback must not be empty
+     * \pre The \p callback must not be empty
      */
     OnChangeHandle onChange(std::function<void()> callback);
 
     /**
-    * This method registers a \p callback function that will be called when the property
-    * is destructed.
-    *
-    * \return An OnDeleteHandle that can be used in subsequent calls to remove a callback
-    *
-    * \pre The callback must not be empty
-    */
+     * This method registers a \p callback function that will be called when the property
+     * is destructed.
+     *
+     * \return An OnDeleteHandle that can be used in subsequent calls to remove a callback
+     *
+     * \pre The \p callback must not be empty
+     */
     OnDeleteHandle onDelete(std::function<void()> callback);
 
     /**
@@ -265,15 +275,15 @@ public:
     void removeOnChange(OnChangeHandle handle);
 
     /**
-    * This method deregisters a callback that was previously registered with the onDelete
-    * method.
-    *
-    * \param handle An OnDeleteHandle that was returned from a previous call to onDelete
-    *        by this property.
-    *
-    * \pre \p handle must refer to a callback that has been previously registred
-    * \pre \p handle must refer to a callback that has not been removed previously
-    */
+     * This method deregisters a callback that was previously registered with the onDelete
+     * method.
+     *
+     * \param handle An OnDeleteHandle that was returned from a previous call to onDelete
+     *        by this property.
+     *
+     * \pre \p handle must refer to a callback that has been previously registred
+     * \pre \p handle must refer to a callback that has not been removed previously
+     */
     void removeOnDelete(OnDeleteHandle handle);
 
     /**
@@ -296,7 +306,7 @@ public:
      * Returns the PropertyOwner of this Property or `nullptr`, if it does not have an
      * owner.
      *
-     * \return The Property of this Property
+     * \return The PropertyOwner of this Property
      */
     PropertyOwner* owner() const;
 
@@ -337,8 +347,9 @@ public:
     void setGroupIdentifier(std::string groupId);
 
     /**
-     * Returns the group idenfier that this Property belongs to, or `""` if it
-     * belongs to no group.
+     * Returns the group idenfier that this Property belongs to, or `""` if it belongs to
+     * no group.
+     *
      * \return The group identifier that this Property belongs to
      */
     std::string groupIdentifier() const;
@@ -363,8 +374,8 @@ public:
      * This method determines if this Property should be read-only in external
      * applications. This setting is only a hint and does not need to be followed by GUI
      * applications and does not have any effect on the Property::set or
-     * Property::setLuaValue methods. The value is stored in the metaData Dictionary
-     * with the key: `isReadOnly`. The default value is `false`.
+     * Property::setLuaValue methods. The value is stored in the metaData Dictionary with
+     * the key: `isReadOnly`. The default value is `false`.
      *
      * \param state `true` if the Property should be read only, `false` otherwise
      */
@@ -373,8 +384,8 @@ public:
     /**
      * Default view options that can be used in the Property::setViewOption method. The
      * values are:
-     * - Property::ViewOptions::Color = `Color` (Intended for Vec3 and Vec4),
-     * - Property::ViewOptions::MinMaxRange = `MinMaxRange` (Intended for Vec2)
+     *   - Property::ViewOptions::Color = `Color` (Intended for Vec3 and Vec4),
+     *   - Property::ViewOptions::MinMaxRange = `MinMaxRange` (Intended for Vec2)
      */
     struct ViewOptions {
         static const char* Color;
@@ -385,9 +396,10 @@ public:
      * This method allows the developer to give hints to the GUI about different
      * representations for the GUI. The same Property (for example Vec4Property) can be
      * used in different ways, each requiring a different input method. These values are
-     * stored in the metaData object under `ViewOptions`.
-     * See Property::ViewOptions for a default list of possible options. As these are
-     * only hints, the GUI is free to ignore any suggestion by the developer.
+     * stored in the metaData object under `ViewOptions`. See Property::ViewOptions for a
+     * default list of possible options. As these are only hints, the GUI is free to
+     * ignore any suggestion by the developer.
+     *
      * \param option The view option that should be modified
      * \param value Determines if the view option should be active (`true`) or
      *        deactivated (`false`)
@@ -401,7 +413,6 @@ public:
      *
      * \param option The view option that should be retrieved
      * \param defaultValue The value that is returned if the \p option was not set
-     *
      * \return The view option's value
      */
     bool viewOption(const std::string& option, bool defaultValue = false) const;
@@ -418,7 +429,7 @@ public:
     /**
      * Get a valid JSON formatted representation of the Property's value.
      *
-     * \return the value in a json compatible format
+     * \return The value in a JSON compatible format
      */
     virtual std::string jsonValue() const;
 
@@ -431,8 +442,8 @@ public:
 
     /**
      * Creates the information that is general to every Property and adds the
-     * `Identifier`, `Name`, `Type`, and `MetaData` keys and their values. The meta
-     * data is handles by the generateMetaDataJsonDescription method, which has to be
+     * `Identifier`, `Name`, `Type`, and `MetaData` keys and their values. The meta data
+     * is handles by the generateMetaDataJsonDescription method, which has to be
      * overloaded if a concrete base class wants to add meta data that is not curated by
      * the Property class.
      *
diff --git a/include/openspace/properties/propertyowner.h b/include/openspace/properties/propertyowner.h
index e803fa8930..7fc6e03858 100644
--- a/include/openspace/properties/propertyowner.h
+++ b/include/openspace/properties/propertyowner.h
@@ -54,8 +54,8 @@ public:
 
     struct PropertyOwnerInfo {
         std::string identifier;
-        std::string guiName = "";
-        std::string description = "";
+        std::string guiName;
+        std::string description;
     };
 
     /**
@@ -63,7 +63,7 @@ public:
      *
      * \param info The PropertyOwnerInfo struct that contains the
      *             #PropertyOwnerInfo::identifier, #PropertyOwnerInfo::guiName, and
-     *             #PropertyOwnerInfo::description of this PropertyOwner.
+     *             #PropertyOwnerInfo::description of this PropertyOwner
      *
      * \pre The \p info 's #PropertyOwnerInfo::identifier must not contain any whitespaces
      * \pre The \p info 's #PropertyOwnerInfo::identifier must not contain any `.`
@@ -141,11 +141,11 @@ public:
 
     /**
      * Retrieves a Property identified by \p uri from this PropertyOwner. If \p uri does
-     * not contain a `.` the identifier must refer to a Property directly owned
-     * by this PropertyOwner. If the identifier contains one or more `.`, the
-     * first part of the name will be recursively extracted and used as a name for a
-     * sub-owner and only the last part of the identifier is referring to a Property owned
-     * by PropertyOwner named by the second-but-last name.
+     * not contain a `.` the identifier must refer to a Property directly owned by this
+     * PropertyOwner. If the identifier contains one or more `.`, the first part of the
+     * name will be recursively extracted and used as a name for a sub-owner and only the
+     * last part of the identifier is referring to a Property owned by PropertyOwner named
+     * by the second-but-last name.
      *
      * \param uri The identifier of the Property that should be extracted
      * \return If the Property cannot be found, `nullptr` is returned, otherwise the
@@ -155,19 +155,20 @@ public:
 
     /**
      * This method checks if a Property with the provided \p uri exists in this
-     * PropertyOwner (or any sub-owner). If the identifier contains one or more
-     * `.`, the first part of the name will be recursively extracted and is
-     * used as a name for a sub-owner and only the last part of the identifier is
-     * referring to a Property owned by PropertyOwner named by the second-but-last name.
+     * PropertyOwner (or any sub-owner). If the identifier contains one or more `.`, the
+     * first part of the name will be recursively extracted and is used as a name for a
+     * sub-owner and only the last part of the identifier is referring to a Property owned
+     * by PropertyOwner named by the second-but-last name.
      *
-     * \return `true` if the \p uri refers to a Property; `false` otherwise.
+     * \return `true` if the \p uri refers to a Property; `false` otherwise
      */
     bool hasProperty(const std::string& uri) const;
 
     /**
-    * This method checks if a Property exists in this PropertyOwner.
-    * \return `true` if the Property existed, `false` otherwise.
-    */
+     * This method checks if a Property exists in this PropertyOwner.
+     *
+     * \return `true` if the Property existed, `false` otherwise
+     */
     bool hasProperty(const Property* prop) const;
 
     void setPropertyOwner(PropertyOwner* owner) { _owner = owner; }
@@ -185,11 +186,11 @@ public:
     /**
      * This method returns the direct sub-owner of this PropertyOwner with the provided
      * \p identifier. This means that `identifier` cannot contain any `.` as this
-     * character is not allowed in PropertyOwner names. If the \p name does not name a
-     * valid sub-owner of this PropertyOwner, a `nullptr` will be returned.
+     * character is not allowed in PropertyOwner names. If the \p identifier does not name
+     * a valid sub-owner of this PropertyOwner, a `nullptr` will be returned.
      *
      * \param identifier The identifier of the sub-owner that should be returned
-     * \return The PropertyOwner with the given \p name, or `nullptr`
+     * \return The PropertyOwner with the given \p identifier, or `nullptr`
      */
     PropertyOwner* propertySubOwner(const std::string& identifier) const;
 
@@ -294,7 +295,9 @@ public:
      */
     void removeTag(const std::string& tag);
 
-    // Generate JSON for documentation
+    /**
+     * Generate JSON for documentation.
+     */
     nlohmann::json generateJson() const;
 
 protected:
diff --git a/include/openspace/properties/scalar/shortproperty.h b/include/openspace/properties/scalar/shortproperty.h
index c91c3999eb..be258b07ca 100644
--- a/include/openspace/properties/scalar/shortproperty.h
+++ b/include/openspace/properties/scalar/shortproperty.h
@@ -25,19 +25,6 @@
 #ifndef __OPENSPACE_CORE___SHORTPROPERTY___H__
 #define __OPENSPACE_CORE___SHORTPROPERTY___H__
 
- /**
- * \file shortproperty.h
- *
- * \addtogroup openspace
- * @{
- * \addtogroup properties
- * @{
-
- * \class ShortProperty
-
- * @} @}
- */
-
 #include <openspace/properties/numericalproperty.h>
 #include <limits>
 
diff --git a/include/openspace/properties/selectionproperty.h b/include/openspace/properties/selectionproperty.h
index 2207317070..45cca8b4c8 100644
--- a/include/openspace/properties/selectionproperty.h
+++ b/include/openspace/properties/selectionproperty.h
@@ -41,10 +41,10 @@ public:
     int typeLua() const override;
 
     /**
-     * This method sets the stored value to the provided value `val`.
-     * If the value is different, the listeners are notified. It also removes any
-     * invalid keys in the input set. A key is invalid if it does not correspond to
-     * an existing option in the SelectionProperty
+     * This method sets the stored value to the provided value `val`. If the value is
+     * different, the listeners are notified. It also removes any invalid keys in the
+     * input set. A key is invalid if it does not correspond to an existing option in the
+     * SelectionProperty.
      *
      * \param val The new value for this SelectionProperty
      */
@@ -67,16 +67,16 @@ public:
     bool isSelected(const std::string& key) const;
 
     /**
-     * Checks if the SelectionProperty has any selected values, that is, if its
-     * value is empty.
+     * Checks if the SelectionProperty has any selected values, that is, if its value is
+     * empty.
      *
      * \return `true` if there are selected options; `false` otherwise
      */
     bool hasSelected() const;
 
     /**
-     * Returns all available options for this SelectionProperty. Should be
-     * sorted alphabetically.
+     * Returns all available options for this SelectionProperty. Should be sorted
+     * alphabetically.
      *
      * \return A list of all available options
      */
@@ -99,7 +99,7 @@ public:
     void addOption(const std::string& key);
 
     /**
-     * This method clears the selection list, that is the value of this SelectionProperty
+     * This method clears the selection list, that is the value of this SelectionProperty.
      */
     void clearSelection();
 
diff --git a/include/openspace/properties/templateproperty.h b/include/openspace/properties/templateproperty.h
index 9d80a58d5d..b4e7318635 100644
--- a/include/openspace/properties/templateproperty.h
+++ b/include/openspace/properties/templateproperty.h
@@ -30,20 +30,21 @@
 namespace openspace::properties {
 
 /**
- * This subclass of Property handles a single parameter value that is of type
- * `T`. It provides all the necessary methods to automatically access the
- * value. One notable instantiation of this class is StringProperty, using
- * `T = std::string` while NumericalProperty is a templated subclass dealing
- * with numerical parameter types.
+ * This subclass of Property handles a single parameter value that is of type `T`. It
+ * provides all the necessary methods to automatically access the value. One notable
+ * instantiation of this class is StringProperty, using `T = std::string` while
+ * NumericalProperty is a templated subclass dealing with numerical parameter types.
+ *
  * The accessor operator and assignment operators are overloaded, so that the
  * TemplateProperty can be used just in the same way as a regular member variable. In the
  * case that these cannot not be used inline, the Property::get method will work.
  *
  * Each instantiation of this class should provide a constructor that deals with the
- * default value for that specific type `T`, so that a property can be
- * created from just a Property::PropertyInfo object.
+ * default value for that specific type `T`, so that a property can be created from just a
+ * Property::PropertyInfo object.
  *
  * \tparam T The type of value that is stored in this TemplateProperty
+ *
  * \see Property
  * \see NumericalProperty
  */
@@ -66,33 +67,31 @@ public:
     TemplateProperty(Property::PropertyInfo info, T value);
 
     /**
-     * Returns the class name for this TemplateProperty. This method has to be
-     * specialized for each new type.
+     * Returns the class name for this TemplateProperty. This method has to be specialized
+     * for each new type.
      *
      * \return The class name for the TemplateProperty
      */
     virtual std::string_view className() const override = 0;
 
     /**
-     * Returns the stored value packed into a ghoul::any object.
+     * Returns the stored value packed into a `std::any` object.
      *
-     * \return The stored value packed into a ghoul::any object
+     * \return The stored value packed into a `std::any` object
      */
     virtual std::any get() const override;
 
     /**
-     * Sets the value from the provided ghoul::any object. If the types between
-     * `T` and `value` disagree, an error is logged and the stored
-     * value remains unchanged.
+     * Sets the value from the provided ghoul::any object. If the types between `T` and
+     * `value` disagree, an error is logged and the stored value remains unchanged.
      *
      * \param value The value that is used to set this Property
      */
     virtual void set(std::any value) final;
 
     /**
-     * Returns the `std::type_info` describing the template parameter
-     * `T`. It can be used to test against a ghoul::any value before trying to
-     * assign it.
+     * Returns the `std::type_info` describing the template parameter `T`. It can be used
+     * to test against a ghoul::any value before trying to assign it.
      *
      * \return The type info object describing the template parameter `T`
      */
@@ -127,19 +126,11 @@ public:
      */
     virtual std::string stringValue() const override;
 
-    /**
-     * Returns the description for this TemplateProperty as a Lua script that returns a
-     * table on execution.
-     *
-     * \return The description for this TemplateProperty
-     */
-    //virtual std::string description() override;
-
     /**
      * This operator allows the TemplateProperty to be used almost transparently as if it
-     * was of the type `T`. It makes assignments such as
-     * `T v = property;` possible by allowing implicit casts (even though,
-     * internally, not casts are performed. This method is next to zero overhead).
+     * was of the type `T`. It makes assignments such as `T v = property;` possible by
+     * allowing implicit casts (even though, internally, not casts are performed. This
+     * method is next to zero overhead).
      *
      * \return The internal representation of the Property
      */
@@ -147,9 +138,9 @@ public:
 
     /**
      * This operator allows the TemplateProperty to be used almost transparently as if it
-     * was of the type `T`. It makes assignments such as
-     * `T v = property;` possible by allowing implicit casts (even though,
-     * internally, not casts are performed. This method is next to zero overhead).
+     * was of the type `T`. It makes assignments such as `T v = property;` possible by
+     * allowing implicit casts (even though, internally, not casts are performed. This
+     * method is next to zero overhead).
      *
      * \return The internal representation of the Property
      */
@@ -165,10 +156,10 @@ public:
     TemplateProperty<T>& operator=(T val);
 
     /**
-     * This method sets the stored value to the provided value `val`,
-     * moving it into place. The move only happens if the provided value `val`
-     * is different from the stored value, which needs an operator== to exist for the type
-     * `T`. If the value is different, the listeners are notified.
+     * This method sets the stored value to the provided value `val`, moving it into
+     * place. The move only happens if the provided value `val` is different from the
+     * stored value, which needs an operator== to exist for the type `T`. If the value is
+     * different, the listeners are notified.
      *
      * \param val The new value for this TemplateProperty
      */
@@ -183,17 +174,17 @@ public:
 
 protected:
     /**
-     * Decodes the object at the top of the stack to a value of the type `T`
-     * and returns it. This method has to be specialized for each new type.
+     * Decodes the object at the top of the stack to a value of the type `T` and returns
+     * it. This method has to be specialized for each new type.
      *
      * \param state The Lua state from which the value will be decoded
-     * \return the decoded value
+     * \return The decoded value
      */
     virtual T fromLuaConversion(lua_State* state) const = 0;
 
     /**
-     * Encodes the stored value into a Lua object and pushes that object onto
-     * the stack. This method has to be specialized for each new type.
+     * Encodes the stored value into a Lua object and pushes that object onto the stack.
+     * This method has to be specialized for each new type.
      *
      * \param state The Lua state onto which the encoded object will be pushed
      */
@@ -201,8 +192,8 @@ protected:
 
     /**
      * Encodes the stored value into a std::string object, in a format that is a valid
-     * JSON representation of the property. This method has to be specialized for each
-     * new type.
+     * JSON representation of the property. This method has to be specialized for each new
+     * type.
      *
      * \return The resulting encoding
      */
diff --git a/include/openspace/properties/triggerproperty.h b/include/openspace/properties/triggerproperty.h
index 35bd620414..6e5210cbd7 100644
--- a/include/openspace/properties/triggerproperty.h
+++ b/include/openspace/properties/triggerproperty.h
@@ -36,11 +36,11 @@ namespace openspace::properties {
 class TriggerProperty : public Property {
 public:
     /**
-     * Initializes the TriggerProperty by delegating the `identifier` and
-     * `guiName` to the Property constructor.
+     * Initializes the TriggerProperty by delegating the `identifier` and `guiName` to the
+     * Property constructor.
      *
      * \param info The PropertyInfo structure that contains all the required static
-     *        information for initializing this Property.
+     *        information for initializing this Property
      * \pre \p info.identifier must not be empty
      * \pre \p info.guiName must not be empty
      */
@@ -54,8 +54,8 @@ public:
     std::string_view className() const override;
 
     /**
-     * Accepts only the `LUA_TNIL` type and will notify all the listeners
-     * that the event has been triggered.
+     * Accepts only the `LUA_TNIL` type and will notify all the listeners that the event
+     * has been triggered.
      *
      * \param state The unused Lua state
      */
diff --git a/include/openspace/rendering/dashboard.h b/include/openspace/rendering/dashboard.h
index 64603cc36d..2f0fcf1131 100644
--- a/include/openspace/rendering/dashboard.h
+++ b/include/openspace/rendering/dashboard.h
@@ -54,9 +54,9 @@ public:
     glm::vec2 getStartPositionOffset();
 
     /**
-    * Returns the Lua library that contains all Lua functions available to affect the
-    * rendering.
-    */
+     * Returns the Lua library that contains all Lua functions available to affect the
+     * rendering.
+     */
     static scripting::LuaLibrary luaLibrary();
 
 private:
diff --git a/include/openspace/rendering/fadeable.h b/include/openspace/rendering/fadeable.h
index 7ded6d8b1b..d26108c14a 100644
--- a/include/openspace/rendering/fadeable.h
+++ b/include/openspace/rendering/fadeable.h
@@ -31,7 +31,7 @@ namespace openspace {
 
 /**
  * This class is an interface for all things fadeable in the software; things that need
- * a fade and opacity property, which will be combined into a final opacity value
+ * a fade and opacity property, which will be combined into a final opacity value.
  *
  * A Fadeable can also be dependent on the fade value from a specified parent fadeable,
  * so that it fades out together with the parent
diff --git a/include/openspace/rendering/framebufferrenderer.h b/include/openspace/rendering/framebufferrenderer.h
index 429c5c48db..e89f2ec76d 100644
--- a/include/openspace/rendering/framebufferrenderer.h
+++ b/include/openspace/rendering/framebufferrenderer.h
@@ -67,11 +67,11 @@ public:
      * for all RenderBins. However, it cannot be used at the same time as the Deferred
      * Caster Tasks. The size of the texture is the resolution of the viewport.
      *
-     * NOTE (malej 2023-FEB-21): The currently NOT used pingPongTexture might change
+     * NOTE (malej 2023-02-21): The currently NOT used pingPongTexture might change
      * depending on where in the render cycle you are. Especially after the Deferred
      * Caster Tasks.
      *
-     * \return identifier of the currently NOT used pingPongTexture
+     * \return The identifier of the currently NOT used pingPongTexture
      */
     GLuint additionalColorTexture1() const;
 
@@ -80,7 +80,7 @@ public:
      * However, it cannot be used at the same time as the Raycaster Tasks. The size of the
      * texture is the resolution of the viewport.
      *
-     * \return identifier of the exitColorTexture
+     * \return The identifier of the exitColorTexture
      */
     GLuint additionalColorTexture2() const;
 
@@ -89,7 +89,7 @@ public:
      * However, it cannot be used at the same time as the FXAA Task. The size of the
      * texture is the resolution of the viewport.
      *
-     * \return identifier of the fxaaTexture
+     * \return The identifier of the fxaaTexture
      */
     GLuint additionalColorTexture3() const;
 
@@ -98,7 +98,7 @@ public:
      * However, it cannot be used at the same time as the Raycaster Tasks. The size of the
      * texture is the resolution of the viewport.
      *
-     * \return identifier of the exitDepthTexture
+     * \return The identifier of the exitDepthTexture
      */
     GLuint additionalDepthTexture() const;
 
@@ -111,7 +111,7 @@ public:
      * the majority of rendering the scene and might be already in use. Use CAUTION when
      * using this function. The size of the texture is the resolution of the viewport.
      *
-     * \return identifier of the color texture of the G-buffer
+     * \return The identifier of the color texture of the G-buffer
      */
     GLuint gBufferColorTexture() const;
 
@@ -121,7 +121,7 @@ public:
      * when using this function. The size of the texture is the resolution of the
      * viewport.
      *
-     * \return identifier of the position texture of the G-buffer
+     * \return The identifier of the position texture of the G-buffer
      */
     GLuint gBufferPositionTexture() const;
 
@@ -130,7 +130,7 @@ public:
      * the majority of rendering the scene and might be already in use. Use CAUTION when
      * using this function. The size of the texture is the resolution of the viewport.
      *
-     * \return identifier of the normal texture of the G-buffer
+     * \return The identifier of the normal texture of the G-buffer
      */
     GLuint gBufferNormalTexture() const;
 
@@ -139,7 +139,7 @@ public:
      * the majority of rendering the scene and might be already in use. Use CAUTION when
      * using this function. The size of the texture is the resolution of the viewport.
      *
-     * \return identifier of the depth texture of the G-buffer
+     * \return The identifier of the depth texture of the G-buffer
      */
     GLuint gBufferDepthTexture() const;
 
@@ -171,8 +171,7 @@ public:
     void render(Scene* scene, Camera* camera, float blackoutFactor);
 
     /**
-     * Update render data
-     * Responsible for calling renderEngine::setRenderData
+     * Update render data. Responsible for calling renderEngine::setRenderData
      */
     virtual void updateRendererData();
 
diff --git a/include/openspace/rendering/helper.h b/include/openspace/rendering/helper.h
index ddff046cd4..b12b0cd390 100644
--- a/include/openspace/rendering/helper.h
+++ b/include/openspace/rendering/helper.h
@@ -160,7 +160,7 @@ VertexIndexListCombo<VertexXYZNormal> createCone(unsigned int nSegments, float r
     float height);
 
 /**
- * Data structure that can be used for rendering using multiple light directions
+ * Data structure that can be used for rendering using multiple light directions.
  */
 struct LightSourceRenderData {
     unsigned int nLightSources = 0;
diff --git a/include/openspace/rendering/renderable.h b/include/openspace/rendering/renderable.h
index cb41bf07b4..c143e15a96 100644
--- a/include/openspace/rendering/renderable.h
+++ b/include/openspace/rendering/renderable.h
@@ -127,7 +127,9 @@ protected:
 
     void setRenderBinFromOpacity();
 
-    /// Returns the full opacity constructed from the _opacity and _fade property values
+    /**
+     * Returns the full opacity constructed from the _opacity and _fade property values.
+     */
     float opacity() const noexcept override;
 
     SceneGraphNode* parent() const noexcept;
@@ -148,15 +150,15 @@ protected:
     };
 
     /**
-     * Calculates the model transformation matrix with the given data and returns it
+     * Calculates the model transformation matrix with the given data and returns it.
      *
-     * \param data the RenderData for the object that the model transformation matrix
+     * \param data The RenderData for the object that the model transformation matrix
      *        should be calculated for
-     * \param altTransform an object containing alternative transformations to use instead
+     * \param altTransform An object containing alternative transformations to use instead
      *        of those given in data. The transforms can be translation, rotation and
      *        scale.
      *
-     * \return the resulting model transformation matrix in double precision
+     * \return The resulting model transformation matrix in double precision
      */
     glm::dmat4 calcModelTransform(const RenderData& data,
         const AlternativeTransform& altTransform = {
@@ -164,28 +166,26 @@ protected:
         }) const;
 
     /**
-     * Calculates the model view transformation matrix with the given data and returns it
+     * Calculates the model view transformation matrix with the given data and returns it.
      *
-     * \param data the RenderData for the object that the model view transformation matrix
+     * \param data The RenderData for the object that the model view transformation matrix
      *        should be calculated for
-     * \param modelTransform an alternative model transformation matrix to use. If not
+     * \param modelTransform An alternative model transformation matrix to use. If not
      *        provided the function will calculate a new one.
-     *
-     * \return the resulting model view transformation matrix in double precision
+     * \return The resulting model view transformation matrix in double precision
      */
     glm::dmat4 calcModelViewTransform(const RenderData& data,
         std::optional<glm::dmat4> modelTransform = std::nullopt) const;
 
     /**
      * Calculates the model view projection transformation matrix with the given data and
-     * returns it
+     * returns it.
      *
-     * \param data the RenderData for the object that the model view projection
+     * \param data The RenderData for the object that the model view projection
      *        transformation matrix should be calculated for
-     * \param modelTransform an alternative model transformation matrix to use. If not
+     * \param modelTransform An alternative model transformation matrix to use. If not
      *        provided the function will calculate a new one.
-     *
-     * \return the resulting model view projection transformation matrix in double
+     * \return The resulting model view projection transformation matrix in double
      *         precision
      */
     glm::dmat4 calcModelViewProjectionTransform(const RenderData& data,
@@ -193,15 +193,14 @@ protected:
 
     /**
      * Calculates the model, model view, and the model view projection transformation
-     * matricies with the given data and returns them in a tuple object
+     * matricies with the given data and returns them in a tuple object.
      *
-     * \param data the RenderData for the object that the transforms should be
+     * \param data The RenderData for the object that the transforms should be
      *        calculated for
-     * \param altModelTransform an object containing alternative transformations to use
+     * \param altModelTransform An object containing alternative transformations to use
      *        instead of those given in data. The transforms can be translation, rotation
      *        and scale.
-     *
-     * \return a tuple object containing the resulting model, model view, and the
+     * \return A tuple object containing the resulting model, model view, and the
      *         model view projection transformation matrices
      */
     std::tuple<glm::dmat4, glm::dmat4, glm::dmat4> calcAllTransforms(
diff --git a/include/openspace/rendering/renderengine.h b/include/openspace/rendering/renderengine.h
index 9465ada77d..6905679375 100644
--- a/include/openspace/rendering/renderengine.h
+++ b/include/openspace/rendering/renderengine.h
@@ -113,7 +113,7 @@ public:
     void removeRenderProgram(ghoul::opengl::ProgramObject* program);
 
     /**
-     * Set the camera to use for rendering
+     * Set the camera to use for rendering.
      */
     void setCamera(Camera* camera);
 
@@ -130,17 +130,17 @@ public:
     void setResolveData(ghoul::Dictionary resolveData);
 
     /**
-     * Take a screenshot and store in the ${SCREENSHOTS} directory
+     * Take a screenshot and store in the ${SCREENSHOTS} directory.
      */
     void takeScreenshot();
 
     /**
-     * Resets the screenshot index to 0
+     * Resets the screenshot index to 0.
      */
     void resetScreenshotNumber();
 
     /**
-     * Get the filename of the latest screenshot
+     * Get the filename of the latest screenshot.
      */
     unsigned int latestScreenshotNumber() const;
 
diff --git a/include/openspace/rendering/screenspacerenderable.h b/include/openspace/rendering/screenspacerenderable.h
index 0d832a7b68..e2b1e0f8fd 100644
--- a/include/openspace/rendering/screenspacerenderable.h
+++ b/include/openspace/rendering/screenspacerenderable.h
@@ -44,11 +44,11 @@ namespace openspace {
 namespace documentation { struct Documentation; }
 
 /**
- * The base class for screen space images and screen space framebuffers.
- * This base class handles general functionality specific to planes that are rendered in
- * front of the camera. It implements protected methods and properties for converting
- * the planes from Spherical to Cartesian coordinates and back. It also specifies the
- * interface that its children need to implement.
+ * The base class for screen space images and screen space framebuffers. This base class
+ * handles general functionality specific to planes that are rendered in front of the
+ * camera. It implements protected methods and properties for converting the planes from
+ * Spherical to Cartesian coordinates and back. It also specifies the interface that its
+ * children need to implement.
  */
 class ScreenSpaceRenderable : public properties::PropertyOwner, public Fadeable {
 public:
diff --git a/include/openspace/rendering/volume.h b/include/openspace/rendering/volume.h
deleted file mode 100644
index d1d63778da..0000000000
--- a/include/openspace/rendering/volume.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*****************************************************************************************
- *                                                                                       *
- * OpenSpace                                                                             *
- *                                                                                       *
- * Copyright (c) 2014-2023                                                               *
- *                                                                                       *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
- * software and associated documentation files (the "Software"), to deal in the Software *
- * without restriction, including without limitation the rights to use, copy, modify,    *
- * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
- * permit persons to whom the Software is furnished to do so, subject to the following   *
- * conditions:                                                                           *
- *                                                                                       *
- * The above copyright notice and this permission notice shall be included in all copies *
- * or substantial portions of the Software.                                              *
- *                                                                                       *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
- * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
- * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
- * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
- * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
- ****************************************************************************************/
-
-#ifndef __OPENSPACE_CORE___VOLUME___H__
-#define __OPENSPACE_CORE___VOLUME___H__
-
-#include <string>
-#include <vector>
-
-namespace ghoul::opengl {
-    class Texture;
-    class ProgramObject;
-} // namespace ghoul::opengl
-
-namespace openspace {
-
-class Volume {
-public:
-    /**
-     * Constructor
-     */
-    Volume() = default;
-
-    /**
-     * Destructor
-     */
-    virtual ~Volume() = default;
-
-    /**
-     * Render the volume's entry points (front face of the bounding geometry)
-     */
-    //virtual void renderEntryPoints(const RenderData& data,
-    //    ghoul::opengl::ProgramObject* program) = 0;
-
-    /**
-     * Render the volume's exit points (back face of the bounding geometry)
-     */
-    //virtual void renderExitPoints(const RenderData& data,
-    //    ghoul::opengl::ProgramObject* program) = 0;
-
-    /**
-     * Prepare the volume for the ABuffer's resolve step.
-     * Make sure textures are up to date, bind them to texture units, set program uniforms
-     * etc.
-     */
-    //virtual void preRayCast(ghoul::opengl::ProgramObject* program) {};
-
-    /**
-     * Clean up for the volume after the ABuffer's resolve step.
-     * Make sure texture units are deinitialized, etc.
-     */
-    //virtual void postRayCast(ghoul::opengl::ProgramObject* program) {};
-
-    /**
-     * Return a path to a file with the uniforms, per-vertex variables, functions etc
-     * required to transform the vertices of the bounding geometry to view space.
-     * It could also set other vertex out variables for the fragment shader to access.
-     *
-     * The shader preprocessor will have acceess to
-     *   A #{namespace} variable (unique per helper file)
-     *
-     * Should define the function:
-     * vec4 getVertex()
-     */
-    //virtual std::string boundsVertexShaderPath() = 0;
-
-    /*
-     * Return a path to a file with the functions, uniforms and fragment shader in
-     * variables required to generate the fragment color and depth.
-     *
-     * Should define the function:
-     * Fragment getFragment()
-     *
-     * The shader preprocessor will have acceess to
-     *   A #{namespace} variable (unique per helper file)
-     */
-    //virtual std::string boundsFragmentShaderPath() = 0;
-
-    /**
-     * Return a path to a file with all the uniforms, functions etc
-     * required to perform ray casting through this volume.
-     *
-     * The header should define the following two functions:
-     *   vec4 sampler#{id}(vec3 samplePos, vec3 dir, float occludingAlpha,
-     *                     inout float maxStepSize)
-     *      (return color of sample)
-     *   float stepSize#{id}(vec3 samplePos, vec3 dir)
-     *      (return the preferred step size at this sample position)
-     *
-     * The shader preprocessor will have acceess to
-     *   An #{id} variable (unique per volume)
-     *   A #{namespace} variable (unique per helper file)
-     */
-    //virtual std::string getRayCastPath() = 0;
-
-    /**
-     * Return a path to a glsl file with helper functions required for the
-     * transformation and raycast steps.
-     * This file will be included once per shader program generated,
-     * regardless of how many volumes say they require the file.
-     * Ideal to avoid redefinitions of helper functions.
-     *
-     * The shader preprocessor will have access to the #{namespace} variable (unique per
-     * helper file) which should be a prefix to all symbols defined by the helper
-     */
-    //virtual std::string helperPath() = 0;
-
-};
-
-} // namespace openspace
-
-#endif // __OPENSPACE_CORE___VOLUME___H__
diff --git a/include/openspace/rendering/volumeraycaster.h b/include/openspace/rendering/volumeraycaster.h
index cd4163f18c..da1e7e2eea 100644
--- a/include/openspace/rendering/volumeraycaster.h
+++ b/include/openspace/rendering/volumeraycaster.h
@@ -42,87 +42,85 @@ struct RaycastData;
 class VolumeRaycaster {
 public:
     /**
-     * Destructor
+     * Destructor.
      */
     virtual ~VolumeRaycaster() = default;
 
     /**
-     * Render the volume's entry points (front face of the bounding geometry)
+     * Render the volume's entry points (front face of the bounding geometry).
      */
     virtual void renderEntryPoints(const RenderData& /*data*/,
         ghoul::opengl::ProgramObject& /*program*/) = 0;
 
     /**
-     * Render the volume's exit points (back face of the bounding geometry)
+     * Render the volume's exit points (back face of the bounding geometry).
      */
     virtual void renderExitPoints(const RenderData& /*data*/,
         ghoul::opengl::ProgramObject& /*program*/) = 0;
 
     /**
-     * Prepare the volume for the ABuffer's resolve step.
-     * Make sure textures are up to date, bind them to texture units, set program uniforms
-     * etc.
+     * Prepare the volume for the ABuffer's resolve step. Make sure textures are up to
+     * date, bind them to texture units, set program uniforms etc.
      */
     virtual void preRaycast(const RaycastData& data,
         ghoul::opengl::ProgramObject& program);
 
     /**
-     * Clean up for the volume after the ABuffer's resolve step.
-     * Make sure texture units are deinitialized, etc.
+     * Clean up for the volume after the ABuffer's resolve step. Make sure texture units
+     * are deinitialized, etc.
      */
     virtual void postRaycast(const RaycastData& data,
         ghoul::opengl::ProgramObject& program);
 
     /**
-    * Return true if the camera is inside the volume.
-    * Also set localPosition to the camera position in the volume's local coordinate
-    * system.
-    */
+     * Return true if the camera is inside the volume. Also set localPosition to the
+     * camera position in the volume's local coordinate system.
+     */
     virtual bool isCameraInside(const RenderData& data, glm::vec3& localPosition);
 
     /**
-     * Return a path the file to use as vertex shader
+     * Return a path the file to use as vertex shader.
      *
-     * The shader preprocessor will have acceess to
-     *   A #{namespace} variable (unique per helper file)
+     * The shader preprocessor will have access to:
+     *   - A `#{namespace}` variable (unique per helper file)
      */
     virtual std::string boundsVertexShaderPath() const = 0;
 
-    /*
+    /**
      * Return a path to a file with the functions, uniforms and fragment shader in
      * variables required to generate the fragment color and depth.
      *
-     * Should define the function:
-     * Fragment getFragment()
+     * Should define the function: `Fragment getFragment()`
      *
-     * The shader preprocessor will have acceess to
-     *   A #{namespace} variable (unique per helper file)
+     * The shader preprocessor will have access to:
+     *   - A `#{namespace}` variable (unique per helper file)
      */
     virtual std::string boundsFragmentShaderPath() const = 0;
 
     /**
-     * Return a path to a file with all the uniforms, functions etc
-     * required to perform ray casting through this volume.
+     * Return a path to a file with all the uniforms, functions, etc. Required to perform
+     * ray casting through this volume.
      *
      * The header should define the following two functions:
+     * ```
      *   vec4 sample#{id}(vec3 samplePos, vec3 dir, float occludingAlpha,
      *                    inout float maxStepSize)
      *      (return color of sample)
      *   float stepSize#{id}(vec3 samplePos, vec3 dir)
      *      (return the preferred step size at this sample position)
+     * ```
      *
-     * The shader preprocessor will have acceess to
-     *   An #{id} variable (unique per volume)
-     *   A #{namespace} variable (unique per helper file)
+     * The shader preprocessor will have access to:
+     *   - An #{id} variable (unique per volume)
+     *   - A #{namespace} variable (unique per helper file)
      */
     virtual std::string raycasterPath() const = 0;
 
     /**
-     * Return a path to a glsl file with helper functions required for the
-     * transformation and raycast steps.
-     * This file will be included once per shader program generated,
-     * regardless of how many volumes say they require the file.
-     * Ideal to avoid redefinitions of helper functions.
+     * Return a path to a glsl file with helper functions required for the transformation
+     * and raycast steps. This file will be included once per shader program generated,
+     * regardless of how many volumes say they require the file. Ideal to avoid
+     * redefinitions of helper functions.
      *
      * The shader preprocessor will have access to the #{namespace} variable (unique per
      * helper file) which should be a prefix to all symbols defined by the helper
diff --git a/include/openspace/scene/asset.h b/include/openspace/scene/asset.h
index 9d2841c51a..164419746a 100644
--- a/include/openspace/scene/asset.h
+++ b/include/openspace/scene/asset.h
@@ -41,15 +41,16 @@ class AssetManager;
  * 0-* number of other Assets that this Asset requires (through the `require` function in
  * Lua. There also is a list of requiring assets that contain all assets which require
  * this asset.
+ *
  * An asset goes through three external states. Starting out as unloaded when the instance
  * is newly created but the file has not been processed. In this case the #isLoaded,
  * #isSynchronized and the #isInitialized functions all return `false`. After the asset
- * has been loaded it is in the `Loaded` state (#isLoaded = true,
- * #isSynchronized = false, #isInitialized = false). After all registered synchronizations
- * finish successfully, the Asset transitions into the Synchronized state
- * (#isLoaded = true, #isSynchronized = true, #isInitialized = false) and after the final
- * initialization step, the asset is initialized (#isLoaded = true,
- * #isSynchronized = true and #isInitialized = true)
+ * has been loaded it is in the `Loaded` state (#isLoaded = true, #isSynchronized = false,
+ * #isInitialized = false). After all registered synchronizations finish successfully, the
+ * Asset transitions into the Synchronized state (#isLoaded = true,
+ * #isSynchronized = true, #isInitialized = false) and after the final initialization
+ * step, the asset is initialized (#isLoaded = true, #isSynchronized = true and
+ * #isInitialized = true)
  */
 class Asset {
 public:
@@ -109,21 +110,22 @@ public:
     /**
      * Updates the state of this Asset based on the latest synchronization being
      * successfully resolved. Depending on the sum state of all registered
-     * synchronizations this Asset's state changes to successfully Synchronized, or Failed
+     * synchronizations this Asset's state changes to successfully Synchronized, or
+     * Failed.
      */
     void setSynchronizationStateResolved();
 
     /**
      * Updates the state of this Asset based on the latest synchronization being rejected.
      * Depending on the sum state of all registered synchronizations this Asset's state
-     * changes to successfully Synchronized, or Failed
+     * changes to successfully Synchronized, or Failed.
      */
     void setSynchronizationStateRejected();
 
 
     /**
-     * Register a SceneGraphNodeIdentifier with the asset
-     * (used to associate Nodes with asset meta)
+     * Register a SceneGraphNodeIdentifier with the asset (used to associate Nodes with
+     * asset meta).
      */
     void addIdentifier(std::string identifier);
 
@@ -213,10 +215,11 @@ public:
     void deinitialize();
 
     /**
-     * Marks the passed \p child as being required by \p this Asset. If the \p child is
+     * Marks the passed \p child as being required by this Asset. If the \p child is
      * already required by this asset, this function does nothing.
      *
      * \param child The asset that is required by this asset
+     *
      * \pre \p child must not be nullptr
      */
     void require(Asset* child);
@@ -296,12 +299,16 @@ private:
      */
     void setState(State state);
 
-    /// Returns whether the Asset is synchronizing or has successfully synchronized
+    /**
+     * Returns whether the Asset is synchronizing or has successfully synchronized.
+     */
     bool isSyncingOrResolved() const;
 
-    /// Returns whether the Asset has been successfully synchronized, meaning that both
-    /// its own resource synchronizations are finished as well as all requiered assets are
-    /// finished synchronizing
+    /**
+     * Returns whether the Asset has been successfully synchronized, meaning that both its
+     * own resource synchronizations are finished as well as all requiered assets are
+     * finished synchronizing.
+     */
     bool isSyncResolveReady() const;
 
     /// The state that this Asset is currently in
diff --git a/include/openspace/scene/assetmanager.h b/include/openspace/scene/assetmanager.h
index 6343d07653..2bf660e95c 100644
--- a/include/openspace/scene/assetmanager.h
+++ b/include/openspace/scene/assetmanager.h
@@ -43,6 +43,7 @@ class ResourceSynchronization;
  * loaded in OpenSpace. Most actions of this class are operating in a two-step process
  * where first the intent of an action is registered, which is then executed in the next
  * call to the #update function.
+ *
  * All assets are loading through the same Lua state.
  */
 class AssetManager {
@@ -120,6 +121,7 @@ public:
      * \param asset The asset that should be loaded
      * \param parent The parent of the loaded asset file or `nullptr` if the asset is a
      *        root asset
+     *
      * \pre \p asset must not be a nullptr
      */
     bool loadAsset(Asset* asset, Asset* parent);
@@ -130,6 +132,7 @@ public:
      * will not actually get destroyed until the next #update call to the AssetManager.
      *
      * \param asset The asset that should get unloaded
+     *
      * \pre \p asset must not be a nullptr
      */
     void unloadAsset(Asset* asset);
@@ -151,21 +154,29 @@ public:
     void callOnDeinitialize(Asset* asset) const;
 
 private:
-    /// Creates and registers all of the callback functions that the asset is expected to
-    /// call in the file, for example the `localResource`, `require`, etc.
+    /**
+     * Creates and registers all of the callback functions that the asset is expected to
+     * call in the file, for example the `localResource`, `require`, etc.
+     */
     void setUpAssetLuaTable(Asset* asset);
 
-    /// Returns the loaded Asset by either trying to load the asset at the provided path
-    /// or returning a previously loaded copy
+    /**
+     * Returns the loaded Asset by either trying to load the asset at the provided path
+     * or returning a previously loaded copy.
+     */
     Asset* retrieveAsset(const std::filesystem::path& path,
         const std::filesystem::path& retriever,
         std::optional<bool> explicitEnable = std::nullopt);
 
-    /// Setup the asset table of the provided asset in the shared Lua state
+    /**
+     * Setup the asset table of the provided asset in the shared Lua state.
+     */
     void setCurrentAsset(Asset* asset);
 
-    /// Takes the asset path, determines the type of path (relative to base, relative to
-    /// root or absolute and returns fully formed path
+    /**
+     * Takes the asset path, determines the type of path (relative to base, relative to
+     * root or absolute and returns fully formed path.
+     */
     std::filesystem::path generateAssetPath(const std::filesystem::path& baseDirectory,
         const std::string& assetPath) const;
 
@@ -204,6 +215,7 @@ private:
     /// Authoritative list over all ResourceSynchronizations that have been requested by
     /// any asset
     std::unordered_map<std::string, std::unique_ptr<SyncItem>> _synchronizations;
+
     /// The list of ResourceSynchronizations that were not finished in the last update
     /// call
     std::vector<SyncItem*> _unfinishedSynchronizations;
diff --git a/include/openspace/scene/profile.h b/include/openspace/scene/profile.h
index c1dbdeca07..436dafa67b 100644
--- a/include/openspace/scene/profile.h
+++ b/include/openspace/scene/profile.h
@@ -147,8 +147,10 @@ public:
     void saveCurrentSettingsToProfile(const properties::PropertyOwner& rootOwner,
         std::string currentTime, interaction::NavigationState navState);
 
-    /// Adds a new asset and checks for duplicates unless the `ignoreUpdates` member is
-    /// set to `true`
+    /**
+     * Adds a new asset and checks for duplicates unless the `ignoreUpdates` member is
+     * set to `true`.
+     */
     void addAsset(const std::string& path);
 
     /// Removes an asset unless the `ignoreUpdates` member is set to `true`
@@ -174,6 +176,7 @@ public:
     /**
      * Returns the Lua library that contains all Lua functions available to provide
      * profile functionality.
+     *
      * \return The Lua library that contains all Lua functions available for profiles
      */
     static scripting::LuaLibrary luaLibrary();
diff --git a/include/openspace/scene/scene.h b/include/openspace/scene/scene.h
index f6c6bd6fc6..7aed9df083 100644
--- a/include/openspace/scene/scene.h
+++ b/include/openspace/scene/scene.h
@@ -69,39 +69,41 @@ public:
         /**
          * \param msg The reason that caused this exception to be thrown
          * \param comp The optional compoment that caused this exception to be thrown
+         *
          * \pre message may not be empty
          */
         explicit InvalidSceneError(std::string msg, std::string comp = "");
     };
 
-    /// This struct describes a time that has some intrinsic interesting-ness to this
-    /// scene.
+    /**
+     * This struct describes a time that has some intrinsic interesting-ness to this
+     * scene.
+     */
     struct InterestingTime {
         std::string name;
         std::string time;
     };
 
-    // constructors & destructor
     Scene(std::unique_ptr<SceneInitializer> initializer);
     virtual ~Scene() override;
 
     /**
-     * Attach node to the root
+     * Attach node to the root.
      */
     void attachNode(ghoul::mm_unique_ptr<SceneGraphNode> node);
 
     /**
-     * Detach node from the root
+     * Detach node from the root.
      */
     ghoul::mm_unique_ptr<SceneGraphNode> detachNode(SceneGraphNode& node);
 
     /**
-     * Return the camera
+     * Return the camera.
      */
     Camera* camera() const;
 
     /**
-     * Updates all SceneGraphNodes relative positions
+     * Updates all SceneGraphNodes relative positions.
      */
     void update(const UpdateData& data);
 
@@ -121,8 +123,8 @@ public:
     const SceneGraphNode* root() const;
 
     /**
-     * Return the scenegraph node with the specified name or `nullptr` if that
-     * name does not exist.
+     * Return the scenegraph node with the specified name or `nullptr` if that name does
+     * not exist.
      */
     SceneGraphNode* sceneGraphNode(const std::string& name) const;
 
@@ -137,7 +139,7 @@ public:
     void unregisterNode(SceneGraphNode* node);
 
     /**
-     * Mark the node registry as dirty
+     * Mark the node registry as dirty.
      */
     void markNodeRegistryDirty();
 
@@ -162,7 +164,7 @@ public:
     void initializeNode(SceneGraphNode* node);
 
     /**
-     * Return true if the scene is initializing
+     * Return true if the scene is initializing.
      */
     bool isInitializing() const;
 
@@ -191,7 +193,7 @@ public:
 
     /**
      * Removes the passed \p prop from the list of Property%s that are update each time
-     * the #updateInterpolations method is called
+     * the #updateInterpolations method is called.
      *
      * \param prop The Property that should not longer be updated
      *
@@ -232,16 +234,17 @@ public:
     /**
      * Returns the Lua library that contains all Lua functions available to change the
      * scene graph.
+     *
      * \return The Lua library that contains all Lua functions available to change the
-     * scene graph
+     *         scene graph
      */
     static scripting::LuaLibrary luaLibrary();
 
     /**
      * Sets a property using the 'properties' contents of a profile. The function will
-     * loop through each setProperty command. A property may be set to a bool, float,
-     * or string value (which must be converted because a Profile stores all values
-     * as strings)
+     * loop through each setProperty command. A property may be set to a bool, float, or
+     * string value (which must be converted because a Profile stores all values as
+     * strings).
      *
      * \param p The Profile to be read.
      */
@@ -251,7 +254,7 @@ public:
      * Searches for any properties that match the regex propertyString, and returns
      * the results in a vector.
      *
-     * \param propertyString the regex string that is intended to match one or more
+     * \param propertyString The regex string that is intended to match one or more
      *        properties in the currently-available properties
      * \return Vector of Property objs containing property names that matched the regex
      */
@@ -268,19 +271,19 @@ public:
 private:
     /**
      * Accepts string version of a property value from a profile, converts it to the
-     * appropriate type, and then pushes the value onto the lua state.
+     * appropriate type, and then pushes the value onto the Lua state.
      *
-     * \param L the lua state to push value to
-     * \param value string representation of the value with which to set property
+     * \param L The Lua state to push value to
+     * \param value String representation of the value with which to set property
      */
     void propertyPushProfileValueToLua(ghoul::lua::LuaState& L, const std::string& value);
 
     /**
      * Accepts string version of a property value from a profile, and processes it
-     * according to the data type of the value
+     * according to the data type of the value.
      *
-     * \param L the lua state to (eventually) push to
-     * \param value string representation of the value with which to set property
+     * \param L The Lua state to (eventually) push to
+     * \param value String representation of the value with which to set property
      * \return The ProfilePropertyLua variant type translated from string representation
      */
     ProfilePropertyLua propertyProcessValue(ghoul::lua::LuaState& L,
@@ -288,31 +291,31 @@ private:
 
     /**
      * Accepts string version of a property value from a profile, and returns the
-     * supported data types that can be pushed to a lua state. Currently, the full
-     * range of possible lua values is not supported.
+     * supported data types that can be pushed to a Lua state. Currently, the full range
+     * of possible Lua values is not supported.
      *
-     * \param value string representation of the value with which to set property
+     * \param value String representation of the value with which to set property
      */
     PropertyValueType propertyValueType(const std::string& value);
 
     /**
      * Accepts string version of a property value from a profile, and adds it to a vector
-     * which will later be used to push as a lua table containing values of type T
+     * which will later be used to push as a Lua table containing values of type T
      *
-     * \param L the lua state to (eventually) push to
-     * \param value string representation of the value with which to set property
-     * \param table the std::vector container which has elements of type T for a lua table
+     * \param L The Lua state to (eventually) push to
+     * \param value String representation of the value with which to set property
+     * \param table The std::vector container which has elements of type T for a Lua table
      */
     template <typename T>
     void processPropertyValueTableEntries(ghoul::lua::LuaState& L,
         const std::string& value, std::vector<T>& table);
 
     /**
-     * Handles a lua table entry, creating a vector of the correct variable type based
-     * on the profile string, and pushes this vector to the lua stack.
+     * Handles a Lua table entry, creating a vector of the correct variable type based
+     * on the profile string, and pushes this vector to the Lua stack.
      *
-     * \param L the lua state to (eventually) push to
-     * \param value string representation of the value with which to set property
+     * \param L The Lua state to (eventually) push to
+     * \param value String representation of the value with which to set property
      */
     void handlePropertyLuaTableEntry(ghoul::lua::LuaState& L, const std::string& value);
 
diff --git a/include/openspace/scripting/lualibrary.h b/include/openspace/scripting/lualibrary.h
index 03427c595b..7e2fff2241 100644
--- a/include/openspace/scripting/lualibrary.h
+++ b/include/openspace/scripting/lualibrary.h
@@ -33,15 +33,15 @@
 namespace openspace::scripting {
 
 /**
- * This structure represents a Lua library, itself consisting of a unique #name and
- * an arbitrary number of #functions
+ * This structure represents a Lua library, itself consisting of a unique #name and an
+ * arbitrary number of #functions.
  */
 struct LuaLibrary {
     /**
-    * This structure represents a Lua function with its #name, #function pointer
-    * #arguments describe the arguments this function takes, and the #helpText describing
-    * the function.
-    */
+     * This structure represents a Lua function with its #name, #function pointer
+     * #arguments describe the arguments this function takes, and the #helpText describing
+     * the function.
+     */
     struct Function {
         /// The name of the function
         std::string name;
diff --git a/include/openspace/scripting/scriptengine.h b/include/openspace/scripting/scriptengine.h
index 65e6703fe9..d8ebac7f97 100644
--- a/include/openspace/scripting/scriptengine.h
+++ b/include/openspace/scripting/scriptengine.h
@@ -44,9 +44,9 @@ namespace openspace::scripting {
  * The ScriptEngine is responsible for handling the execution of custom Lua functions and
  * executing scripts (#runScript and #runScriptFile). Before usage, it has to be
  * #initialize%d and #deinitialize%d. New ScriptEngine::Library%s consisting of
- * ScriptEngine::Library::Function%s have to be added which can then be called using the
- * `openspace` namespace prefix in Lua. The same functions can be exposed to
- * other Lua states by passing them to the #initializeLuaState method.
+ * Library::Function%s have to be added which can then be called using the
+ * `openspace` namespace prefix in Lua. The same functions can be exposed to other Lua
+ * states by passing them to the #initializeLuaState method.
  */
 class ScriptEngine : public Syncable {
 public:
@@ -66,7 +66,8 @@ public:
     ScriptEngine();
 
     /**
-     * Initializes the internal Lua state and registers a common set of library functions
+     * Initializes the internal Lua state and registers a common set of library functions.
+     *
      * \throw LuaRuntimeException If the creation of the new Lua state fails
      */
     void initialize();
diff --git a/include/openspace/scripting/scriptscheduler.h b/include/openspace/scripting/scriptscheduler.h
index 8c6d9a70f5..76b26c3710 100644
--- a/include/openspace/scripting/scriptscheduler.h
+++ b/include/openspace/scripting/scriptscheduler.h
@@ -45,8 +45,8 @@ namespace openspace::scripting {
 struct LuaLibrary;
 
 /**
- * Maintains an ordered list of `ScheduledScript`s and provides a simple
- * interface for retrieveing scheduled scripts
+ * Maintains an ordered list of `ScheduledScript`s and provides a simple interface for
+ * retrieveing scheduled scripts.
  */
 class ScriptScheduler : public properties::PropertyOwner {
 public:
@@ -69,8 +69,9 @@ public:
      * ScheduledScript%s to the list of stored scripts.
      *
      * \param scheduledScripts The scripts that should be loaded
+     *
      * \throw SpecificationError If the dictionary does not adhere to the Documentation as
-     * specified in the openspace::Documentation function
+     *        specified in the openspace::Documentation function
      */
     void loadScripts(std::vector<ScheduledScript> scheduledScripts);
 
@@ -84,51 +85,48 @@ public:
      * Removes all scripts for the schedule.
      *
      * \param group An int that specifies which group to clear. If none given then all
-     *              scripts
-     *        is cleared from the schedule.
+     *              scripts are cleared from the schedule
      */
     void clearSchedule(std::optional<int> group = std::nullopt);
 
     /**
-    * Progresses the script schedulers time and returns all scripts that has been
-    * scheduled to run between \p newTime and the time provided in the last invocation
-    * of this method.
-    *
-    * \param newTime A j2000 time value specifying the new time stamp that
-    * the script scheduler should progress to.
-    *
-    * \returns vector with the scheduled scripts that should be run from begining to end.
-    */
+     * Progresses the script schedulers time and returns all scripts that has been
+     * scheduled to run between \p newTime and the time provided in the last invocation
+     * of this method.
+     *
+     * \param newTime A j2000 time value specifying the new time stamp that the script
+     *        scheduler should progress to.
+     * \return vector with the scheduled scripts that should be run from begining to end
+     */
     std::vector<std::string> progressTo(double newTime);
 
     /**
-     * Returns the the j2000 time value that the script scheduler is currently at
+     * Returns the the j2000 time value that the script scheduler is currently at.
      */
     double currentTime() const;
 
     /**
-     * Updates the current time to the given j2000 time value
+     * Updates the current time to the given J2000 time value.
      */
     void setCurrentTime(double time);
 
     /**
-    * Function that returns all scripts currently loaded in the script scheduler
-    *
-    * \param group An int specifying which group to return, if empty all scripts
-    *              will be returned
-    *
-    * \returns a vector of all scripts that has been loaded
-    */
+     * Function that returns all scripts currently loaded in the script scheduler.
+     *
+     * \param group An int specifying which group to return, if empty all scripts
+     *              will be returned
+     * \return a vector of all scripts that has been loaded
+     */
     std::vector<ScheduledScript> allScripts(
         std::optional<int> group = std::nullopt) const;
 
     /**
-    * Sets the mode for how each scheduled script's timestamp will be interpreted.
-    * \param refType reference mode (for exact syntax, see definition of
-    * openspace::interaction::KeyframeTimeRef) which is either relative to the
-    * application start time, relative to the recorded session playback start time,
-    * or according to the absolute simulation time in seconds from J2000 epoch.
-    */
+     * Sets the mode for how each scheduled script's timestamp will be interpreted.
+     * \param refType reference mode (for exact syntax, see definition of
+     * interaction::KeyframeTimeRef) which is either relative to the application start
+     * time, relative to the recorded session playback start time, or according to the
+     * absolute simulation time in seconds from J2000 epoch.
+     */
     void setTimeReferenceMode(openspace::interaction::KeyframeTimeRef refType);
 
     static LuaLibrary luaLibrary();
diff --git a/include/openspace/util/collisionhelper.h b/include/openspace/util/collisionhelper.h
index 166c7767d5..2cf906211d 100644
--- a/include/openspace/util/collisionhelper.h
+++ b/include/openspace/util/collisionhelper.h
@@ -29,11 +29,11 @@
 
 namespace openspace::collision {
 
-/*
- * Calculate the intersection of a line segment and a sphere.
- * The line segment is defined from \p p1 to \p p2.
- * The sphere is defined by the radius \p r and center point \p center.
- * The resulting intersection point is stored in the \p intersectionPoint parameter.
+/**
+ * Calculate the intersection of a line segment and a sphere. The line segment is defined
+ * from \p p1 to \p p2. The sphere is defined by the radius \p r and center point
+ * \p center. The resulting intersection point is stored in the \p intersectionPoint
+ * parameter.
  *
  * In the case of two intersection points, only care about the first one.
  *
@@ -48,7 +48,7 @@ namespace openspace::collision {
 bool lineSphereIntersection(glm::dvec3 p1, glm::dvec3 p2, glm::dvec3 center,
     double r, glm::dvec3& intersectionPoint);
 
-/*
+/**
  * Check if the point \p p is inside of the sphere defined by radius \p r and center
  * point \p c
  */
diff --git a/include/openspace/util/concurrentjobmanager.h b/include/openspace/util/concurrentjobmanager.h
index 32dacfa3cf..ee92a92038 100644
--- a/include/openspace/util/concurrentjobmanager.h
+++ b/include/openspace/util/concurrentjobmanager.h
@@ -34,9 +34,9 @@ namespace openspace {
 
 template <typename T> struct Job;
 
-/*
+/**
  * Templated Concurrent Job Manager
- * This class is used execute specific jobs on one (1) parallell thread
+ * This class is used execute specific jobs on one (1) parallel thread
  */
 template<typename P>
 class ConcurrentJobManager {
diff --git a/include/openspace/util/concurrentqueue.h b/include/openspace/util/concurrentqueue.h
index ded68bcc66..86f2345169 100644
--- a/include/openspace/util/concurrentqueue.h
+++ b/include/openspace/util/concurrentqueue.h
@@ -32,7 +32,7 @@
 namespace openspace {
 
 /**
- * Templated thread-safe queue based on std::thread and std::queue
+ * Templated thread-safe queue based on std::thread and std::queue.
  */
 template <typename T>
 class ConcurrentQueue {
diff --git a/include/openspace/util/coordinateconversion.h b/include/openspace/util/coordinateconversion.h
index 56d50ddf4c..66e07a6dbc 100644
--- a/include/openspace/util/coordinateconversion.h
+++ b/include/openspace/util/coordinateconversion.h
@@ -32,16 +32,18 @@ namespace openspace {
 
 /**
  * Converts from ICRS decimal degrees coordinates to galactic cartesian coordinates.
+ *
  * \param ra Right ascension, given in decimal degrees
  * \param dec Declination, given in decimal degrees
- * \param distance The distance, or radius, to the position given in any unit.
+ * \param distance The distance, or radius, to the position given in any unit
  * \return A position in galactic cartesian coordinates, given in the same unit as the
- *         distance parameter.
+ *         distance parameter
  */
 glm::dvec3 icrsToGalacticCartesian(double ra, double dec, double distance);
 
 /**
  * Converts from ICRS (hms and dms) coordinates to decimal degrees.
+ *
  * \param ra Right ascension, given as a string in format 'XhYmZs'
  * \param dec Declination, given as a string in format 'XdYmZs'
  * \return The decimal degrees coordinate in degrees
@@ -51,18 +53,18 @@ glm::dvec2 icrsToDecimalDegrees(const std::string& ra, const std::string& dec);
 /**
  * Converts from galactic cartesian coordinates to ICRS decimal degrees coordinates
  * and distance.
- * \param x X coordinate
- * \param y Y coordinate
- * \param z Z coordinate
- * \return A vector with the ra and dec decimal degrees in degrees and distance.
+ *
+ * \param x, y, z X, Y, and Z coordinates
+ * \return A vector with the ra and dec decimal degrees in degrees and distance
  */
 glm::dvec3 galacticCartesianToIcrs(double x, double y, double z);
 
 /**
  * Converts from ICRS decimal degrees coordinates to ICRS hms and dms coordinates.
+ *
  * \param ra Right ascension, given in decimal degrees
  * \param dec Declination, given in decimal degrees
- * \return A pair with the ra and dec strings in hms and dms format.
+ * \return A pair with the ra and dec strings in hms and dms format
  */
 std::pair<std::string, std::string> decimalDegreesToIcrs(double ra, double dec);
 
diff --git a/include/openspace/util/factorymanager.h b/include/openspace/util/factorymanager.h
index fcf8ef7eac..d16c4c9e6b 100644
--- a/include/openspace/util/factorymanager.h
+++ b/include/openspace/util/factorymanager.h
@@ -39,13 +39,16 @@ namespace openspace {
  */
 class FactoryManager {
 public:
-    /// This exception is thrown if the ghoul::TemplateFactory could not be found in the
-    /// #factory method
+    /**
+     * This exception is thrown if the ghoul::TemplateFactory could not be found in the
+     * #factory method.
+     */
     struct FactoryNotFoundError : public ghoul::RuntimeError {
         /**
          * Constructor for FactoryNotFoundError, the \p type is a human-readable (-ish)
          * type descriptor for the type `T` for the TemplateFactory that could
          * not be found.
+         *
          * \param t The type `T` for the `TemplateFactory<T>` that could not be found
          * \pre \p t must not be empty
          */
@@ -60,36 +63,41 @@ public:
     /**
      * Static initializer that initializes the static member. This needs to be done before
      * the FactoryManager can be used.
+     *
      * \pre The FactoryManager must not have been initialized before
      */
     static void initialize();
 
     /**
      * Deinitializes the static member and all the registered ghoul::TemplateFactory%s.
+     *
      * \pre The FactoryManager must have been initialized before
      */
     static void deinitialize();
 
     /**
-     * Returns `true` if the static FactoryManager has already been
-     * initiailzed, `false` otherwise.
+     * Returns `true` if the static FactoryManager has already been initialized, `false`
+     * otherwise.
+     *
      * \return The initialization status of the static FactoryManager
      */
     static bool isInitialized();
 
     /**
      * This method returns a reference to the initialized FactoryManager.
+     *
      * \return An initialized reference to the singleton manager
+     *
      * \pre The FactoryManager must have been initialized before
      */
     static FactoryManager& ref();
 
     /**
      * Adds the passed \p factory to the FactoryManager. Factories may only be added once.
-     * \param name A user-readable name for the registered factory.
      *
      * \tparam Factory The type for which a factory should be created and added
-     *
+     * \param name A user-readable name for the registered factory
+     *     *
      * \pre \p name must not be empty
      */
     template <typename T>
@@ -99,10 +107,12 @@ public:
      * This method provides access to all registered ghoul::TemplateFactory%s through
      * their type. The method will always return a proper ghoul::TemplateFactory or throw
      * an error if the appropriate ghoul::TemplateFactory was not registered.
+     *
      * \tparam T The type that the requested ghoul::TemplateFactory should create
      * \return The ghoul::TemplateFactory that will create the pass type `T`
+     *
      * \throw FactoryNotFoundError If the requested ghoul::TemplateFactory could not be
-     * found
+     *        found
      */
     template <class T>
     ghoul::TemplateFactory<T>* factory() const;
diff --git a/include/openspace/util/histogram.h b/include/openspace/util/histogram.h
index 4ce1fb2c5f..784f3b553f 100644
--- a/include/openspace/util/histogram.h
+++ b/include/openspace/util/histogram.h
@@ -44,14 +44,12 @@ public:
     bool isValid() const;
 
     /**
-     * Enter value into the histogram. The add method takes the given
-     * value, works out which bin this corresponds to, and increments
-     * this bin by 'repeat'.
+     * Enter value into the histogram. The add method takes the given value, works out
+     * which bin this corresponds to, and increments this bin by 'repeat'.
      *
-     * @param value The Value to insert into the histogram
-     * @param repeat How many times you want to insert it
-     *
-     * @return Returns true if succesful insertion, otherwise return false
+     * \param value The Value to insert into the histogram
+     * \param repeat How many times you want to insert it
+     * \return Returns `true` if succesful insertion, otherwise return `false`
      */
     bool add(float value, float repeat = 1.0f);
     bool add(const Histogram& histogram);
diff --git a/include/openspace/util/httprequest.h b/include/openspace/util/httprequest.h
index 0fc5c4c03a..026f544398 100644
--- a/include/openspace/util/httprequest.h
+++ b/include/openspace/util/httprequest.h
@@ -43,14 +43,14 @@ namespace openspace {
  * This class performs a synchronous HTTP request to the provided URL. Any result that is
  * returned based on this request is returned through three callback functions that can be
  * registered using the #onHeader, #onProgress, and #onData functions. Calling these
- * functions will overwrite any previously registered handler.
- * The ProgressCallback can be used to stop the download if the handler returns `false`.
+ * functions will overwrite any previously registered handler. The ProgressCallback can be
+ * used to stop the download if the handler returns `false`.
  *
  * The workflow for this class:
- * 1. Create a new object with the URL that points to the location from which the data
- *    should be loaded
- * 2. Register the callbacks that are needed (at least the #onData callback)
- * 3. Start the download with the #perform function
+ *   1. Create a new object with the URL that points to the location from which the data
+ *      should be loaded
+ *   2. Register the callbacks that are needed (at least the #onData callback)
+ *   3. Start the download with the #perform function
  */
 class HttpRequest {
 public:
@@ -77,8 +77,8 @@ public:
      * that have arrived. The buffer pointed to will most likely only be valid during the
      * time of the callback and it is the callbacks responsibility to store the contents
      * of the buffer before the callback returns. If the return value is `true`, the
-     * download continues, if it is `false`, this signals to the library that an error
-     * has occurred from which recovery is not possible.
+     * download continues, if it is `false`, this signals to the library that an error has
+     * occurred from which recovery is not possible.
      *
      * \param buffer The pointer to the beginning of the buffer where the new incoming
      *        data is located. This buffer is only valid during the execution of this
@@ -95,9 +95,9 @@ public:
      * for the response. The buffer pointed to will most likely only be valid during the
      * time of the callback and it is the callbacks responsibility to store the contents
      * of the buffer before the callback returns. If the return value is `true`, the
-     * download continues, if it is `false`, this signals to the library that an error
-     * has occurred from which recovery is not possible. If this function returns
-     * `false`, it will cause the main download to not start at all.
+     * download continues, if it is `false`, this signals to the library that an error has
+     * occurred from which recovery is not possible. If this function returns `false`, it
+     * will cause the main download to not start at all.
      *
      * \param buffer The pointer to the beginning of the buffer where the header
      *        information is located. This buffer is only valid during the execution of
@@ -164,7 +164,6 @@ public:
      * \param timeout The amount of time the request will wait before aborting due to the
      *        server not responding. If this value is 0, there is no timeout on the
      *        request.
-     *
      * \return `true` if the request completed successfully, `false` otherwise
      */
     bool perform(std::chrono::milliseconds timeout = std::chrono::milliseconds(0));
@@ -287,13 +286,12 @@ protected:
      * pointed to will most likely only be valid during the time of the callback and it is
      * the callbacks responsibility to store the contents of the buffer before the
      * callback returns. If the return value is `true`, the download continues, if it is
-     * `false`, this signals to the library that an error has occurred from which
-     * recovery is not possible. This function will be called on a different thread from
-     * the one that called the #start method.
+     * `false`, this signals to the library that an error has occurred from which recovery
+     * is not possible. This function will be called on a different thread from the one
+     * that called the #start method.
      *
      * \param buffer The beginning of the buffer of this chunk of data
      * \param size The number of bytes that the \p buffer contains
-     *
      * \return The implementation should return `true` if the downloading should continue
      *         and `false` if the handling of the data caused some error that the
      *         subclass is incapable of recovering from
@@ -303,8 +301,8 @@ protected:
     /**
      * This function is called before the downloading starts and can be used by subclasses
      * to perform one-time setup functions, such as opening a file, reserving a block of
-     * storage, etc. This function guaranteed to be only called once per HttpDownload.
-     * The return value determines if the setup operation completed successfully or if an
+     * storage, etc. This function guaranteed to be only called once per HttpDownload. The
+     * return value determines if the setup operation completed successfully or if an
      * error occurred that will cause the download to be terminated. This function will be
      * called on a different thread from the one that called the #start method.
      *
@@ -386,15 +384,21 @@ public:
     std::filesystem::path destination() const;
 
 private:
-    /// Will create all directories that are necessary to reach _destination and then
-    /// fight with other HttpFileDownloads to get one of a limited number of file handles
-    /// to open _file
+    /**
+     * Will create all directories that are necessary to reach _destination and then
+     * fight with other HttpFileDownloads to get one of a limited number of file handles
+     * to open _file.
+     */
     bool setup() override;
 
-    /// Closes the _file and returns the handle back to the pool of available handles
+    /**
+     * Closes the _file and returns the handle back to the pool of available handles.
+     */
     bool teardown() override;
 
-    /// Stores the chunk of data into the _file handle
+    /**
+     * Stores the chunk of data into the _file handle.
+     */
     bool handleData(char* buffer, size_t size) override;
 
     /// A flag whether this HttpFileDownload got a handle from the limited supply of
@@ -402,7 +406,7 @@ private:
     /// handles from the operating system as that resource is limited and downloads would
     /// fail unrecoverably if no handles are available. So we limit the maximum number and
     /// if that number is exceeded, the HttpFileDownload will wait until a handle is
-    /// available.
+    /// available
     std::atomic_bool _hasHandle = false;
 
     /// The destination path where the contents of the URL provided in the constructor
@@ -433,7 +437,7 @@ class HttpMemoryDownload : public HttpDownload {
 public:
     /**
      * Creates an instance of a HttpMemoryDownload that will download the contents of the
-     * \p url into memory
+     * \p url into memory.
      *
      * \param url The URL whose contents should be downloaded
      */
@@ -449,15 +453,17 @@ public:
      * Returns a reference to the buffer that is used to store the contents of the URL
      * passed in the constructor. Please observe that while the HttpDownload::hasFinished
      * method returns `false`, this buffer will be changed by a different thread and
-     * access is not thread-safe. After that function returns `true`, it is safe to
-     * access the buffer.
+     * access is not thread-safe. After that function returns `true`, it is safe to access
+     * the buffer.
      *
      * \return A reference to the buffer used to hold the contents of the URL
      */
     const std::vector<char>& downloadedData() const;
 
 private:
-    /// Stores each downloaded chunk into the stored buffer
+    /**
+     * Stores each downloaded chunk into the stored buffer.
+     */
     bool handleData(char* buffer, size_t size) override;
 
     /// The buffer where the downloaded chunks are accumulated
diff --git a/include/openspace/util/job.h b/include/openspace/util/job.h
index ba7da7c906..13dc5fcc06 100644
--- a/include/openspace/util/job.h
+++ b/include/openspace/util/job.h
@@ -29,8 +29,10 @@
 
 namespace openspace {
 
-// Templated abstract base class representing a job to be done.
-// Client code derive from this class and implement the virtual execute() method
+/**
+ * Templated abstract base class representing a job to be done. Client code derive from
+ * this class and implement the virtual execute() method.
+ */
 template <typename P>
 struct Job {
     Job() = default;
diff --git a/include/openspace/util/json_helper.h b/include/openspace/util/json_helper.h
index 6761e6bfcf..4042599c36 100644
--- a/include/openspace/util/json_helper.h
+++ b/include/openspace/util/json_helper.h
@@ -31,8 +31,8 @@
 namespace openspace {
 
 /**
- * This function takes a \p text and escapes all necessary characters () that JSON
- * does not want in its strings.
+ * This function takes a \p text and escapes all necessary characters that JSON does not
+ * want in its strings.
  *
  * \param text The text that is to be escaped
  * \return The same text with all required characteres escaped
@@ -40,8 +40,8 @@ namespace openspace {
 std::string escapedJson(const std::string& text);
 
 /**
- * This function takes a \p list of text and escapes all necessary characters () that
- * JSON does not want in its strings.
+ * This function takes a \p list of text and escapes all necessary characters that JSON
+ * does not want in its strings.
  *
  * \param list The list of text that is to be escaped
  * \return The same text with all required characteres escaped
@@ -49,8 +49,8 @@ std::string escapedJson(const std::string& text);
 std::string escapedJson(const std::vector<std::string>& list);
 
 /**
- * Convert the input value to a valid JSON formatted string. Nan and Inf values
- * are not vald JSON and will be represented by 'null'.
+ * Convert the input value to a valid JSON formatted string. Nan and Inf values are not
+ * valid JSON and will be represented by `null`.
  *
  * \param d The value to format
  * \return The resulting JSON formatted string
@@ -68,10 +68,10 @@ std::string formatJson(T value);
 
 /**
  * Sort a json object that is an array of objects with the structure
- * [ key = {}, key = {} ...]. Sorts it by the provided key
+ * `[ key = {}, key = {} ...]`. Sorts it by the provided key.
  *
- * \param json The json to sort
- * \param key The key the json should be sorted by
+ * \param json The JSON object to sort
+ * \param key The key the JSON should be sorted by
  */
 void sortJson(nlohmann::json& json, const std::string& key);
 
diff --git a/include/openspace/util/openspacemodule.h b/include/openspace/util/openspacemodule.h
index 7ba1b3c019..7e626f5f90 100644
--- a/include/openspace/util/openspacemodule.h
+++ b/include/openspace/util/openspacemodule.h
@@ -62,26 +62,26 @@ public:
 
     /**
      * Initialization method that will register a token of the form
-     * `${MODULE_<<NAME>>}` for a specific `<<NAME>>` that
-     * is set in the OpenSpaceModule constructor. This method will call the
-     * internalInitialize method for further customization for each subclass.
+     * `${MODULE_<<NAME>>}` for a specific `<<NAME>>` that is set in the OpenSpaceModule
+     * constructor. This method will call the #internalInitialize method for further
+     * customization for each subclass.
      */
     void initialize(const ghoul::Dictionary& configuration);
 
     /**
-     * This method calls the internalInitializeGL method for further customization for
+     * This method calls the #internalInitializeGL method for further customization for
      * each subclass.
      */
     void initializeGL();
 
     /**
-     * Empty deinitialization method that will call the internalDeinitialize method for
+     * Empty deinitialization method that will call the #internalDeinitialize method for
      * module-specific customization.
      */
     void deinitialize();
 
     /**
-     * This method will call the internalDeinitializeGL method for each subclass.
+     * This method will call the #internalDeinitializeGL method for each subclass.
      */
     void deinitializeGL();
 
@@ -122,15 +122,14 @@ public:
      * Returns the list of required OpenGL extensions for this OpenSpaceModule. Unless
      * overwritten, this function returns an empty list.
      *
-     * \return The list of required OpenGL extensions necessary to use this
-     *         OpenSpaceModule
+     * \return The list of required OpenGL extensions necessary to use this module
      */
     virtual std::vector<std::string> requiredOpenGLExtensions() const;
 
 protected:
     /**
-     * Customization point for each derived class. The internalInitialize method is called
-     * by the initialize method.
+     * Customization point for each derived class. The #internalInitialize method is
+     * called by the initialize method.
      *
      * \param configuration The configuration options that were read from the
      *        configuration file
@@ -138,21 +137,21 @@ protected:
     virtual void internalInitialize(const ghoul::Dictionary& configuration);
 
     /**
-     * Customization point for each derived class. The internalInitializeGL method is
-     * called by the initializeGL method at a time when a valid OpenGL state is
+     * Customization point for each derived class. The #internalInitializeGL method is
+     * called by the #initializeGL method at a time when a valid OpenGL state is
      * guaranteed.
      */
     virtual void internalInitializeGL();
 
     /**
-     * Customization point for each derived class. The internalDeinitialize method is
+     * Customization point for each derived class. The #internalDeinitialize method is
      * called by the deinitialize method.
      */
     virtual void internalDeinitialize();
 
     /**
-     * Customization point for each derived class. The internalDeinitializeGL method is
-     * called by the deinitializeGL method at a time when a valid OpenGL state is
+     * Customization point for each derived class. The #internalDeinitializeGL method is
+     * called by the #deinitializeGL method at a time when a valid OpenGL state is
      * guaranteed.
      */
     virtual void internalDeinitializeGL();
diff --git a/include/openspace/util/resourcesynchronization.h b/include/openspace/util/resourcesynchronization.h
index 1849a4b7ba..699940ed93 100644
--- a/include/openspace/util/resourcesynchronization.h
+++ b/include/openspace/util/resourcesynchronization.h
@@ -42,13 +42,14 @@ namespace documentation { struct Documentation; }
  * function, whose dictionary must contain at least a `Type` value that specifies which
  * type of ResourceSynchronization should be create. Any type that is registered to the
  * global factory is a valid type here.
+ *
  * A ResourceSynchronization state can be in one of four states that can be queried
  * through the #isSyncing, #isResolved, and #isRejected functions. The available states
  * are:
- *  - `Unsynchronized` (#isSyncing = false, #isResolved = false, #isRejected = false)
- *  - `Syncing` (#isSyncing = true, #isResolved = false, #isRejected = false)
- *  - `Resolved` (#isSyncing = false, #isResolved = true, #isRejected = false)
- *  - `Rejected` (#isSyncing = false, #isResolved = false, #isRejected = true)
+ *   - `Unsynchronized` (#isSyncing = false, #isResolved = false, #isRejected = false)
+ *   - `Syncing` (#isSyncing = true, #isResolved = false, #isRejected = false)
+ *   - `Resolved` (#isSyncing = false, #isResolved = true, #isRejected = false)
+ *   - `Rejected` (#isSyncing = false, #isResolved = false, #isRejected = true)
  */
 class ResourceSynchronization {
 public:
@@ -74,7 +75,9 @@ public:
      */
     virtual std::string generateUid() = 0;
 
-    /// Defaulted virtual constructor
+    /**
+     * Defaulted virtual constructor.
+     */
     virtual ~ResourceSynchronization() = default;
 
     /**
@@ -85,10 +88,14 @@ public:
      */
     virtual std::filesystem::path directory() const = 0;
 
-    /// Starts the synchronization for this ResourceSynchronization
+    /**
+     * Starts the synchronization for this ResourceSynchronization.
+     */
     virtual void start() = 0;
 
-    /// Cancels any ongoing synchronization of this ResourceSynchronization
+    /**
+     * Cancels any ongoing synchronization of this ResourceSynchronization.
+     */
     virtual void cancel() = 0;
 
     /**
@@ -168,10 +175,14 @@ public:
     static documentation::Documentation Documentation();
 
 protected:
-    /// Empty constructor that just sets the synchronization root
+    /**
+     * Empty constructor that just sets the synchronization root.
+     */
     ResourceSynchronization(std::filesystem::path synchronizationRoot);
 
-    /// Representation of the state that this object can be in
+    /**
+     * Representation of the state that this object can be in.
+     */
     enum class State {
         Unsynced,
         Syncing,
@@ -179,11 +190,15 @@ protected:
         Rejected
     };
 
-    /// Creates a file next to the directory that indicates that this
-    /// ResourceSynchronization has successfully synchronized its contents
+    /**
+     * Creates a file next to the directory that indicates that this.
+     * ResourceSynchronization has successfully synchronized its contents.
+     */
     virtual void createSyncFile(bool isFullySynchronized = true) const;
 
-    /// Returns whether the synchronization file create in #createSyncFile exists
+    /**
+     * Returns whether the synchronization file create in #createSyncFile exists.
+     */
     bool hasSyncFile() const;
 
     /// The internal identifier for this ResourceSynchronization. It is not enforced but
diff --git a/include/openspace/util/screenlog.h b/include/openspace/util/screenlog.h
index 4fbd047955..e82cc92201 100644
--- a/include/openspace/util/screenlog.h
+++ b/include/openspace/util/screenlog.h
@@ -36,10 +36,9 @@ namespace openspace {
 
 /**
  * The ScreenLog is an implementation of the ghoul::logging::Log abstract interface that
- * can be used to present log messages in an on-screen GUI. For this, every incoming
- * log message (#log) is tagged with the current time and all stored log messages can
- * expire based on the time-to-live as specified in the constructor
- * (#removeExpiredEntries).
+ * can be used to present log messages in an on-screen GUI. For this, every incoming log
+ * message (#log) is tagged with the current time and all stored log messages can expire
+ * based on the time-to-live as specified in the constructor (#removeExpiredEntries).
  */
 class ScreenLog : public ghoul::logging::Log {
 public:
@@ -99,9 +98,9 @@ public:
      * This method removes all the stored LogEntry%s that have expired, calculated by
      * their `timeStamp` and the #_timeToLive value.
      *
-     * \post All entries retrieved by the #entries function have a `timeStamp`
-     *       that is lower than the current time + #_timeToLive. The current time used is
-     *       the time when this method was last called
+     * \post All entries retrieved by the #entries function have a `timeStamp` that is
+     *       lower than the current time + #_timeToLive. The current time used is the time
+     *       when this method was last called
      */
     void removeExpiredEntries();
 
@@ -117,7 +116,7 @@ private:
     std::vector<LogEntry> _entries;
 
     /// The time-to-live for the LogEntry%s in this ScreenLog. Is used by the
-    /// #removeExpiredEntries method to remove expired entries.
+    /// #removeExpiredEntries method to remove expired entries
     std::chrono::seconds _timeToLive;
 
     /// The minimum LogLevel of messages
diff --git a/include/openspace/util/spicemanager.h b/include/openspace/util/spicemanager.h
index aad2c1f737..30e5b4845e 100644
--- a/include/openspace/util/spicemanager.h
+++ b/include/openspace/util/spicemanager.h
@@ -72,19 +72,29 @@ public:
 
     /**
      * Specifies the aberration correction method for the #targetPosition function.
+     *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/spkpos_c.html
      */
     struct AberrationCorrection {
     public:
-        /// The type of the aberration correction
+        /**
+         * The type of the aberration correction.
+         */
         enum class Type {
-            None = 0, ///< No correction (`NONE`)
-            LightTime, ///< One-way light time (`LT`)
-            LightTimeStellar, ///< One-way light time and stellar (`LT+S`)
-            ConvergedNewtonian, ///< Converged newtonian light time (`CN`)
-            ConvergedNewtonianStellar ///< Converged newtonian+stellar (`CN+S`)
+            /// No correction (`NONE`)
+            None = 0,
+            /// One-way light time (`LT`)
+            LightTime,
+            /// One-way light time and stellar (`LT+S`)
+            LightTimeStellar,
+            /// Converged newtonian light time (`CN`)
+            ConvergedNewtonian,
+            /// Converged newtonian+stellar (`CN+S`)
+            ConvergedNewtonianStellar
         };
-        /// The direction of the aberration correct
+        /**
+         * The direction of the aberration correct.
+         */
         enum class Direction {
             Reception = 0,
             Transmission
@@ -92,13 +102,13 @@ public:
 
         /**
          * Default constructor initializing the AberrationCorrection to Type::None with a
-         * Direction::Reception
+         * Direction::Reception.
          */
         AberrationCorrection() = default;
 
         /**
          * Constructor initializing the AberrationCorrection to the provided \p type and
-         * \p direction
+         * \p direction.
          *
          * \param t The type of the aberration correction (AberrationCorrection::Type)
          * \param d The used direction (AberrationCorrection::Direction)
@@ -108,16 +118,15 @@ public:
         /**
          * Converts one of the valid aberration correction strings into its enumeration
          * format. The valid strings are:
-         *
-         *  - `NONE`
-         *  - `LT`
-         *  - `LT+S`
-         *  - `CN`
-         *  - `CN+S`
-         *  - `XLT`
-         *  - `XLT+S`
-         *  - `XCN`
-         *  - XCN+S.
+         *   - `NONE`
+         *   - `LT`
+         *   - `LT+S`
+         *   - `CN`
+         *   - `CN+S`
+         *   - `XLT`
+         *   - `XLT+S`
+         *   - `XCN`
+         *   - XCN+S
          *
          * \param identifier The identifier that should be converted into the enumeration
          *        Type and Direction
@@ -139,7 +148,9 @@ public:
         Direction direction = Direction::Reception;
     };
 
-    /// The possible values for the method parameter of the targetInFieldOfView method
+    /**
+     * The possible values for the method parameter of the targetInFieldOfView method.
+     */
     enum class FieldOfViewMethod {
         Ellipsoid = 0,
         Point
@@ -157,15 +168,17 @@ public:
      */
     static FieldOfViewMethod fieldOfViewMethodFromString(const std::string& method);
 
-    /// The possible values for terminator type method of the terminatorEllipse method
+    /**
+     * The possible values for terminator type method of the terminatorEllipse method.
+     */
     enum class TerminatorType {
         Umbral = 0,
         Penumbral
     };
 
     /**
-     * Returns the TerminatorType for the passed string. The allowed strings are
-     * `UMBRAL` and `PENUMBRAL`. All other values will result in an exception.
+     * Returns the TerminatorType for the passed string. The allowed strings are `UMBRAL`
+     * and `PENUMBRAL`. All other values will result in an exception.
      *
      * \param type The terminator type
      * \return The terminator type enum
@@ -187,12 +200,12 @@ public:
      * safely be loaded multiple times and are reference counted.
      *
      * \param filePath The path to the kernel that should be loaded. This path will be
-     *        passed to `absPath` to convert a relative path to an absolute
-     *        path before usage
+     *        passed to `absPath` to convert a relative path to an absolute path before
+     *        usage
      * \return The loaded kernel's unique identifier that can be used to unload the kernel
      *
-     * \throw SpiceException If the loading of the kernel \p filePath failed if,
-     *        for example, \p filePath is not a valid SPICE kernel
+     * \throw SpiceException If the loading of the kernel \p filePath failed if, for
+     *        example, \p filePath is not a valid SPICE kernel
      * \pre \p filePath must not be empty.
      * \pre \p filePath must be an absolute or relative path pointing to an existing file.
      * \post The kernel is loaded or has its reference counter incremented and the handle
@@ -205,11 +218,12 @@ public:
 
     /**
      * Unloads a SPICE kernel identified by the \p kernelId which was returned by the
-     * loading call to #loadKernel. The unloading is done by calling the
-     * `unload_c` function.
+     * loading call to #loadKernel. The unloading is done by calling the `unload_c`
+     * function.
      *
      * \param kernelId The unique identifier that was returned from the call to
      *        #loadKernel which loaded the kernel
+     *
      * \pre \p kernelId must be a valid handle.
      * \pre \p kernelId cannot be equal to `KernelHandle(0)`.
      * \post The kernel identified by \p kernelId is unloaded.
@@ -220,10 +234,10 @@ public:
 
     /**
      * Unloads a SPICE kernel identified by the \p filePath which was used in the
-     * loading call to #loadKernel. The unloading is done by calling the
-     * `unload_c` function.
+     * loading call to #loadKernel. The unloading is done by calling the `unload_c`
+     * function.
      *
-     * \param filePath The path of the kernel that should be unloaded.
+     * \param filePath The path of the kernel that should be unloaded
      *
      * \throw SpiceException If the \p filePath has not been previously used to
      *        successfully load a kernel.
@@ -235,26 +249,26 @@ public:
     void unloadKernel(std::string filePath);
 
     /**
-     * Returns whether a given \p target has an Spk kernel covering it at the designated
+     * Returns whether a given \p target has an SPK kernel covering it at the designated
      * \p et ephemeris time.
      *
      * \param target The body to be examined. The target has to name a valid SPICE object
      *        with respect to the kernels that have been loaded
      * \param et The time for which the coverage should be checked
-     * \return `true` if SPK kernels have been loaded to cover \p target at the
-     *         time \p et, `false` otherwise.
+     * \return `true` if SPK kernels have been loaded to cover \p target at the time
+     *         \p et, `false` otherwise
      *
      * \throw SpiceException If \p target does not name a valid SPICE object
-     * \pre \p target must not be empty.
+     * \pre \p target must not be empty
      */
     bool hasSpkCoverage(const std::string& target, double et) const;
 
     /**
-     * Returns a list of loaded SPK coverage intervals for \p target
+     * Returns a list of loaded SPK coverage intervals for \p target.
      *
      * \param target The body to be examined. The target has to name a valid SPICE object
      *        with respect to the kernels that have been loaded
-     * \return `list` of SPK kernels for \p target , `empty` list if none loaded.
+     * \return `list` of SPK kernels for \p target, `empty` list if none loaded
      *
      * \throw SpiceException If \p target does not name a valid SPICE object
      * \pre \p target must not be empty.
@@ -268,34 +282,33 @@ public:
      * \param frame The frame to be examined. The \p frame has to name a valid frame with
      *        respect to the kernels that have been loaded
      * \param et The time for which the coverage should be checked
-     * \return `true` if SPK kernels have been loaded to cover \p target at the
-     *         time \p et, false otherwise.
+     * \return `true` if SPK kernels have been loaded to cover \p target at the time
+     *         \p et, false otherwise
      *
      * \throw SpiceException If \p target does not name a valid SPICE object or \p frame
      *        is not a valid frame
-     * \pre \p target must not be empty.
+     * \pre \p target must not be empty
      */
     bool hasCkCoverage(const std::string& frame, double et) const;
 
     /**
-    * Returns a list of loaded CK coverage intervals for \p target
-    *
-    * \param target The body to be examined. The target has to name a valid SPICE object
-    *        with respect to the kernels that have been loaded
-    * \return `list` of CK kernels for \p target , `empty` list if none loaded.
-    *
-    * \throw SpiceException If \p target does not name a valid SPICE object
-    * \pre \p target must not be empty.
-    */
+     * Returns a list of loaded CK coverage intervals for \p target.
+     *
+     * \param target The body to be examined. The target has to name a valid SPICE object
+     *        with respect to the kernels that have been loaded
+     * \return `list` of CK kernels for \p target, `empty` list if none loaded
+     *
+     * \throw SpiceException If \p target does not name a valid SPICE object
+     * \pre \p target must not be empty.
+     */
     std::vector<std::pair<double, double>> ckCoverage(const std::string& target) const;
 
     /**
-   * Returns a list of loaded spice frames,
-   *
-   * \param builtInFrames Boolean representing if builtIn or LoadedFrames should be used
-   * \return `list` of Spice frames with ID(int) and Name(string).
-   *
-   */
+     * Returns a list of loaded spice frames.
+     *
+     * \param builtInFrames Boolean representing if builtIn or LoadedFrames should be used
+     * \return `list` of Spice frames with ID(int) and Name(string)
+     */
     std::vector<std::pair<int, std::string>> spiceBodies(bool builtInFrames) const;
 
     /**
@@ -319,9 +332,9 @@ public:
      * \param item The item to find in the \p body
      * \return `true` if the function succeeded, `false` otherwise
      *
-     * \throw SpiceException If \p body does not name a valid SPICE object.
-     * \pre \p body must not be empty.
-     * \pre \p item must not be empty.
+     * \throw SpiceException If \p body does not name a valid SPICE object
+     * \pre \p body must not be empty
+     * \pre \p item must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/bodfnd_c.html
      */
@@ -331,11 +344,11 @@ public:
      * Returns the NAIF ID for a specific \p body using the `bods2c_c` function.
      *
      * \param body The body name that should be retrieved
-     * \return The ID of the `body` will be stored in this variable. The
-     *         value will only be changed if the retrieval was successful
+     * \return The ID of the `body` will be stored in this variable. The value will only
+     *         be changed if the retrieval was successful
      *
-     * \throw SpiceException If \p body does not name a valid SPICE object.
-     * \pre \p body must not be empty.
+     * \throw SpiceException If \p body does not name a valid SPICE object
+     * \pre \p body must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/bods2c_c.html
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/naif_ids.html
@@ -359,8 +372,8 @@ public:
      * \param frame The frame name that should be retrieved
      * \return The NAIF ID of the \p frame
      *
-     * \throw SpiceException If \p frame is not a valid frame.
-     * \pre \p frame must not be empty.
+     * \throw SpiceException If \p frame is not a valid frame
+     * \pre \p frame must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/namfrm_c.html
      */
@@ -373,7 +386,7 @@ public:
      * \param frame The frame for which the presence of a valid ID should be checked
      * \return `true` if the \p frame has a NAIF ID, `false` otherwise
      *
-     * \pre \p frame must not be empty.
+     * \pre \p frame must not be empty
      */
     bool hasFrameId(const std::string& frame) const;
 
@@ -388,11 +401,10 @@ public:
      * \param value The value that should be retrieved, this value is case-sensitive
      * \param v The destination for the retrieved value
      *
-     * \throw SpiceException If the \p body does not name a valid body, \p value
-     *        is not a valid item for the \p body or the retrieved value is not a single
-     *        value.
-     * \pre \p body must not be empty.
-     * \pre \p value must not be empty.
+     * \throw SpiceException If the \p body does not name a valid body, \p value is not a
+     *        valid item for the \p body or the retrieved value is not a single value
+     * \pre \p body must not be empty
+     * \pre \p value must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/bodvrd_c.html
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/naif_ids.html
@@ -410,11 +422,11 @@ public:
      * \param value The value that should be retrieved, this value is case-sensitive
      * \param v The destination for the retrieved value
      *
-     * \throw SpiceException If the \p body does not name a valid body, \p value
-     *        is not a valid item for the \p body or the retrieved value is not a
-     *        two-component value.
-     * \pre \p body must not be empty.
-     * \pre \p value must not be empty.
+     * \throw SpiceException If the \p body does not name a valid body, \p value is not a
+     *        valid item for the \p body or the retrieved value is not a two-component
+     *        value
+     * \pre \p body must not be empty
+     * \pre \p value must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/bodvrd_c.html
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/naif_ids.html
@@ -432,11 +444,11 @@ public:
      * \param value The value that should be retrieved, this value is case-sensitive
      * \param v The destination for the retrieved value
      *
-     * \throw SpiceException If the \p body does not name a valid body, \p value
-     *        is not a valid item for the \p body or the retrieved value is not a
-     *        three-component value.
-     * \pre \p body must not be empty.
-     * \pre \p value must not be empty.
+     * \throw SpiceException If the \p body does not name a valid body, \p value is not a
+     *        valid item for the \p body or the retrieved value is not a three-component
+     *        value
+     * \pre \p body must not be empty
+     * \pre \p value must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/bodvrd_c.html
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/naif_ids.html
@@ -454,9 +466,9 @@ public:
      * \param value The value that should be retrieved, this value is case-sensitive
      * \param v The destination for the retrieved value
      *
-     * \throw SpiceException If the \p body does not name a valid body, \p value
-     *        is not a valid item for the \p body or the retrieved value is not a
-     *        four-component value.
+     * \throw SpiceException If the \p body does not name a valid body, \p value is not a
+     *        valid item for the \p body or the retrieved value is not a four-component
+     *        value
      * \pre \p body must not be empty.
      * \pre \p value must not be empty.
      *
@@ -468,9 +480,9 @@ public:
     /**
      * Retrieves a \p value with an arbitrary number of components for a certain \p body.
      * This method succeeds iff \p body is the name of a valid body, \p value is a value
-     * associated with the body, and the value consists of the correct number of
-     * `double` values. If all conditions are true, the value is retrieved using the
-     * method `bodvrd_c` and stored in \p v.
+     * associated with the body, and the value consists of the correct number of `double`
+     * values. If all conditions are true, the value is retrieved using the method
+     * `bodvrd_c` and stored in \p v.
      *
      * \param body The name of the body whose value should be retrieved or the NAIF ID of
      *        this body
@@ -478,9 +490,9 @@ public:
      * \param v The destination for the retrieved value. The `vector` must be
      *          preallocated to the correct size of components that should be retrieved
      *
-     * \throw SpiceException If the \p body does not name a valid body, \p value
-     *        is not a valid item for the \p body or the retrieved value does not contain
-     *        the correct number of components
+     * \throw SpiceException If the \p body does not name a valid body, \p value is not a
+     *        valid item for the \p body or the retrieved value does not contain the
+     *        correct number of components
      * \pre \p body must not be empty.
      * \pre \p value must not be empty.
      *
@@ -498,26 +510,25 @@ public:
      * \param craftTicks The internal clock ticks for the specified craft
      * \return The converted ephemeris time
      *
-     * \throw SpiceException If the name \p craft is not a valid name
-     *        available through all loaded kernels, if the craft is not supported by any
-     *        of the loaded kernel, or if the provided \p craftTicks is not a valid tick
-     *        time for the specific spacecraft
+     * \throw SpiceException If the name \p craft is not a valid name available through
+     *        all loaded kernels, if the craft is not supported by any of the loaded
+     *        kernel, or if the provided \p craftTicks is not a valid tick time for the
+     *        specific spacecraft
      * \pre \p craft must not be empty
      */
     double spacecraftClockToET(const std::string& craft, double craftTicks);
 
     /**
-     * Converts the \p timeString representing a date to a double precision
-     * value representing the ephemeris time; that is the number of TDB
-     * seconds past the J2000 epoch.
+     * Converts the \p timeString representing a date to a double precision value
+     * representing the ephemeris time; that is the number of TDB seconds past the J2000
+     * epoch.
      *
      * \param timeString A string representing the time to be converted
      * \return The converted time; the number of TDB seconds past the J2000 epoch,
      *         representing the passed \p timeString
      *
-     * \throw SpiceException If \p timeString is not a valid timestring according
-     *        to the `str2et_c` function (see the Particulars section of the linked
-     *        webpage).
+     * \throw SpiceException If \p timeString is not a valid timestring according to the
+     *        `str2et_c` function (see the Particulars section of the linked webpage)
      * \pre \p timeString must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html
@@ -532,7 +543,7 @@ public:
      * \param ephemerisTime The ephemeris time, that is the number of TDB seconds past the
      *        J2000 epoch
      * \param format The format string describing the output format
-     * \return The destination for the converted date.
+     * \return The destination for the converted date
      *
      * \pre \p format must not be empty
      *
@@ -587,18 +598,18 @@ public:
      * \param ephemerisTime The time at which the position is to be queried
      * \param lightTime If the \p aberrationCorrection is different from
      *        AbberationCorrection::Type::None, this variable will contain the light time
-     *        between the observer and the target.
+     *        between the observer and the target
      * \return The position of the \p target relative to the \p observer in the specified
      *         \p referenceFrame
      *
-     * \throw SpiceException If the \p target or \p observer do not name a valid
-     *        NAIF object, \p referenceFrame does not name a valid reference frame or if
-     *        there is not sufficient data available to compute the position or neither
-     *        the target nor the observer have coverage.
-     * \pre \p target must not be empty.
-     * \pre \p observer must not be empty.
-     * \pre \p referenceFrame must not be empty.
-     * \post If an exception is thrown, \p lightTime will not be modified.
+     * \throw SpiceException If the \p target or \p observer do not name a valid NAIF
+     *        object, \p referenceFrame does not name a valid reference frame or if there
+     *        is not sufficient data available to compute the position or neither the
+     *        target nor the observer have coverage.
+     * \pre \p target must not be empty
+     * \pre \p observer must not be empty
+     * \pre \p referenceFrame must not be empty
+     * \post If an exception is thrown, \p lightTime will not be modified
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/spkpos_c.html
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/naif_ids.html
@@ -621,14 +632,14 @@ public:
      * \return The position of the \p target relative to the \p observer in the specified
      *         \p referenceFrame
      *
-     * \throw SpiceException If the \p target or \p observer do not name a valid
-     *        NAIF object, \p referenceFrame does not name a valid reference frame or if
-     *        there is not sufficient data available to compute the position or neither
-     *        the target nor the observer have coverage.
-     * \pre \p target must not be empty.
-     * \pre \p observer must not be empty.
-     * \pre \p referenceFrame must not be empty.
-     * \post If an exception is thrown, \p lightTime will not be modified.
+     * \throw SpiceException If the \p target or \p observer do not name a valid NAIF
+     *        object, \p referenceFrame does not name a valid reference frame or if there
+     *        is not sufficient data available to compute the position or neither the
+     *        target nor the observer have coverage
+     * \pre \p target must not be empty
+     * \pre \p observer must not be empty
+     * \pre \p referenceFrame must not be empty
+     * \post If an exception is thrown, \p lightTime will not be modified
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/spkpos_c.html
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/naif_ids.html
@@ -648,32 +659,28 @@ public:
      * \return The transformation matrix
      *
      * \throw SpiceException If the transformation matrix between \p from and \p to
-     *        cannot be determined.
-     * \pre \p from must not be empty.
-     * \pre \p to must not be empty.
+     *        cannot be determined
+     * \pre \p from must not be empty
+     * \pre \p to must not be empty
      */
     glm::dmat3 frameTransformationMatrix(const std::string& from,
         const std::string& to, double ephemerisTime) const;
 
-    /// Struct that is used as the return value from the #surfaceIntercept method
+    /**
+     * Struct that is used as the return value from the #surfaceIntercept method.
+     */
     struct SurfaceInterceptResult {
-        /**
-         * The closest surface intercept point on the target body in Cartesian Coordinates
-         * relative to the reference frame.
-         */
+        /// The closest surface intercept point on the target body in Cartesian Coordinates
+        /// relative to the reference frame
         glm::dvec3 surfaceIntercept = glm::dvec3(0.0);
 
-        /**
-         * If the aberration correction is not AberrationCorrection::Type::None, this
-         * value contains the time for which the intercept was computed. Otherwise it is
-         * the same as the ephemerisTime.
-         */
+        /// If the aberration correction is not AberrationCorrection::Type::None, this
+        /// value contains the time for which the intercept was computed. Otherwise it is
+        /// the same as the ephemerisTime
         double interceptEpoch = 0.0;
 
-        /**
-         * The vector from the observer's position to the \p surfaceIntercept position in
-         * the provided reference frame.
-         */
+        /// The vector from the observer's position to the \p surfaceIntercept position in
+        /// the provided reference frame
         glm::dvec3 surfaceVector = glm::dvec3(0.0);
 
         /// `true` if the ray intersects the body, `false` otherwise
@@ -697,17 +704,17 @@ public:
      * \return A SurfaceInterceptResult structure that contains all information about the
      *         intercept, including whether an intercept was found
      *
-     * \throw SpiceException If the \p target or \p observer do not name the same
-     *        NAIF object, the \p target or \p observer name the same NAIF object or are
-     *        in the same location, the \p referenceFrame or \p fovFrame are not
-     *        recognized, insufficient kernel information has been loaded.
-     * \pre \p target must not be empty.
-     * \pre \p observer must not be empty.
+     * \throw SpiceException If the \p target or \p observer do not name the same NAIF
+     *        object, the \p target or \p observer name the same NAIF object or are in the
+     *        same location, the \p referenceFrame or \p fovFrame are not recognized,
+     *        insufficient kernel information has been loaded.
+     * \pre \p target must not be empty
+     * \pre \p observer must not be empty
      * \pre \p The \p target and \p observer must be different strings
-     * \pre \p fovFrame must not be empty.
-     * \pre \p referenceFrame must not be empty.
+     * \pre \p fovFrame must not be empty
+     * \pre \p referenceFrame must not be empty
      * \pre \p directionVector must not be the null vector
-     * \post The SurfaceInterceptResult does not contain any uninitialized values.
+     * \post The SurfaceInterceptResult does not contain any uninitialized values
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/sincpt_c.html
      */
@@ -730,15 +737,15 @@ public:
      * \param ephemerisTime Time of the observation (seconds past J2000)
      * \return `true` if the target is visible, `false` otherwise
      *
-     * \throw SpiceException If the \p target or \p observer do not name valid
-     *        NAIF objects, the \p target or \p observer name the same NAIF object, the
+     * \throw SpiceException If the \p target or \p observer do not name valid NAIF
+     *        objects, the \p target or \p observer name the same NAIF object, the
      *        \p instrument does not name a valid NAIF object, or insufficient kernel
-     *        information has been loaded.
-     * \pre \p target must not be empty.
-     * \pre \p observer must not be empty.
+     *        information has been loaded
+     * \pre \p target must not be empty
+     * \pre \p observer must not be empty
      * \pre \p target and \p observer must not be different strings
-     * \pre \p referenceFrame must not be empty.
-     * \pre \p instrument must not be empty.
+     * \pre \p referenceFrame must not be empty
+     * \pre \p instrument must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/fovtrg_c.html
      */
@@ -747,7 +754,9 @@ public:
         FieldOfViewMethod method, AberrationCorrection aberrationCorrection,
         double& ephemerisTime) const;
 
-    /// Struct that is used as the return value from the #targetState method
+    /**
+     * Struct that is used as the return value from the #targetState method.
+     */
     struct TargetStateResult {
         /// The target position
         glm::dvec3 position = glm::dvec3(0.0);
@@ -755,8 +764,8 @@ public:
         /// The target velocity
         glm::dvec3 velocity = glm::dvec3(0.0);
 
-        /// One-way light time between `target` and `observer` if
-        /// the aberration correction is enabled
+        /// One-way light time between `target` and `observer` if the aberration
+        /// correction is enabled
         double lightTime = 0.0;
     };
 
@@ -777,15 +786,15 @@ public:
      *         \p aberrationCorrection is set to a valid different from
      *         AberrationCorrection::None
      *
-     * \throw SpiceException If the \p target or \p observer do not name a valid
-     *        NAIF object, the \p referenceFrame is not a valid frame, or if there is
-     *        insufficient kernel information.
-     * \pre \p target must not be empty.
-     * \pre \p observer must not be empty.
-     * \pre \p referenceFrame must not be empty.
-     * \post The resulting TargetStateResult is set to valid values; the
-     *       `lightTime` is only set to a valid different from `0.0` if the
-     *       \p aberrationCorrection is not AberrationCorrection::None.
+     * \throw SpiceException If the \p target or \p observer do not name a valid NAIF
+     *        object, the \p referenceFrame is not a valid frame, or if there is
+     *        insufficient kernel information
+     * \pre \p target must not be empty
+     * \pre \p observer must not be empty
+     * \pre \p referenceFrame must not be empty
+     * \post The resulting TargetStateResult is set to valid values; the `lightTime` is
+     *       only set to a valid different from `0.0` if the \p aberrationCorrection is
+     *       not AberrationCorrection::None
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/spkezr_c.html
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/naif_ids.html
@@ -807,8 +816,8 @@ public:
      *
      * \throw SpiceException If the \p sourceFrame or the \p destinationFrame is
      *        not a valid frame
-     * \pre \p sourceFrame must not be empty.
-     * \pre \p destinatoinFrame must not be empty.
+     * \pre \p sourceFrame must not be empty
+     * \pre \p destinatoinFrame must not be empty
      *
      * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/sxform_c.html
      */
@@ -847,12 +856,12 @@ public:
      * \param ephemerisTimeTo The time for the destination reference frame
      * \return The transformation matrix that maps between the \p sourceFrame at time
      *         \p ephemerisTimeFrom to the \p destinationFrame at the time
-     *         \p ephemerisTimeTo.
+     *         \p ephemerisTimeTo
      *
      * \throw SpiceException If there is no coverage available for the specified
-     *         \p sourceFrame and \p destinationFrame
-     * \pre \p sourceFrame must not be empty.
-     * \pre \p destinationFrame must not be empty.
+     *        \p sourceFrame and \p destinationFrame
+     * \pre \p sourceFrame must not be empty
+     * \pre \p destinationFrame must not be empty
      */
     glm::dmat3 positionTransformMatrix(const std::string& sourceFrame,
         const std::string& destinationFrame, double ephemerisTimeFrom,
@@ -860,12 +869,18 @@ public:
 
     /// The structure returned by the #fieldOfView methods
     struct FieldOfViewResult {
-        /// The rough shape of the returned field of view
+        /**
+         * The rough shape of the returned field of view.
+         */
         enum class Shape {
-            Polygon = 0, ///< The shape is a pyramedal polyhedron
-            Rectangle, ///< The shape is a rectangular pyramid
-            Circle, ///< The shape is circular
-            Ellipse ///< The shape is an ellipse
+            /// The shape is a pyramedal polyhedron
+            Polygon = 0,
+            /// The shape is a rectangular pyramid
+            Rectangle,
+            /// The shape is circular
+            Circle,
+            /// The shape is an ellipse
+            Ellipse
         };
 
         /// The shape of the returned field of view
@@ -887,7 +902,7 @@ public:
      *
      * \param instrument The name of the instrument for which the FOV is to be retrieved
      * \return The FieldOfViewResult structure that contains information about the field
-     *         of view.
+     *         of view
      *
      * \throw SpiceException If \p instrument does not name a valid NAIF object
      * \pre \p instrument must not be empty
@@ -904,7 +919,7 @@ public:
      *
      * \param instrument The name of the instrument for which the FOV is to be retrieved
      * \return The FieldOfViewResult structure that contains information about the field
-     *         of view.
+     *         of view
      *
      * \throw SpiceException If \p instrument does not name a valid NAIF object
      * \post The returned structure has all its values initialized
@@ -913,7 +928,9 @@ public:
      */
     FieldOfViewResult fieldOfView(int instrument) const;
 
-    /// The structure retuned by the #terminatorEllipse method
+    /**
+     * The structure retuned by the #terminatorEllipse method.
+     */
     struct TerminatorEllipseResult {
         /// The vector from the target body at #targetEphemerisTime to the observer at
         /// the original time
@@ -941,16 +958,16 @@ public:
      *        surface in total shadow. TerminatorType::Penumbral is the boundary of the
      *        portion of the surface that is completely illuminated. Note that in
      *        astronomy references, the unqualified word "terminator" refers to the umbral
-     *        terminator.
+     *        terminator
      * \param aberrationCorrection The aberration correction method that is used
      * \param ephemerisTime The time at which the terminator ellipse shall be computed
      * \param numberOfTerminatorPoints The number of points along terminator that should
      *        be computed by this method
      * \return A TerminatorEllipseResult structure that contains all outputs of this
-     * function
+     *         function
      *
-     * \throw SpiceException If the \p target, \p observer, or \p lightSource are
-     *        not valid NAIF names, the \p frame is not a valid NAIF frame or there is
+     * \throw SpiceException If the \p target, \p observer, or \p lightSource are not
+     *        valid NAIF names, the \p frame is not a valid NAIF frame or there is
      *        insufficient kernel data loaded
      * \pre \p target must not be empty
      * \pre \p observer must not be empty
@@ -987,20 +1004,29 @@ public:
     static scripting::LuaLibrary luaLibrary();
 
 private:
-    /// Struct storing the information about all loaded kernels
+    /**
+     * Struct storing the information about all loaded kernels.
+     */
     struct KernelInformation {
-        std::string path; /// The path from which the kernel was loaded
-        KernelHandle id; /// A unique identifier for each kernel
-        int refCount; /// How many parts loaded this kernel and are interested in it
+        /// The path from which the kernel was loaded
+        std::string path;
+        /// A unique identifier for each kernel
+        KernelHandle id;
+        /// How many parts loaded this kernel and are interested in it
+        int refCount;
     };
 
-    /// Default constructor setting values for SPICE to not terminate on error
+    /**
+     * Default constructor setting values for SPICE to not terminate on error.
+     */
     SpiceManager();
     SpiceManager(const SpiceManager& c) = delete;
     SpiceManager& operator=(const SpiceManager& r) = delete;
     SpiceManager(SpiceManager&& r) = delete;
 
-    /// Default destructor that resets the SPICE settings
+    /**
+     * Default destructor that resets the SPICE settings.
+     */
     ~SpiceManager();
 
     /**
@@ -1066,8 +1092,8 @@ private:
      * If a transform matrix is requested for an uncovered time in the CK kernels, this
      * function will an estimated matrix. If the coverage has not yet started, the first
      * transform matrix will be retrieved. If the coverage has ended, the last transform
-     * matrix will be retrieved. If \p time is in a coverage gap, the transform
-     * matrix will be interpolated.
+     * matrix will be retrieved. If \p time is in a coverage gap, the transform matrix
+     * will be interpolated.
      *
      * \param fromFrame The transform matrix will be retrieved in relation to this frame
      * \param toFrame The reference frame into which the resulting matrix will transformed
@@ -1083,7 +1109,9 @@ private:
     glm::dmat3 getEstimatedTransformMatrix(const std::string& fromFrame,
         const std::string& toFrame, double time) const;
 
-    /// Loads pre defined leap seconds time kernel (naif00012.tls).
+    /**
+     * Loads pre defined leap seconds time kernel (naif00012.tls).
+     */
     void loadLeapSecondsSpiceKernel();
 
     /// A list of all loaded kernels
diff --git a/include/openspace/util/syncable.h b/include/openspace/util/syncable.h
index 8910423d45..9789a97525 100644
--- a/include/openspace/util/syncable.h
+++ b/include/openspace/util/syncable.h
@@ -30,9 +30,7 @@ namespace openspace {
 class SyncBuffer;
 
 /**
- * Interface for synchronizable data
- *
- * Used by `SyncEngine`
+ * Interface for synchronizable data. Used by #SyncEngine.
  */
 class Syncable {
 public:
diff --git a/include/openspace/util/syncbuffer.h b/include/openspace/util/syncbuffer.h
index 22e6dfc2b9..35e63daefc 100644
--- a/include/openspace/util/syncbuffer.h
+++ b/include/openspace/util/syncbuffer.h
@@ -59,9 +59,6 @@ public:
 
     void reset();
 
-    //void write();
-    //void read();
-
     void setData(std::vector<std::byte> data);
     std::vector<std::byte> data();
 
diff --git a/include/openspace/util/syncdata.h b/include/openspace/util/syncdata.h
index a51b7627cf..6f88f96915 100644
--- a/include/openspace/util/syncdata.h
+++ b/include/openspace/util/syncdata.h
@@ -32,16 +32,15 @@
 namespace openspace {
 
 /**
- * A double buffered implementation of the Syncable interface.
- * Users are encouraged to used this class as a default way to synchronize different
- * C++ data types using the SyncEngine.
+ * A double buffered implementation of the Syncable interface. Users are encouraged to
+ * used this class as a default way to synchronize different C++ data types using the
+ * SyncEngine.
  *
  * This class aims to handle the synchronization parts and yet act like a regular
  * instance of T. Implicit casts are supported, however, when accessing member functions
  * or variables, user may have to do explicit casts.
  *
- * ((T&) t).method();
- *
+ * `((T&) t).method();`
  */
 template<class T>
 class SyncData : public Syncable {
@@ -51,28 +50,28 @@ public:
     SyncData(const SyncData<T>& o);
 
     /**
-     * Allowing assignment of data as if
+     * Allowing assignment of data as if.
      */
     SyncData& operator=(const T& rhs);
 
     /**
-     * Allow implicit cast to referenced T
+     * Allow implicit cast to referenced T.
      */
     operator T&();
 
     /**
-     * Allow implicit cast to const referenced T
+     * Allow implicit cast to const referenced T.
      */
     operator const T&() const;
 
     /**
-     * Explicitly access data
+     * Explicitly access data.
      */
     T& data();
 
     /**
-    * Explicitly access const data
-    */
+     * Explicitly access const data.
+     */
     const T& data() const;
 
 protected:
diff --git a/include/openspace/util/time.h b/include/openspace/util/time.h
index 48d70ef3b7..2499431517 100644
--- a/include/openspace/util/time.h
+++ b/include/openspace/util/time.h
@@ -32,36 +32,32 @@ namespace openspace {
 namespace scripting { struct LuaLibrary; }
 
 /**
- * This singleton class represents the current simulation time in OpenSpace. It
- * internally stores the time and provides methods to set the time directly
- * (setTime(double), setTime(std::string)) using a `double` value using the
- * number of seconds passed since the J2000 epoch or a `string` that denotes
- * a valid date string in accordance to the Spice library
- * (http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html). The time can
- * be retrieved as the number of seconds since the J2000 epoch with currentTime() or as a
- * UTC string following ISO 8601 with the method UTC().
+ * This singleton class represents the current simulation time in OpenSpace. It internally
+ * stores the time and provides methods to set the time directly (setTime(double),
+ * setTime(std::string)) using a `double` value using the number of seconds passed since
+ * the J2000 epoch or a `string` that denotes a valid date string in accordance to the
+ * SPICE library (http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html).
+ * The time can be retrieved as the number of seconds since the J2000 epoch with
+ * #currentTime or as a UTC string following ISO 8601 with the method #UTC.
  *
  * In addition to the time itself, it also stores a delta time value. This value denotes
  * the number of seconds that pass for each real-time second. This value is set with
- * setDeltaTime(double), retrieved with deltaTime() and solely used in the
- * advanceTime(double), which takes a `tickTime` parameter. The value of the
- * parameter is dependent on the usage of the class and must be equal to the real-world
- * time that has passed since the last call to the method. For example, if the
- * advanceTime(double) method is called each frame, the `tickTime` has to be
- * equal to the frame time.
- *
- * The synchronization of the simulation time requires
+ * #setDeltaTime(double), retrieved with deltaTime() and solely used in the
+ * #advanceTime(double), which takes a `tickTime` parameter. The value of the parameter is
+ * dependent on the usage of the class and must be equal to the real-world time that has
+ * passed since the last call to the method. For example, if the #advanceTime(double)
+ * method is called each frame, the `tickTime` has to be equal to the frame time.
  */
 class Time {
 public:
     /**
-     * Converts the \p timeString representing a date to a double precision
-     * value representing the ephemeris time; that is the number of TDB
-     * seconds past the J2000 epoch.
+     * Converts the \p timeString representing a date to a double precision value
+     * representing the ephemeris time; that is the number of TDB seconds past the J2000
+     * epoch.
      *
      * \param time A string representing the time to be converted
      * \return The converted time; the number of TDB seconds past the J2000 epoch,
-     * representing the passed \p timeString
+     *         representing the passed \p timeString
      *
      * \pre \p timeString must not be empty
      */
@@ -92,6 +88,7 @@ public:
     /**
      * Deinitializes the Time singleton. This method will not unload the kernel that was
      * possibly loaded during the initialize method.
+     *
      * \pre The Time singleton must have been initialized
      */
     static void deinitialize();
@@ -107,39 +104,44 @@ public:
     void setTime(double j2000Seconds);
 
     /**
-     * Sets the current time to the specified value given as a Spice compliant string as
-     * described in the Spice documentation
-     * (http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html)
+     * Sets the current time to the specified value given as a SPICE compliant string as
+     * described in the SPICE documentation.
      *
      * \param time The time to be set as a date string
+     *
+     * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html
      */
     void setTime(const std::string& time);
 
     /**
-     * Sets the current time to the specified value given as a Spice compliant string as
-     * described in the Spice documentation
-     * (http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html)
+     * Sets the current time to the specified value given as a SPICE compliant string as
+     * described in the SPICE documentation.
      *
      * \param time The time to be set as a date string
+     *
+     * \sa http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html
      */
     void setTime(const char* time);
 
     /**
      * Returns the current time as the number of seconds past the J2000 epoch. If the
      * current time is a date before that epoch, the returned value will be negative.
+     *
      * \return The current time as the number of seconds past the J2000 epoch
      */
     double j2000Seconds() const;
 
     /**
      * Returns the current time as a formatted date string compliant with ISO 8601 and
-     * thus also compliant with the Spice library.
+     * thus also compliant with the SPICE library.
+     *
      * \return The current time as a formatted date string
      */
     std::string_view UTC() const;
 
     /**
-     * Returns the current time as a ISO 8601 formatted, i.e YYYY-MM-DDThh:mm:ssZ
+     * Returns the current time as a ISO 8601 formatted, i.e YYYY-MM-DDThh:mm:ssZ.
+     *
      * \return The current time as a ISO 8601 formatted string
      */
     std::string_view ISO8601() const;
@@ -151,13 +153,14 @@ public:
     void ISO8601(char* buffer) const;
 
     /**
-     * Advances the simulation time using the deltaTime() and the `tickTime`.
-     * The deltaTime() is the number of simulation seconds that pass for each real-time
-     * second. `tickTime` is the number of real-time seconds that passed since
-     * the last call to this method. If this method is called in the render loop, the
-     * \p tickTime should be equivalent to the frame time.
-     * \param tickTime The number of real-time seconds that passed since the last call
-     *        to this method
+     * Advances the simulation time using the #deltaTime and the `tickTime`. The
+     * #deltaTime is the number of simulation seconds that pass for each real-time second.
+     * `tickTime` is the number of real-time seconds that passed since the last call to
+     * this method. If this method is called in the render loop, the \p tickTime should be
+     * equivalent to the frame time.
+     *
+     * \param tickTime The number of real-time seconds that passed since the last call to
+     *        this method
      * \return The new time value after advancing the time
      */
     double advanceTime(double tickTime);
@@ -174,8 +177,9 @@ public:
     /**
      * Returns the Lua library that contains all Lua functions available to change the
      * current time, retrieve the current time etc.
+     *
      * \return The Lua library that contains all Lua functions available to change the
-     * time
+     *         time
      */
     static scripting::LuaLibrary luaLibrary();
 
diff --git a/include/openspace/util/timeline.h b/include/openspace/util/timeline.h
index d5747d9704..466caea613 100644
--- a/include/openspace/util/timeline.h
+++ b/include/openspace/util/timeline.h
@@ -32,7 +32,7 @@
 namespace openspace {
 
 /**
- * Base class for keyframes
+ * Base class for keyframes.
  */
 struct KeyframeBase {
     size_t id;
@@ -40,7 +40,7 @@ struct KeyframeBase {
 };
 
 /**
- * Templated class for keyframes containing data
+ * Templated class for keyframes containing data.
  */
 template <typename T>
 struct Keyframe : public KeyframeBase {
@@ -54,7 +54,7 @@ struct Keyframe : public KeyframeBase {
 };
 
 /**
- * Templated class for timelines
+ * Templated class for timelines.
  */
 template <typename T>
 class Timeline {
@@ -81,27 +81,27 @@ private:
 };
 
 /**
- * Return true if the timestamp of a is smaller the timestamp of b.
+ * Return `true` if the timestamp of a is smaller the timestamp of b.
  */
 bool compareKeyframeTimes(const KeyframeBase& a, const KeyframeBase& b);
 
 /**
- * Return true if a is smaller than the timestamp of b.
+ * Return `true` if a is smaller than the timestamp of b.
  */
 bool compareTimeWithKeyframeTime(double a, const KeyframeBase& b);
 
 /**
- * Return true if the timestamp of a is smaller than b.
+ * Return `true` if the timestamp of a is smaller than b.
  */
 bool compareKeyframeTimeWithTime(const KeyframeBase& a, double b);
 
 /**
- * Return true if the timestamp of a is smaller than or equal to b.
- * This is used only in the mode of saving render frames during session recording
- * playback. This was necessary to correct a small timing issue caused by fixing
- * the application time according to the playback framerate. In normal operation,
- * the application time at the instant the keyframes are evaluated is always a
- * little bit newer than the first keyframe in the timeline.
+ * Return true if the timestamp of a is smaller than or equal to b. This is used only in
+ * the mode of saving render frames during session recording playback. This was necessary
+ * to correct a small timing issue caused by fixing the application time according to the
+ * playback framerate. In normal operation, the application time at the instant the
+ * keyframes are evaluated is always a little bit newer than the first keyframe in the
+ * timeline.
  */
 bool compareKeyframeTimeWithTime_playbackWithFrames(const KeyframeBase& a, double b);
 
diff --git a/include/openspace/util/timemanager.h b/include/openspace/util/timemanager.h
index d440041a22..bf8305f619 100644
--- a/include/openspace/util/timemanager.h
+++ b/include/openspace/util/timemanager.h
@@ -70,12 +70,12 @@ public:
     void setDeltaTimeSteps(const std::vector<double> deltaTimes);
 
     /**
-     * Returns the delta time, unaffected by pause
+     * Returns the delta time, unaffected by pause.
      */
     double targetDeltaTime() const;
 
     /*
-     * Returns the current delta time, as affected by pause
+     * Returns the current delta time, as affected by pause.
      */
     double deltaTime() const;
 
@@ -83,7 +83,7 @@ public:
      * Sets the simulation time using the time contents of a profile. The function will
      * set either a relative or absolute time.
      *
-     * \param p The Profile to be read.
+     * \param p The Profile to be read
      */
     void setTimeFromProfile(const Profile& p);
 
diff --git a/include/openspace/util/timerange.h b/include/openspace/util/timerange.h
index 89a568ab2f..9c87e8dab3 100644
--- a/include/openspace/util/timerange.h
+++ b/include/openspace/util/timerange.h
@@ -46,13 +46,13 @@ struct TimeRange {
     TimeRange(double startTime, double endTime);
 
     /**
-     * Throws exception if unable to parse the provided \class ghoul::Dictionary
+     * Throws exception if unable to parse the provided \class ghoul::Dictionary.
      */
     TimeRange(const ghoul::Dictionary& dict);
 
     /**
-     * \return `true` if timeRange could be initialized from the dictionary, `false`
-     *         otherwise.
+     * \return `true` if \p timeRange could be initialized from the dictionary, `false`
+     *         otherwise
      */
     static bool initializeFromDictionary(const ghoul::Dictionary& dict,
         TimeRange& timeRange);
diff --git a/include/openspace/util/touch.h b/include/openspace/util/touch.h
index 0c200acd74..c6e94a0e8f 100644
--- a/include/openspace/util/touch.h
+++ b/include/openspace/util/touch.h
@@ -32,9 +32,11 @@
 
 namespace openspace {
 
-// The TouchInput represents a single finger/device-input at a specific point in time.
-// the fingerId and touchDeviceId coupled with the timestamp allows this to be compared
-// with other TouchInputs in order to calculate gesture-like behaviour.
+/**
+ * The TouchInput represents a single finger/device-input at a specific point in time. The
+ * fingerId and touchDeviceId coupled with the timestamp allows this to be compared with
+ * other TouchInputs in order to calculate gesture-like behavior.
+ */
 struct TouchInput {
     TouchInput(size_t touchDeviceId, size_t fingerId, float x, float y, double timestamp);
     glm::vec2 screenCoordinates(glm::vec2 resolution) const;
@@ -47,27 +49,32 @@ struct TouchInput {
     size_t fingerId;
     float x;
     float y;
-    float dx = 0.f;         // movement in x direction since last touch input
-    float dy = 0.f;         // movement in y direction since last touch input
-    double timestamp;       // timestamp in seconds from global touch initialization
+    float dx = 0.f; // movement in x direction since last touch input
+    float dy = 0.f; // movement in y direction since last touch input
+    double timestamp; // timestamp in seconds from global touch initialization
 };
 
-// The TouchInputHolder holds one or many TouchInputs, in order to track the history of
-// the finger/input device
+/**
+ * The TouchInputHolder holds one or many TouchInputs, in order to track the history of
+ * the finger/input device.
+ */
 class TouchInputHolder {
 public:
     TouchInputHolder(TouchInput input);
 
-    // Succeeds upon a different input than last.
-    // Fails upon a too similar input as last.
-    // Updates time for the last input if same position.
+    /**
+     * Succeeds upon a different input than last. Fails upon a too similar input as last.
+     * Updates time for the last input if same position.
+     */
     bool tryAddInput(TouchInput input);
 
     void clearInputs();
 
-    // Checks whether or not this Holder actually holds a specific input (based on IDs)
-    // Succeeds when `input` is held by this Holder
-    // Fails if `input` is not held by this Holder
+    /**
+     * Checks whether or not this Holder actually holds a specific input (based on IDs).
+     * Succeeds when `input` is held by this Holder. Fails if `input` is not held by this
+     * Holder.
+     */
     bool holdsInput(const TouchInput &input) const;
 
     size_t touchDeviceId() const;
@@ -86,7 +93,7 @@ public:
     const std::deque<TouchInput>& peekInputs() const;
 
 private:
-    //A deque of recorded inputs. Adding newer points to the front of the queue
+    /// A deque of recorded inputs. Adding newer points to the front of the queue
     std::deque<TouchInput> _inputs;
     TouchInput _firstInput;
 
diff --git a/include/openspace/util/tstring.h b/include/openspace/util/tstring.h
index 59c2fca1b2..c0c9936994 100644
--- a/include/openspace/util/tstring.h
+++ b/include/openspace/util/tstring.h
@@ -31,17 +31,16 @@
 namespace openspace {
 
 /**
- * This string is a temporary string that is generated using the temporary memory
- * storage. This means that under no circumstances must an instance of a tstring be kept
- * across frame boundaries as the temporary storage is reset at between frames. In
- * exchange, the allocation of these objects is extreme fast and with barely any overhead
- * associated with it. The memory accessed through a tstring object shall never be
- * released manually.
+ * This string is a temporary string that is generated using the temporary memory storage.
+ * This means that under no circumstances must an instance of a tstring be kept across
+ * frame boundaries as the temporary storage is reset at between frames. In exchange, the
+ * allocation of these objects is extreme fast and with barely any overhead associated
+ * with it. The memory accessed through a tstring object shall never be released manually.
  */
 using tstring = std::string_view;
 
 /**
- * Allocate and create a temporary string from the passed std::string.
+ * Allocate and create a temporary string from the passed `std::string`.
  *
  * \param str The string to be copied into a newly allocated tstring
  * \return The copy of the str as a temporary string
@@ -49,9 +48,9 @@ using tstring = std::string_view;
 tstring temporaryString(const std::string& str);
 
 /**
- * Allocate and create a temporary string from the passed std::string_view.
+ * Allocate and create a temporary string from the passed `std::string_view`.
  *
- * \param str The string to be copied into a newly allocated tstring
+ * \param str The string to be copied into a newly allocated #tstring
  * \return The copy of the str as a temporary string
  */
 tstring temporaryString(std::string_view str);
@@ -59,7 +58,7 @@ tstring temporaryString(std::string_view str);
 /**
  * Allocate and create a temporary string from the passed char array.
  *
- * \param str The string to be copied into a newly allocated tstring
+ * \param str The string to be copied into a newly allocated #tstring
  * \return The copy of the str as a temporary string
  */
 tstring temporaryString(const char str[]);
diff --git a/include/openspace/util/universalhelpers.h b/include/openspace/util/universalhelpers.h
index b27dba6d15..8b1b23ecc1 100644
--- a/include/openspace/util/universalhelpers.h
+++ b/include/openspace/util/universalhelpers.h
@@ -25,21 +25,21 @@
 #ifndef __OPENSPACE_CORE___UNIVERSALHELPERS___H__
 #define __OPENSPACE_CORE___UNIVERSALHELPERS___H__
 
-/*
- * This file is meant to contain generally useful functions that is used a bit all over
- * the place but that do not belong in any other, more specific, file.
- *
- * If you implement a function that can be useful in several other situations, feel free
- * to document it and put it this file
- */
+//
+// This file is meant to contain generally useful functions that is used a bit all over
+// the place but that do not belong in any other, more specific, file.
+//
+// If you implement a function that can be useful in several other situations, feel free
+// to document it and put it this file
+//
 
 namespace openspace::helpers {
 
-/*
+/**
  * Remap a parameter t in [0,1] to a subinterval [start, end], by shifting and scaling
  * the value to match the interval. If \p t is smaller than \p start, the return value
  * will be 0 and if bigger than \p end it will be 1. Other values will be linearly
- * interpolated within the range [start, end]
+ * interpolated within the range [start, end].
  */
 double shiftAndScale(double t, double start, double end);
 
diff --git a/modules/base/rendering/renderablenodearrow.h b/modules/base/rendering/renderablenodearrow.h
index f51bafbc28..d020fafd9f 100644
--- a/modules/base/rendering/renderablenodearrow.h
+++ b/modules/base/rendering/renderablenodearrow.h
@@ -42,8 +42,7 @@ namespace documentation { struct Documentation; }
 class Translation;
 
 /**
- * Generates an arrow shape that points from the start node to the
- * end node
+ * Generates an arrow shape that points from the start node to the end node.
  */
 class RenderableNodeArrow : public Renderable {
 public:
diff --git a/modules/base/rendering/renderabletrail.h b/modules/base/rendering/renderabletrail.h
index d0635b0444..032c80a2cd 100644
--- a/modules/base/rendering/renderabletrail.h
+++ b/modules/base/rendering/renderabletrail.h
@@ -72,10 +72,9 @@ class Translation;
  */
 class RenderableTrail : public Renderable {
 public:
+    const double DISTANCE_CULLING_RADII = 800.0;
 
-const double DISTANCE_CULLING_RADII = 800.0;
-
-struct Appearance : properties::PropertyOwner {
+    struct Appearance : properties::PropertyOwner {
         Appearance();
         /// Specifies the base color of the line before fading
         properties::Vec3Property lineColor;
@@ -111,10 +110,11 @@ struct Appearance : properties::PropertyOwner {
 protected:
     explicit RenderableTrail(const ghoul::Dictionary& dictionary);
 
-    /// Returns the documentation entries that the con
     static documentation::Documentation Documentation();
 
-    /// The layout of the VBOs
+    /**
+     * The layout of the VBOs.
+     */
     struct TrailVBOLayout {
         float x, y, z;
     };
@@ -130,13 +130,18 @@ protected:
     /// The Translation object that provides the position of the individual trail points
     ghoul::mm_unique_ptr<Translation> _translation;
 
-    /// The RenderInformation contains information filled in by the concrete subclasses to
-    /// be used by this class.
+    /**
+     * The RenderInformation contains information filled in by the concrete subclasses to
+     * be used by this class.
+     */
     struct RenderInformation {
         enum class VertexSorting {
-            NewestFirst = 0,    ///< Newer vertices have a lower index than older ones
-            OldestFirst,        ///< Older vertices have a lower index than newer ones
-            NoSorting           ///< No ordering in the vertices; no fading applied
+            /// Newer vertices have a lower index than older ones
+            NewestFirst = 0,
+            /// Older vertices have a lower index than newer ones
+            OldestFirst,
+            /// No ordering in the vertices; no fading applied
+            NoSorting
         };
         /// The first element in the vertex buffer to be rendered
         GLint first = 0;
diff --git a/modules/base/rendering/renderabletrailorbit.h b/modules/base/rendering/renderabletrailorbit.h
index b938b9aeda..358af448d4 100644
--- a/modules/base/rendering/renderabletrailorbit.h
+++ b/modules/base/rendering/renderabletrailorbit.h
@@ -58,14 +58,18 @@ public:
 private:
     /**
      * Performs a full sweep of the orbit and fills the entire vertex buffer object.
+     *
      * \param time The current time up to which the full sweep should be performed
      */
     void fullSweep(double time);
 
-    /// This structure is returned from the #updateTrails method and gives information
-    /// about which parts of the vertex array to update
+    /**
+     * This structure is returned from the #updateTrails method and gives information
+     * about which parts of the vertex array to update.
+     */
     struct UpdateReport {
-        static constexpr int All = 0; ///< The entire array was touched in the update
+        /// The entire array was touched in the update
+        static constexpr int All = 0;
 
         /// If `true` the floating point needs to be updated
         bool floatingPointNeedsUpdate;
@@ -73,8 +77,8 @@ private:
         /// If `true` at least one of their permanent point were touched
         bool permanentPointsNeedUpdate;
 
-        /// Returns the number of fixed points that were touched in the update method
-        /// If this value is negative, the newest values were replaced, if positive the
+        /// Returns the number of fixed points that were touched in the update method. If
+        /// this value is negative, the newest values were replaced, if positive the
         /// oldest
         int nUpdated;
     };
@@ -82,6 +86,7 @@ private:
      * Updates the trail based on the new incoming UpdateData information. This function
      * might update an arbitrary number of values in the vertex buffer and returns an
      * UpdateReport that will tell the #update method how many values were modified.
+     *
      * \param data The UpdateData struct that comes from the #update method
      * \return The UpdateReport containing information which array parts were touched
      */
diff --git a/modules/base/rendering/renderabletrailtrajectory.h b/modules/base/rendering/renderabletrailtrajectory.h
index 018b5f6b58..3484b4afa3 100644
--- a/modules/base/rendering/renderabletrailtrajectory.h
+++ b/modules/base/rendering/renderabletrailtrajectory.h
@@ -61,7 +61,9 @@ public:
 
 private:
 
-    /// Reset some variables to default state
+    /**
+     * Reset some variables to default state.
+     */
     void reset();
 
     /// The number of vertices that we calculate during each frame of the full sweep pass
diff --git a/modules/base/rendering/screenspacedashboard.h b/modules/base/rendering/screenspacedashboard.h
index 425adf9859..86e155947d 100644
--- a/modules/base/rendering/screenspacedashboard.h
+++ b/modules/base/rendering/screenspacedashboard.h
@@ -61,10 +61,6 @@ public:
 private:
     Dashboard _dashboard;
     properties::BoolProperty _useMainDashboard;
-    //std::unique_ptr<ghoul::fontrendering::FontRenderer> _fontRenderer;
-
-    //std::shared_ptr<ghoul::fontrendering::Font> _fontDate;
-    //std::shared_ptr<ghoul::fontrendering::Font> _fontInfo;
 };
 
 } // namespace openspace
diff --git a/modules/base/rendering/screenspaceframebuffer.h b/modules/base/rendering/screenspaceframebuffer.h
index 96ad201faf..bf190cf4e1 100644
--- a/modules/base/rendering/screenspaceframebuffer.h
+++ b/modules/base/rendering/screenspaceframebuffer.h
@@ -39,12 +39,10 @@ namespace openspace {
 namespace documentation { struct Documentation; }
 
 /**
- * @brief Creates a texture by rendering to a framebuffer, this is then used on a screen
- *        space plane.
- * @details This class lets you ass renderfunctions that should render to a framebuffer
- *          with an attached texture.
- * The texture is then used on a screen space plane that works both in fisheye and flat
- * screens.
+ * Creates a texture by rendering to a framebuffer, this is then used on a screen space
+ * plane. This class lets you ass renderfunctions that should render to a framebuffer with
+ * an attached texture. The texture is then used on a screen space plane that works both
+ * in fisheye and flat screens.
  */
 class ScreenSpaceFramebuffer : public ScreenSpaceRenderable {
 public:
diff --git a/modules/debugging/rendering/debugrenderer.h b/modules/debugging/rendering/debugrenderer.h
index b0132ec3ce..b5c0229358 100644
--- a/modules/debugging/rendering/debugrenderer.h
+++ b/modules/debugging/rendering/debugrenderer.h
@@ -37,93 +37,91 @@ namespace ghoul::opengl { class ProgramObject; }
 namespace openspace {
 
 /**
- * A helper class for quick rendering of vertices IN clipping space.
- * The class is practically stateless. It only stores a ghoul::opengl::ProgramObject
- * which can be reused despite the fact that rendering calls are invoked from different
- * callers. Therefore a static reference is provided for convenience which is accessed
- * through ref(). Note: That constructors are still public and the class is not a strict
- * singleton.
+ * A helper class for quick rendering of vertices IN clipping space. The class is
+ * practically stateless. It only stores a ghoul::opengl::ProgramObject which can be
+ * reused despite the fact that rendering calls are invoked from different callers.
+ * Therefore a static reference is provided for convenience which is accessed through
+ * #ref. Note: That constructors are still public and the class is not a strict singleton.
  */
 class DebugRenderer {
 public:
     using Vertices = std::vector<glm::vec4>;
 
     /**
-     *  Consider using ref() before creating a new default instance!
+     * Consider using ref() before creating a new default instance.
      */
     DebugRenderer();
 
     /**
-     *  Instantiate a new DebugRenderer with a custom shader program
+     * Instantiate a new DebugRenderer with a custom shader program.
      */
     DebugRenderer(std::unique_ptr<ghoul::opengl::ProgramObject> programObject);
     ~DebugRenderer() = default;
 
     /**
-     *  Access the static reference
+     * Access the static reference.
      */
     static const DebugRenderer& ref();
 
     /**
-     *  Render the vector of clipping space points in the specified mode and color.
+     * Render the vector of clipping space points in the specified mode and color.
      */
     void renderVertices(const Vertices& clippingSpacePoints, GLenum mode,
         const glm::vec4& color = glm::vec4(1.f, 0.f, 0.f, 1.f)) const;
 
     /**
-     *  Takes a vector of exactly 8 vertices, i.e. corner points in a box.
-     *  The box corners should be ordered from smaller to larger,
-     *  first by x, the, y and finally z.
-     *
-     *  6-------7
-     *  |\      |\
-     *  | 2-------3
-     *  4 | - - 5 |
-     *   \|      \|
-     *    0-------1
+     * Takes a vector of exactly 8 vertices, i.e. corner points in a box. The box corners
+     * should be ordered from smaller to larger, first by x, the, y and finally z.
      *
+     * ```
+     * 6-------7
+     * |\      |\
+     * | 2-------3
+     * 4 | - - 5 |
+     *  \|      \|
+     *   0-------1
+     * ```
      */
     void renderBoxFaces(const Vertices& clippingSpaceBoxCorners,
         const glm::vec4& rgba = glm::vec4(1.f, 0.f, 0.f, 1.f)) const;
 
     /**
-     *  Takes a vector of exactly 8 vertices, i.e. corner points in a box.
-     *  The box corners should be ordered from smaller to larger,
-     *  first by x, the, y and finally z.
-     *
-     *  6-------7
-     *  |\      |\
-     *  | 2-------3
-     *  4 | - - 5 |
-     *   \|      \|
-     *    0-------1
+     * Takes a vector of exactly 8 vertices, i.e. corner points in a box. The box corners
+     * should be ordered from smaller to larger, first by x, the, y and finally z.
      *
+     * ```
+     * 6-------7
+     * |\      |\
+     * | 2-------3
+     * 4 | - - 5 |
+     *  \|      \|
+     *   0-------1
+     * ```
      */
     void renderBoxEdges(const Vertices& clippingSpaceBoxCorners,
         const glm::vec4& rgba = glm::vec4(1.f, 0.f, 0.f, 1.f)) const;
 
     /**
-      *  Takes a vector of exactly 8 vertices, i.e. corner points in a box.
-      *  The box corners should be ordered from smaller to larger,
-      *  first by x, the, y and finally z.
-      *
-      *  6-------7
-      *  |\      |\
-      *  | 2-------3
-      *  4 | - - 5 |
-      *   \|      \|
-      *    0-------1
-      *
-      */
+     * Takes a vector of exactly 8 vertices, i.e. corner points in a box. The box corners
+     * should be ordered from smaller to larger, first by x, the, y and finally z.
+     *
+     * ```
+     * 6-------7
+     * |\      |\
+     * | 2-------3
+     * 4 | - - 5 |
+     *  \|      \|
+     *   0-------1
+     * ```
+     */
     void renderNiceBox(const Vertices& clippingSpaceBoxCorners,
         const glm::vec4& rgba = glm::vec4(1.f, 0.f, 0.f, 0.3f)) const;
 
     /**
-     *  Input arguments:
-     *  1. const RenderData& data:     defines position and camera that we will see the
-     *                                 other cameras view frustum from
-     *  2. const Camera& otherCamera:  The camera who's view frustum is to be rendered
-     *  3. RGBA rgba                   Color to draw the view frustum with
+     * \param data Defines position and camera that we will see the other cameras view
+     *             frustum from
+     * \param otherCamera The camera who's view frustum is to be rendered
+     * \param rgba Color to draw the view frustum with
      */
     void renderCameraFrustum(const RenderData& data, const Camera& otherCamera,
         const glm::vec4& rgba = glm::vec4(1.f, 1.f, 1.f, 0.3f)) const;
@@ -131,9 +129,8 @@ public:
 protected:
     std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
 
-
-    // A raw pointer for the reason that it should not be deleted by the static
-    // destructor and the normal destructor. This class has ownership
+    /// A raw pointer for the reason that it should not be deleted by the static
+    /// destructor and the normal destructor. This class has ownership
     static DebugRenderer* _reference;
 };
 
diff --git a/modules/digitaluniverse/rendering/renderablebillboardscloud.h b/modules/digitaluniverse/rendering/renderablebillboardscloud.h
index 142275c5fb..93701b6aea 100644
--- a/modules/digitaluniverse/rendering/renderablebillboardscloud.h
+++ b/modules/digitaluniverse/rendering/renderablebillboardscloud.h
@@ -69,7 +69,6 @@ public:
     static documentation::Documentation Documentation();
 
 private:
-
     std::vector<float> createDataSlice();
     void createPolygonTexture();
     void renderToTexture(GLuint textureToRenderTo, GLuint textureWidth,
diff --git a/modules/exoplanets/exoplanetshelper.h b/modules/exoplanets/exoplanetshelper.h
index 83368d4f7d..8eda2ad51b 100644
--- a/modules/exoplanets/exoplanetshelper.h
+++ b/modules/exoplanets/exoplanetshelper.h
@@ -33,100 +33,100 @@
 namespace openspace::exoplanets {
 
 struct ExoplanetDataEntry {
-    // Orbital semi-major axis in AU
+    /// Orbital semi-major axis in AU
     float a = std::numeric_limits<float>::quiet_NaN();
-    // Upper uncertainty of orbital semi-major axis
+    /// Upper uncertainty of orbital semi-major axis
     double aUpper = std::numeric_limits<double>::quiet_NaN();
-    // Lower uncertainty of orbital semi-major axis
+    /// Lower uncertainty of orbital semi-major axis
     double aLower = std::numeric_limits<double>::quiet_NaN();
 
-    // Longitude of ascending node in degrees
+    /// Longitude of ascending node in degrees
     float bigOmega = std::numeric_limits<float>::quiet_NaN();
-    // Upper uncertainty of longitude of ascending node
+    /// Upper uncertainty of longitude of ascending node
     float bigOmegaUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of longitude of ascending node
+    /// Lower uncertainty of longitude of ascending node
     float bigOmegaLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Star known to be binary?
+    /// Star known to be binary?
     bool binary = false;
 
-    // Star B − V color
+    /// Star B − V color
     float bmv = std::numeric_limits<float>::quiet_NaN();
 
-    // Orbital eccentricity
+    /// Orbital eccentricity
     float ecc = std::numeric_limits<float>::quiet_NaN();
-    // Upper uncertainty of orbital eccentricity
+    /// Upper uncertainty of orbital eccentricity
     float eccUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of orbital eccentricity
+    /// Lower uncertainty of orbital eccentricity
     float eccLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Orbital inclination in degrees (for transiting systems only)
+    /// Orbital inclination in degrees (for transiting systems only)
     float i = std::numeric_limits<float>::quiet_NaN();
-    // Upper uncertainty of orbital inclination
+    /// Upper uncertainty of orbital inclination
     float iUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of orbital inclination
+    /// Lower uncertainty of orbital inclination
     float iLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Number of known planets in the planetary system
+    /// Number of known planets in the planetary system
     int nPlanets = std::numeric_limits<int>::quiet_NaN();
 
-    // Number of stars in the planetary system
+    /// Number of stars in the planetary system
     int nStars = std::numeric_limits<int>::quiet_NaN();
 
-    // Argument of periastron in degrees
+    /// Argument of periastron in degrees
     float omega = std::numeric_limits<float>::quiet_NaN();
-    // Upper uncertainty of argument of periastron
+    /// Upper uncertainty of argument of periastron
     float omegaUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of argument of periastron
+    /// Lower uncertainty of argument of periastron
     float omegaLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Orbital period in days
+    /// Orbital period in days
     double per = std::numeric_limits<double>::quiet_NaN();
-    // Upper uncertainty of period
+    /// Upper uncertainty of period
     float perUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of period
+    /// Lower uncertainty of period
     float perLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Radius of the planet in Jupiter radii
+    /// Radius of the planet in Jupiter radii
     double r = std::numeric_limits<double>::quiet_NaN();
-    // Upper uncertainty of radius of the planet
+    /// Upper uncertainty of radius of the planet
     double rUpper = std::numeric_limits<double>::quiet_NaN();
-    // Lower uncertainty of radius of the planet
+    /// Lower uncertainty of radius of the planet
     double rLower = std::numeric_limits<double>::quiet_NaN();
 
-    // Estimated radius of the star in solar radii
+    /// Estimated radius of the star in solar radii
     float rStar = std::numeric_limits<float>::quiet_NaN();
-    // Upper uncertainty of estimated star radius
+    /// Upper uncertainty of estimated star radius
     float rStarUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of estimated star radius
+    /// Lower uncertainty of estimated star radius
     float rStarLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Star luminosity, in units of solar luminosities
+    /// Star luminosity, in units of solar luminosities
     float luminosity = std::numeric_limits<float>::quiet_NaN();
-    // Upper uncertainty of star luminosity
+    /// Upper uncertainty of star luminosity
     float luminosityUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of star luminosity
+    /// Lower uncertainty of star luminosity
     float luminosityLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Star's effective temperature in Kelvin
+    /// Star's effective temperature in Kelvin
     float teff = std::numeric_limits<float>::quiet_NaN();
-    // Upper uncertainty of effective temperature
+    /// Upper uncertainty of effective temperature
     float teffUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of effective temperature
+    /// Lower uncertainty of effective temperature
     float teffLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Epoch of transit center in HJD-2440000
+    /// Epoch of transit center in HJD-2440000
     double tt = std::numeric_limits<double>::quiet_NaN();
-    // Upper uncertainty of epoch of transit center
+    /// Upper uncertainty of epoch of transit center
     float ttUpper = std::numeric_limits<float>::quiet_NaN();
-    // Lower uncertainty of epoch of transit center
+    /// Lower uncertainty of epoch of transit center
     float ttLower = std::numeric_limits<float>::quiet_NaN();
 
-    // Star position's X-coordinate in parsec
+    /// Star position's X-coordinate in parsec
     float positionX = std::numeric_limits<float>::quiet_NaN();
-    // Star position's Y-coordinate in parsec
+    /// Star position's Y-coordinate in parsec
     float positionY = std::numeric_limits<float>::quiet_NaN();
-    // Star position's Z-coordinate in parsec
+    /// Star position's Z-coordinate in parsec
     float positionZ = std::numeric_limits<float>::quiet_NaN();
 };
 
@@ -147,24 +147,31 @@ struct ExoplanetSystem {
 
 bool isValidPosition(const glm::vec3& pos);
 
-// Check if the exoplanet p has sufficient data for visualization
+/**
+ * Check if the exoplanet p has sufficient data for visualization.
+ */
 bool hasSufficientData(const ExoplanetDataEntry& p);
 
-// Compute star color in RGB from b-v color index
+/**
+ * Compute star color in RGB from b-v color index.
+ */
 glm::vec3 computeStarColor(float bv);
 
 glm::dmat4 computeOrbitPlaneRotationMatrix(float i, float bigom = 180.f,
     float omega = 90.f);
 
-// Rotate the original coordinate system (where x is pointing to First Point of Aries)
-// so that x is pointing from star to the sun.
+/**
+ * Rotate the original coordinate system (where x is pointing to First Point of Aries) so
+ * that x is pointing from star to the Sun.
+ */
 glm::dmat3 computeSystemRotation(glm::dvec3 starPosition);
 
 void sanitizeNameString(std::string& s);
 
-// Star data should not vary between planets, but one data entry might lack data
-// for the host star while another does not. So for every planet, update star data
-// if needed
+/**
+ * Star data should not vary between planets, but one data entry might lack data for the
+ * host star while another does not. So for every planet, update star data if needed.
+ */
 void updateStarDataFromNewPlanet(StarData& starData, const ExoplanetDataEntry& p);
 
 } // namespace openspace::exoplanets
diff --git a/modules/exoplanets/rendering/renderableorbitdisc.h b/modules/exoplanets/rendering/renderableorbitdisc.h
index 43f30b3ce8..271b20b724 100644
--- a/modules/exoplanets/rendering/renderableorbitdisc.h
+++ b/modules/exoplanets/rendering/renderableorbitdisc.h
@@ -58,7 +58,9 @@ public:
     static documentation::Documentation Documentation();
 
 private:
-    // Computes the size of the plane quad using the relevant properties
+    /**
+     * Computes the size of the plane quad using the relevant properties.
+     */
     float planeSize() const;
 
     properties::StringProperty _texturePath;
diff --git a/modules/exoplanets/tasks/exoplanetsdatapreparationtask.h b/modules/exoplanets/tasks/exoplanetsdatapreparationtask.h
index 5d0542af28..7de2bb7e6d 100644
--- a/modules/exoplanets/tasks/exoplanetsdatapreparationtask.h
+++ b/modules/exoplanets/tasks/exoplanetsdatapreparationtask.h
@@ -51,29 +51,31 @@ public:
 
     /**
      * The exoplanet file includes a set of commented lines in the beginning. This
-     * funciton skips those lines, as well as any empty lines, and continues reading
-     * until it find the first valid data line (which will be the column names).
+     * function skips those lines, as well as any empty lines, and continues reading until
+     * it find the first valid data line (which will be the column names).
      *
      * \param file The input file stream used for reading the file
-     * \return The content of the first data row (i.e. the column names).
+     * \return The content of the first data row (i.e. the column names)
      */
     static std::vector<std::string> readFirstDataRow(std::ifstream& file);
 
     /**
-     * Parse a row in the CSV file of exoplanets. Assumes the same format and column
-     * names as provided by the NASA Exoplanet Archive.
-     * (https://exoplanetarchive.ipac.caltech.edu/)
+     * Parse a row in the CSV file of exoplanets. Assumes the same format and column names
+     * as provided by the NASA Exoplanet Archive.
      *
      * \param row The row to parse, given as a string
      * \param columnNames The list of column names in the file, from the CSV header
      * \param positionSourceFile A SPECK file to use for getting the position of the star.
-     *        This is used to make sure the position of the star matches those of other star
-     *        datasets. If no file is provided, the position from the CSV data file is read
-     *        and used instead
+     *        This is used to make sure the position of the star matches those of other
+     *        star datasets. If no file is provided, the position from the CSV data file
+     *        is read and used instead
      * \param bvFromTeffConversionFile A text file containing a mapping between effective
-     *        temperature (teff) values and B-V color index values. Each line should include
-     *        two values separated by a comma: first the teff value and hten the B-V value
-     * \return An object containing the parsed information.
+     *        temperature (teff) values and B-V color index values. Each line should
+     *        include two values separated by a comma: first the teff value and then the
+     *        B-V value
+     * \return An object containing the parsed information
+     *
+     * /sa https://exoplanetarchive.ipac.caltech.edu/
      */
     static PlanetData parseDataRow(std::string row,
         const std::vector<std::string>& columnNames,
diff --git a/modules/fieldlinessequence/util/commons.h b/modules/fieldlinessequence/util/commons.h
index 9b517a72b7..695743d5a4 100644
--- a/modules/fieldlinessequence/util/commons.h
+++ b/modules/fieldlinessequence/util/commons.h
@@ -38,9 +38,9 @@ enum class Model : int {
 
 Model stringToModel(const std::string& s);
 
-constexpr float AuToMeter = 149597870700.f;  // Astronomical Units
-constexpr float ReToMeter = 6371000.f;       // Earth radius
-constexpr float RsToMeter = 695700000.f;     // Sun radius
+constexpr float AuToMeter = 149597870700.f; // Astronomical Units
+constexpr float ReToMeter = 6371000.f; // Earth radius
+constexpr float RsToMeter = 695700000.f; // Sun radius
 
 } // namespace openspace::fls
 
diff --git a/modules/fieldlinessequence/util/kameleonfieldlinehelper.h b/modules/fieldlinessequence/util/kameleonfieldlinehelper.h
index 8381a2a204..5599f6914c 100644
--- a/modules/fieldlinessequence/util/kameleonfieldlinehelper.h
+++ b/modules/fieldlinessequence/util/kameleonfieldlinehelper.h
@@ -36,21 +36,21 @@ class FieldlinesState;
 
 namespace fls {
 
-/** Traces field lines from the provided cdf file using kameleon and stores the data in
- * the provided FieldlinesState.
- * Returns `false` if it fails to create a valid state. Requires the kameleon module to
- * be activated!
+/**
+ * Traces field lines from the provided cdf file using kameleon and stores the data in the
+ * provided FieldlinesState. Returns `false` if it fails to create a valid state. Requires
+ * the kameleon module to be activated.
  *
  * \param state FieldlineState which should hold the extracted data
- * \param cdfPath std::string of the absolute path to a .cdf file
- * \param seedMap vector of seed points from which to trace field lines
- * \param manualTimeOffset an offset that is applied to all fieldlines
- * \param tracingVar which quantity to trace lines from. Typically "b" for magnetic field
+ * \param cdfPath `std::string` of the absolute path to a .cdf file
+ * \param seedMap Vector of seed points from which to trace field lines
+ * \param manualTimeOffset An offset that is applied to all fieldlines
+ * \param tracingVar Which quantity to trace lines from. Typically "b" for magnetic field
  *        lines and "u" for velocity flow lines
- * \param extraVars extra scalar quantities to be stored in the FieldlinesState; e.g. "T"
+ * \param extraVars Extra scalar quantities to be stored in the FieldlinesState; e.g. "T"
  *        for temperature, "rho" for density or "P" for pressure
- * \param extraMagVars variables which should be used for extracting magnitudes, must be
- *        a multiple of 3; e.g. "ux", "uy" & "uz" to get the magnitude of the velocity
+ * \param extraMagVars Variables which should be used for extracting magnitudes, must be a
+ *        multiple of 3; e.g. "ux", "uy" & "uz" to get the magnitude of the velocity
  *        vector at each line vertex
  */
 bool convertCdfToFieldlinesState(FieldlinesState& state, const std::string& cdfPath,
diff --git a/modules/fitsfilereader/include/fitsfilereader.h b/modules/fitsfilereader/include/fitsfilereader.h
index 9f3078c924..a98a3b970f 100644
--- a/modules/fitsfilereader/include/fitsfilereader.h
+++ b/modules/fitsfilereader/include/fitsfilereader.h
@@ -73,10 +73,10 @@ public:
     std::shared_ptr<T> readHeaderValue(const std::string key);
 
     /**
-     * Read specified table columns from fits file.
-     * If `readAll` is set to true the entire table will be read before the
-     * selected columns, which makes the function take a lot longer if it's a big file.
-     * If no HDU index is given the current Extension HDU will be read from.
+     * Read specified table columns from fits file. If `readAll` is set to true the entire
+     * table will be read before the selected columns, which makes the function take a lot
+     * longer if it's a big file. If no HDU index is given the current Extension HDU will
+     * be read from.
      */
     template<typename T>
     std::shared_ptr<TableData<T>> readTable(const std::filesystem::path& path,
@@ -85,17 +85,17 @@ public:
 
     /**
      * Reads a single FITS file with pre-defined columns (defined for Viennas TGAS-file).
-     * Returns a vector with all read stars with `nValuesPerStar`.
-     * If additional columns are given by `filterColumnNames`, they will be
-     * read but it will slow doen the reading tremendously.
+     * Returns a vector with all read stars with `nValuesPerStar`. If additional columns
+     * are given by `filterColumnNames`, they will be read but it will slow doen the
+     * reading tremendously.
      */
     std::vector<float> readFitsFile(std::filesystem::path filePath, int& nValuesPerStar,
         int firstRow, int lastRow, std::vector<std::string> filterColumnNames,
         int multiplier = 1);
 
     /**
-     * Reads a single SPECK file and returns a vector with `nRenderValues`
-     * per star. Reads data in pre-defined order based on AMNH's star data files.
+     * Reads a single SPECK file and returns a vector with `nRenderValues` per star. Reads
+     * data in pre-defined order based on AMNH's star data files.
      */
     std::vector<float> readSpeckFile(const std::filesystem::path& filePath,
         int& nRenderValues);
diff --git a/modules/gaia/rendering/octreeculler.h b/modules/gaia/rendering/octreeculler.h
index 87dc6aee12..307385df00 100644
--- a/modules/gaia/rendering/octreeculler.h
+++ b/modules/gaia/rendering/octreeculler.h
@@ -35,28 +35,27 @@ namespace openspace {
 /**
  * Culls all octree nodes that are completely outside the view frustum.
  *
- * The frustum culling uses a 2D axis aligned bounding box for the OctreeNode in
- * screen space.
+ * The frustum culling uses a 2D axis aligned bounding box for the OctreeNode in screen
+ * space.
  */
-
 class OctreeCuller {
 public:
 
     /**
-     * \param viewFrustum is the view space in normalized device coordinates space.
-     *                    Hence it is an axis aligned bounding box and not a real frustum.
+     * \param viewFrustum This is the view space in normalized device coordinates space.
+     *        Hence it is an axis aligned bounding box and not a real frustum
      */
     OctreeCuller(globebrowsing::AABB3 viewFrustum);
 
     ~OctreeCuller() = default;
 
     /**
-     * \return true if any part of the node is visible in the current view.
+     * \return `true` if any part of the node is visible in the current view
      */
     bool isVisible(const std::vector<glm::dvec4>& corners, const glm::dmat4& mvp);
 
     /**
-     * \return the size [in pixels] of the node in clipping space.
+     * \return The size [in pixels] of the node in clipping space
      */
     glm::vec2 getNodeSizeInPixels(const std::vector<glm::dvec4>& corners,
         const glm::dmat4& mvp, const glm::vec2& screenSize);
diff --git a/modules/gaia/rendering/octreemanager.h b/modules/gaia/rendering/octreemanager.h
index e15aae9cf7..997ddad1a9 100644
--- a/modules/gaia/rendering/octreemanager.h
+++ b/modules/gaia/rendering/octreemanager.h
@@ -70,49 +70,48 @@ public:
     /**
      * Initializes a stack. Can be used to trigger a rebuild of buffer(s).
      *
-     * \param maxNodes the maximum number of nodes in the buffer
-     * \param useVBO defines if VBO or SSBO is used as buffer(s)
-     * \param datasetFitInMemory defines if streaming of nodes during runtime is used
+     * \param maxNodes The maximum number of nodes in the buffer
+     * \param useVBO Defines if VBO or SSBO is used as buffer(s)
+     * \param datasetFitInMemory Defines if streaming of nodes during runtime is used
      */
     void initBufferIndexStack(long long maxNodes, bool useVBO, bool datasetFitInMemory);
 
     /**
      * Inserts star values in correct position in Octree. Makes use of a recursive
-     * traversal strategy. Internally calls `insertInNode()`
+     * traversal strategy. Internally calls #insertInNode.
      */
     void insert(const std::vector<float>& starValues);
 
     /**
      * Slices LOD data so only the MAX_STARS_PER_NODE brightest stars are stored in inner
-     * nodes. If \p branchIndex is defined then only that branch will be sliced.
-     * Calls `sliceNodeLodCache()` internally.
+     * nodes. If \p branchIndex is defined then only that branch will be sliced. Calls
+     * #sliceNodeLodCache internally.
      */
     void sliceLodData(size_t branchIndex = 8);
 
     /**
      * Prints the whole tree structure, including number of stars per node, number of
-     * nodes, tree depth and if node is a leaf.
-     * Calls `printStarsPerNode(node, prefix)` internally.
+     * nodes, tree depth and if node is a leaf. Calls #printStarsPerNode(node, prefix)
+     * internally.
      */
     void printStarsPerNode() const;
 
     /**
      * Used while streaming nodes from files. Checks if any nodes need to be loaded or
      * unloaded. If entire dataset fits in RAM then the whole dataset will be loaded
-     * asynchronously. Otherwise only nodes close to the camera will be fetched.
-     * When RAM stars to fill up least-recently used nodes will start to unload.
-     * Calls `findAndFetchNeighborNode()` and `removeNodesFromRam()` internally.
+     * asynchronously. Otherwise only nodes close to the camera will be fetched. When RAM
+     * stars to fill up least-recently used nodes will start to unload. Calls
+     * #findAndFetchNeighborNode and #removeNodesFromRam internally.
      */
     void fetchSurroundingNodes(const glm::dvec3& cameraPos, size_t chunkSizeInBytes,
         const glm::ivec2& additionalNodes);
 
     /**
      * Builds render data structure by traversing the Octree and checking for intersection
-     * with view frustum. Every vector in map contains data for one node.
-     * The corresponding integer key is the index where chunk should be inserted into
-     * streaming buffer. Calls #checkNodeIntersection for every branch.
-     * \p deltaStars keeps track of how many stars that were added/removed this render
-     * call.
+     * with view frustum. Every vector in map contains data for one node. The
+     * corresponding integer key is the index where chunk should be inserted into
+     * streaming buffer. Calls #checkNodeIntersection for every branch. \p deltaStars
+     * keeps track of how many stars that were added/removed this render call.
      */
     std::map<int, std::vector<float>> traverseData(const glm::dmat4& mvp,
         const glm::vec2& screenSize, int& deltaStars, gaia::RenderMode mode,
@@ -125,7 +124,8 @@ public:
 
     /**
      * Removes all data from Octree, or only from a specific branch if specified.
-     * \param branchIndex defined which branch to clear if defined.
+     *
+     * \param branchIndex Defined which branch to clear if defined
      */
     void clearAllData(int branchIndex = -1);
 
@@ -202,7 +202,7 @@ private:
     const std::string BINARY_SUFFIX = ".bin";
 
     /**
-     * \returns the correct index of child node. Maps [1,1,1] to 0 and [-1,-1,-1] to 7.
+     * \return the correct index of child node. Maps [1,1,1] to 0 and [-1,-1,-1] to 7.
      */
     size_t getChildIndex(float posX, float posY, float posZ, float origX = 0.f,
         float origY = 0.f, float origZ = 0.f);
@@ -298,7 +298,7 @@ private:
      * \param node the node that should be inserted
      * \param mode the render mode that should be used
      * \param deltaStars keeps track of how many stars that were added.
-     * \returns the data to be inserted
+     * \return the data to be inserted
      */
     std::vector<float> constructInsertData(const OctreeNode& node,
         gaia::RenderMode mode, int& deltaStars);
diff --git a/modules/gaia/rendering/renderablegaiastars.h b/modules/gaia/rendering/renderablegaiastars.h
index 0476cb223a..8424d84be0 100644
--- a/modules/gaia/rendering/renderablegaiastars.h
+++ b/modules/gaia/rendering/renderablegaiastars.h
@@ -69,35 +69,35 @@ private:
     /**
      * Reads data file in format defined by FileReaderOption.
      *
-     * \return true if data was successfully read.
+     * \return `true` if data was successfully read
      */
     bool readDataFile();
 
     /**
      * Reads a FITS file by using FitsFileReader.readFitsFile() and constructs an octree.
      *
-     * \return the number of stars read.
+     * \return The number of stars read
      */
     int readFitsFile(const std::filesystem::path& filePath);
 
     /**
      * Read a SPECK file by using FitsFileReader.readSpeckFile() and constructs an octree.
      *
-     * \return the number of stars read.
+     * \return The number of stars read
      */
     int readSpeckFile(const std::filesystem::path& filePath);
 
     /**
      * Reads a preprocessed binary file and constructs an octree.
      *
-     * \return the number of stars read.
+     * \return The number of stars read
      */
     int readBinaryRawFile(const std::filesystem::path& filePath);
 
     /**
      * Reads a pre-constructed octree, with all data, from a binary file.
      *
-     * \return the number of stars read.
+     * \return The number of stars read
      */
     int readBinaryOctreeFile(const std::filesystem::path& filePath);
 
@@ -105,7 +105,7 @@ private:
      * Reads the structure of a pre-constructed octree from a binary file, without any
      * data.
      *
-     * \return the number of stars read.
+     * \return The number of stars read
      */
     int readBinaryOctreeStructureFile(const std::filesystem::path& folderPath);
 
diff --git a/modules/gaia/tasks/constructoctreetask.h b/modules/gaia/tasks/constructoctreetask.h
index 1aa1d49adf..0269569d92 100644
--- a/modules/gaia/tasks/constructoctreetask.h
+++ b/modules/gaia/tasks/constructoctreetask.h
@@ -49,36 +49,35 @@ private:
 
     /**
      * Reads a single binary file with preprocessed star data and insert the render values
-     * into an octree structure (if star data passed all defined filters).
-     * Stores the entire octree in one binary file.
+     * into an octree structure (if star data passed all defined filters). Stores the
+     * entire octree in one binary file.
      */
     void constructOctreeFromSingleFile(const Task::ProgressCallback& progressCallback);
 
     /**
-     *  Reads binary star data from 8 preprocessed files (one per branch) in specified
-     * folder, prepared by ReadFitsTask, and inserts star render data into an octree
-     * (if star data passed all defined filters).
-     * Stores octree structure in a binary index file and stores all render data
-     * separate files, one file per node in the octree.
+     * Reads binary star data from 8 preprocessed files (one per branch) in specified
+     * folder, prepared by ReadFitsTask, and inserts star render data into an octree (if
+     * star data passed all defined filters). Stores octree structure in a binary index
+     * file and stores all render data separate files, one file per node in the octree.
      */
     void constructOctreeFromFolder(const Task::ProgressCallback& progressCallback);
 
     /**
-     * Checks all defined filter ranges and \returns true if any of the corresponding
-     * `filterValues` are outside of the defined range.
+     * Checks all defined filter ranges and returns true if any of the corresponding
+     * \p filterValues are outside of the defined range.
      *
-     * \param filterValues are all read filter values in binary file.
+     * \param filterValues Are all read filter values in binary file
      *
-     * \returns false if value should be inserted into Octree.
+     * \return `false` if value should be inserted into Octree
      */
     bool checkAllFilters(const std::vector<float>& filterValues);
 
     /**
-     * \p range contains ]min, max[ and \p filterValue corresponding value in
-     * star. Star is filtered either if min = max = filterValue or if filterValue < min
-     * (when min != 0.0) or filterValue > max (when max != 0.0).
+     * \p range contains ]min, max[ and \p filterValue corresponding value in star. Star
+     * is filtered either if `min = max = filterValue` or if `filterValue < min` (when
+     * `min != 0.0`) or `filterValue > max` (when `max != 0.0`).
      *
-     * \return true if star should be filtered away and false if all filters passed.
+     * \return `true` if star should be filtered away and `false` if all filters passed
      */
     bool filterStar(const glm::vec2& range, float filterValue, float normValue = 0.f);
 
diff --git a/modules/gaia/tasks/readfilejob.h b/modules/gaia/tasks/readfilejob.h
index f1fa487b43..53451b5c1b 100644
--- a/modules/gaia/tasks/readfilejob.h
+++ b/modules/gaia/tasks/readfilejob.h
@@ -36,18 +36,18 @@ struct ReadFileJob : public Job<std::vector<std::vector<float>>> {
      * Constructs a Job that will read a single FITS file in a concurrent thread and
      * divide the star data into 8 octants depending on position.
      *
-     * \param filePath the file from which to load the data
-     * \param allColumns define which columns that will be read, it should correspond
-     *        to the pre-defined order in the job. If additional columns are defined they
+     * \param filePath The file from which to load the data
+     * \param allColumns Define which columns that will be read, it should correspond to
+     *        the pre-defined order in the job. If additional columns are defined they
      *        will be read but slow down the process. Proper conversions of positions and
      *        velocities will take place and all values will be checked for NaNs. If
      *        \p firstRow is < 1 then reading will begin at first row in table. If
      *        \p lastRow < firstRow then entire table will be read
-     * \param firstRow the index of the first row to be read
-     * \param lastRow the index of the last row to be read
-     * \param nDefaultCols defines how many columns that will be read per star
-     * \param nValuesPerStar defines how many values that will be stored per star
-     * \param fitsReader the reader that should be used in this job
+     * \param firstRow The index of the first row to be read
+     * \param lastRow The index of the last row to be read
+     * \param nDefaultCols Defines how many columns that will be read per star
+     * \param nValuesPerStar Defines how many values that will be stored per star
+     * \param fitsReader The reader that should be used in this job
      */
     ReadFileJob(std::string filePath, std::vector<std::string> allColumns, int firstRow,
         int lastRow, size_t nDefaultCols, int nValuesPerStar,
diff --git a/modules/gaia/tasks/readfitstask.h b/modules/gaia/tasks/readfitstask.h
index 8236a572ba..ad60b60cd6 100644
--- a/modules/gaia/tasks/readfitstask.h
+++ b/modules/gaia/tasks/readfitstask.h
@@ -50,7 +50,7 @@ private:
     //const size_t MAX_SIZE_BEFORE_WRITE = 9000000; // ~34MB -> 0,5 stars with 18 values
 
     /**
-     *  Reads a single FITS file and stores ordered star data in one binary file.
+     * Reads a single FITS file and stores ordered star data in one binary file.
      */
     void readSingleFitsFile(const Task::ProgressCallback& progressCallback);
 
@@ -63,12 +63,12 @@ private:
     /**
      * Writes data to an octant file.
      *
-     * \param data the data that should be be written to file
-     * \param index the index of the octant that should be written
-     * \param isFirstWrite defines if this is the first write to specified octant, if so
+     * \param data The data that should be be written to file
+     * \param index The index of the octant that should be written
+     * \param isFirstWrite Defines if this is the first write to specified octant, if so
      *        the file is created, otherwise the accumulated data is appended to the end
      *        of the file
-     * \param nValuesPerStar the number of values that should be stored per star
+     * \param nValuesPerStar The number of values that should be stored per star
      */
     int writeOctantToFile(const std::vector<float>& data, int index,
         std::vector<bool>& isFirstWrite, int nValuesPerStar);
diff --git a/modules/galaxy/tasks/milkywayconversiontask.h b/modules/galaxy/tasks/milkywayconversiontask.h
index 77ad77d821..cce9b9433b 100644
--- a/modules/galaxy/tasks/milkywayconversiontask.h
+++ b/modules/galaxy/tasks/milkywayconversiontask.h
@@ -35,8 +35,8 @@ namespace openspace {
 namespace documentation { struct Documentation; }
 
 /**
- * Converts a set of exr image slices to a raw volume
- * with floating point RGBA data (32 bit per channel).
+ * Converts a set of exr image slices to a raw volume with floating point RGBA data (32
+ * bit per channel).
  */
 class MilkywayConversionTask : public Task {
 public:
diff --git a/modules/galaxy/tasks/milkywaypointsconversiontask.h b/modules/galaxy/tasks/milkywaypointsconversiontask.h
index a9d866da23..3551443d12 100644
--- a/modules/galaxy/tasks/milkywaypointsconversiontask.h
+++ b/modules/galaxy/tasks/milkywaypointsconversiontask.h
@@ -34,9 +34,11 @@ namespace openspace {
 namespace documentation { struct Documentation; }
 
 /**
- * Converts ascii based point data
+ * Converts ASCII based point data
+ * ```
  * int64_t n
  * (float x, float y, float z, float r, float g, float b) * n
+ * ```
  * to a binary (floating point) representation with the same layout.
  */
 class MilkywayPointsConversionTask : public Task {
diff --git a/modules/globebrowsing/src/asynctiledataprovider.h b/modules/globebrowsing/src/asynctiledataprovider.h
index 10f5dcc204..6f971a52c8 100644
--- a/modules/globebrowsing/src/asynctiledataprovider.h
+++ b/modules/globebrowsing/src/asynctiledataprovider.h
@@ -45,8 +45,8 @@ class AsyncTileDataProvider {
 public:
     /**
      * \param name is the name for this provider
-     * \param rawTileDataReader is the reader that will be used for the asynchronous
-     *        tile loading
+     * \param rawTileDataReader is the reader that will be used for the asynchronous tile
+     *        loading
      */
     AsyncTileDataProvider(std::string name,
         std::unique_ptr<RawTileDataReader> rawTileDataReader);
@@ -81,7 +81,7 @@ protected:
     };
 
     /**
-     * \returns true if tile of index `tileIndex` is not already enqueued.
+     * \return `true` if tile of index \p tileIndex is not already enqueued
      */
     bool satisfiesEnqueueCriteria(const TileIndex& tileIndex);
 
diff --git a/modules/globebrowsing/src/basictypes.h b/modules/globebrowsing/src/basictypes.h
index 6655d2611a..d153c710be 100644
--- a/modules/globebrowsing/src/basictypes.h
+++ b/modules/globebrowsing/src/basictypes.h
@@ -110,7 +110,7 @@ struct TileMetaData {
 
 
 /**
- * Defines a status and may have a Texture and TileMetaData
+ * Defines a status and may have a Texture and TileMetaData.
  */
 class Tile {
 public:
@@ -118,29 +118,21 @@ public:
      * Describe if this Tile is good for usage (OK) or otherwise the reason why it is not.
      */
     enum class Status {
-        /**
-         * E.g when texture data is not currently in memory.
-         * texture and tileMetaData are both null
-         */
+        /// E.g when texture data is not currently in memory.
+        /// `texture` and `tileMetaData` are both `nullptr`
         Unavailable,
 
-        /**
-         * Can be set by `TileProvider`s if the requested `TileIndex` is undefined for
-         * that particular provider.
-         * texture and metaData are both null
-         */
+        /// Can be set by `TileProvider`s if the requested `TileIndex` is undefined for
+        /// that particular provider.
+        /// `texture` and `metaData` are both `nullptr`
         OutOfRange,
 
-        /**
-         * An IO Error happend
-         * texture and metaData are both null
-         */
+        /// An IO Error happend
+        /// `texture` and `metaData` are both `nullptr`
         IOError,
 
-        /**
-         * The Texture is uploaded to the GPU and good for usage.
-         * texture is defined. metaData may be defined.
-         */
+        /// The Texture is uploaded to the GPU and good for usage.
+        /// `texture` is defined. `metaData` may be defined.
         OK
     };
 
diff --git a/modules/globebrowsing/src/ellipsoid.h b/modules/globebrowsing/src/ellipsoid.h
index e7b8c6ec2a..5eea9b2afc 100644
--- a/modules/globebrowsing/src/ellipsoid.h
+++ b/modules/globebrowsing/src/ellipsoid.h
@@ -37,15 +37,17 @@ struct Geodetic3;
 /**
  * This class is based largely on the Ellipsoid class defined in the book
  * "3D Engine Design for Virtual Globes". Most planets or planetary objects are better
- * described using ellipsoids than spheres. All inputs and outputs to this class is
- * based on the WGS84 standard coordinate system where the x-axis points towards
- * geographic (lat = 0, lon = 0), the y-axis points towards (lat = 0, lon = 90deg) and the
- * z-axis points towards the north pole. For other globes than earth of course the radii
- * can differ.
+ * described using ellipsoids than spheres. All inputs and outputs to this class is based
+ * on the WGS84 standard coordinate system where the x-axis points towards geographic
+ * (lat = 0, lon = 0), the y-axis points towards (lat = 0, lon = 90deg) and the z-axis
+ * points towards the north pole. For other globes than earth of course the radii can
+ * differ.
  */
 class Ellipsoid {
 public:
-    // Shadow configuration structure
+    /**
+     * Shadow configuration structure.
+     */
     struct ShadowConfiguration {
         std::pair<std::string, double> source;
         std::pair<std::string, double> caster;
@@ -59,16 +61,18 @@ public:
     /**
      * Scales a point along the geocentric normal and places it on the surface of the
      * Ellipsoid.
+     *
      * \param p is a point in the cartesian coordinate system to be placed on the surface
-     * of the Ellipsoid
+     *        of the Ellipsoid
      */
     glm::dvec3 geocentricSurfaceProjection(const glm::dvec3& p) const;
 
     /**
      * Scales a point along the geodetic normal and places it on the surface of the
      * Ellipsoid.
+     *
      * \param p is a point in the cartesian coordinate system to be placed on the surface
-     * of the Ellipsoid
+     *        of the Ellipsoid
      */
     glm::dvec3 geodeticSurfaceProjection(const glm::dvec3& p) const;
 
diff --git a/modules/globebrowsing/src/gdalwrapper.h b/modules/globebrowsing/src/gdalwrapper.h
index 219dd16661..7db5edad04 100644
--- a/modules/globebrowsing/src/gdalwrapper.h
+++ b/modules/globebrowsing/src/gdalwrapper.h
@@ -41,10 +41,11 @@ class GdalWrapper : public properties::PropertyOwner {
 public:
     /**
      * Create the singleton. Must be called before the class can be used.
-     * \param maximumCacheSize is the current maximum cache size GDAL can use
-     * for caching blocks in memory given in bytes.
-     * \param maximumMaximumCacheSize is the maximum cache size GDAL can use
-     * for caching blocks in memory given in bytes.
+     *
+     * \param maximumCacheSize is the current maximum cache size GDAL can use for caching
+     *        blocks in memory given in bytes
+     * \param maximumMaximumCacheSize is the maximum cache size GDAL can use for caching
+     *        blocks in memory given in bytes
      */
     static void create(size_t maximumCacheSize, size_t maximumMaximumCacheSize);
     static void destroy();
diff --git a/modules/globebrowsing/src/geodeticpatch.h b/modules/globebrowsing/src/geodeticpatch.h
index a3783e033e..3ce392ba82 100644
--- a/modules/globebrowsing/src/geodeticpatch.h
+++ b/modules/globebrowsing/src/geodeticpatch.h
@@ -46,12 +46,12 @@ public:
     void setHalfSize(Geodetic2 halfSize);
 
     /**
-     * Returns the latitude boundary which is closest to the equator
+     * Returns the latitude boundary which is closest to the equator.
      */
     double edgeLatitudeNearestEquator() const;
 
     /**
-     * Returns `true` if the center above the equator
+     * Returns `true` if the center above the equator.
      */
     double isNorthern() const;
 
@@ -63,34 +63,34 @@ public:
     double maxLon() const;
 
     /**
-     * Returns `true` if the specified coordinate is contained within the patch
+     * Returns `true` if the specified coordinate is contained within the patch.
      */
     bool contains(const Geodetic2& p) const;
 
 
     /**
-     * Clamps a point to the patch region
+     * Clamps a point to the patch region.
      */
     Geodetic2 clamp(const Geodetic2& p) const;
 
     /**
-     * Returns the corner of the patch that is closest to the given point p
+     * Returns the corner of the patch that is closest to the given point p.
      */
     Geodetic2 closestCorner(const Geodetic2& p) const;
 
     /**
-     * Returns a point on the patch that minimizes the great-circle distance to
-     * the given point p.
+     * Returns a point on the patch that minimizes the great-circle distance to the given
+     * point p.
      */
     Geodetic2 closestPoint(const Geodetic2& p) const;
 
     /**
-     * Returns the minimum tile level of the patch (based on largest side)
+     * Returns the minimum tile level of the patch (based on largest side).
      */
     double minimumTileLevel() const;
 
     /**
-     * Returns the maximum level of the patch (based on smallest side)
+     * Returns the maximum level of the patch (based on smallest side).
      */
     double maximumTileLevel() const;
 
diff --git a/modules/globebrowsing/src/geojson/geojsoncomponent.h b/modules/globebrowsing/src/geojson/geojsoncomponent.h
index cad6eb9fbb..74747ddfe1 100644
--- a/modules/globebrowsing/src/geojson/geojsoncomponent.h
+++ b/modules/globebrowsing/src/geojson/geojsoncomponent.h
@@ -61,7 +61,7 @@ class RenderableGlobe;
 
 /**
  * A component representing a collection of globe geometry features, whose details
- * are read from a GeoJson file
+ * are read from a GeoJson file.
  */
 class GeoJsonComponent : public properties::PropertyOwner, public Fadeable {
 public:
@@ -82,9 +82,9 @@ public:
 
 private:
     /**
-     * Small helper class whose purpose is to encapsulate properties related to a
-     * specific geomoetry feature, and allow things like flying to or fadin out
-     * individual subfeatures
+     * Small helper class whose purpose is to encapsulate properties related to a specific
+     * geomoetry feature, and allow things like flying to or fadin out individual
+     * subfeatures.
      */
     class SubFeatureProps : public properties::PropertyOwner, public Fadeable {
     public:
@@ -101,8 +101,8 @@ private:
     void parseSingleFeature(const geos::io::GeoJSONFeature& feature, int indexInFile);
 
     /**
-     * Add meta properties to the feature, to allow things like flying to it,
-     * identifying its location, etc
+     * Add meta properties to the feature, to allow things like flying to it, identifying
+     * its location, etc.
      */
     void addMetaPropertiesToFeature(SubFeatureProps& feature, int index,
         const geos::geom::Geometry* geometry);
diff --git a/modules/globebrowsing/src/geojson/geojsonmanager.h b/modules/globebrowsing/src/geojson/geojsonmanager.h
index 7349f60875..6eade5a73d 100644
--- a/modules/globebrowsing/src/geojson/geojsonmanager.h
+++ b/modules/globebrowsing/src/geojson/geojsonmanager.h
@@ -42,7 +42,7 @@ namespace openspace::globebrowsing {
 class RenderableGlobe;
 
 /**
- * Manages multiple GeoJSON objects of a globe
+ * Manages multiple GeoJSON objects of a globe.
  */
 class GeoJsonManager : public properties::PropertyOwner {
 public:
diff --git a/modules/globebrowsing/src/geojson/geojsonproperties.h b/modules/globebrowsing/src/geojson/geojsonproperties.h
index cad7fe5dd1..90ab578079 100644
--- a/modules/globebrowsing/src/geojson/geojsonproperties.h
+++ b/modules/globebrowsing/src/geojson/geojsonproperties.h
@@ -50,14 +50,16 @@ struct GeoJsonProperties : public properties::PropertyOwner {
 
     static documentation::Documentation Documentation();
 
-    // These are based on the KML specification
+    /**
+     * These are based on the KML specification.
+     */
     enum class AltitudeMode {
-        // Compute position as an altitude above the reference ellipsoid
+        /// Compute position as an altitude above the reference ellipsoid
         Absolute = 0,
-        // Compute position using altitude above the height map
+        /// Compute position using altitude above the height map
         RelativeToGround
-        // Stick to planet surface (TODO: use GDAL to render layer instead and use as
-        // default)
+        /// Stick to planet surface (TODO: use GDAL to render layer instead and use as
+        /// default)
         // ClampToGround
     };
 
@@ -120,9 +122,9 @@ struct GeoJsonOverrideProperties {
 GeoJsonOverrideProperties propsFromGeoJson(const geos::io::GeoJSONFeature& feature);
 
 struct PropertySet {
-    // This value set should be a reference to the main component's propertyowner
+    /// This value set should be a reference to the main component's propertyowner
     GeoJsonProperties& defaultValues;
-    // This is a unique set of properties to use for overriding the default values
+    /// This is a unique set of properties to use for overriding the default values
     GeoJsonOverrideProperties overrideValues;
 
     float opacity() const;
diff --git a/modules/globebrowsing/src/geojson/globegeometryfeature.h b/modules/globebrowsing/src/geojson/globegeometryfeature.h
index 07d1c5b634..909abeca76 100644
--- a/modules/globebrowsing/src/geojson/globegeometryfeature.h
+++ b/modules/globebrowsing/src/geojson/globegeometryfeature.h
@@ -49,8 +49,8 @@ namespace openspace::globebrowsing {
 class RenderableGlobe;
 
 /**
- * This class is responsible for rendering the geomoetry features of globes,
- * created e.g. from GeoJson files
+ * This class is responsible for rendering the geomoetry features of globes, created e.g.
+ * from GeoJson files.
  */
 class GlobeGeometryFeature {
 public:
@@ -87,7 +87,9 @@ public:
         Uninitialized
     };
 
-    // Each geometry feature might translate into several render features
+    /**
+     * Each geometry feature might translate into several render features.
+     */
     struct RenderFeature {
         void initializeBuffers();
 
@@ -97,15 +99,17 @@ public:
         size_t nVertices = 0;
         bool isExtrusionFeature = false;
 
-        // Store the geodetic lat long coordinates of each vertex, so we can quickly
-        // recompute the height values for these points
+        /// Store the geodetic lat long coordinates of each vertex, so we can quickly
+        /// recompute the height values for these points
         std::vector<Geodetic2> vertices;
 
-        // Keep the heights around
+        /// Keep the heights around
         std::vector<float> heights;
     };
 
-    // Some extra data that we need for doing the rendering
+    /**
+     * Some extra data that we need for doing the rendering.
+     */
     struct ExtraRenderData {
         float pointSizeScale;
         float lineWidthScale;
@@ -149,58 +153,66 @@ private:
         int renderPass) const;
 
     /**
-     * Create the vertex information for any line parts of the feature.
-     * Returns the resulting vertex positions, so we can use them for extrusion
+     * Create the vertex information for any line parts of the feature. Returns the
+     * resulting vertex positions, so we can use them for extrusion.
      */
     std::vector<std::vector<glm::vec3>> createLineGeometry();
 
     /**
-     * Create the vertex information for any point parts of the feature. Also creates
-     * the features for extruded lines for the points
+     * Create the vertex information for any point parts of the feature. Also creates the
+     * features for extruded lines for the points.
      */
     void createPointGeometry();
 
     /**
-     * Create the triangle geometry for the extruded edges of lines/polygons
+     * Create the triangle geometry for the extruded edges of lines/polygons.
      */
     void createExtrudedGeometry(const std::vector<std::vector<glm::vec3>>& edgeVertices);
 
     /**
      * Create the triangle geometry for the polygon part of the feature (the area
-     * contained by the shape)
+     * contained by the shape).
      */
     void createPolygonGeometry();
 
     void initializeRenderFeature(RenderFeature& feature,
         const std::vector<Vertex>& vertices);
 
-    /// Get the distance that shall be used for tessellation, based on the properties
+    /**
+     * Get the distance that shall be used for tessellation, based on the properties.
+     */
     float tessellationStepSize() const;
 
-    /// Compute the heights to the surface at the reference points
+    /**
+     * Compute the heights to the surface at the reference points.
+     */
     std::vector<double> getCurrentReferencePointsHeights() const;
 
-    /// Buffer the static data for the vertices
+    /**
+     * Buffer the static data for the vertices.
+     */
     void bufferVertexData(const RenderFeature& feature,
         const std::vector<Vertex>& vertexData);
 
-    /// Buffer the dynamic height data for the vertices, based on the height map
+    /**
+     * Buffer the dynamic height data for the vertices, based on the height map.
+     */
     void bufferDynamicHeightData(const RenderFeature& feature);
 
     GeometryType _type = GeometryType::Error;
     const RenderableGlobe& _globe;
 
-    // Coordinates for geometry. For polygons, the first is always the outer ring
-    // and any following are the inner rings (holes)
+    /// Coordinates for geometry. For polygons, the first is always the outer ring and any
+    /// following are the inner rings (holes)
     std::vector<std::vector<Geodetic3>> _geoCoordinates;
 
-    // Coordinates for any triangles representing the geometry (only relevant for
-    // polygons)
+    /// Coordinates for any triangles representing the geometry (only relevant for
+    /// polygons)
     std::vector<Geodetic3> _triangleCoordinates;
 
     std::vector<RenderFeature> _renderFeatures;
 
-    // lat, long, distance (meters). Passed from parent on property change
+    /// lat, long, distance (meters). Passed from parent on property change
     glm::vec3 _offsets = glm::vec3(0.f);
 
     std::string _key;
diff --git a/modules/globebrowsing/src/geojson/globegeometryhelper.h b/modules/globebrowsing/src/geojson/globegeometryhelper.h
index ce1cf8a491..d2a6281a54 100644
--- a/modules/globebrowsing/src/geojson/globegeometryhelper.h
+++ b/modules/globebrowsing/src/geojson/globegeometryhelper.h
@@ -60,21 +60,20 @@ std::vector<Geodetic2> geodetic2FromVertexList(const RenderableGlobe& globe,
 std::vector<float> heightMapHeightsFromGeodetic2List(const RenderableGlobe& globe,
     const std::vector<Geodetic2>& list);
 
-
 /**
- * Create triangle geometry for the extruded edge, given the provided edge vertices
+ * Create triangle geometry for the extruded edge, given the provided edge vertices.
  */
 std::vector<rendering::helper::VertexXYZNormal> createExtrudedGeometryVertices(
     const std::vector<std::vector<glm::vec3>>& edgeVertices);
 
 /**
- * Get height contribution from reference surface of the globe, based on the height map
+ * Get height contribution from reference surface of the globe, based on the height map.
  */
 double getHeightToReferenceSurface(const Geodetic2& geo, const RenderableGlobe& globe);
 
 /**
  * Compute model space cordinate from geodetic coordinate, and account for lat, long
- * offsets
+ * offsets.
  */
 glm::dvec3 computeOffsetedModelCoordinate(const Geodetic3& geo,
     const RenderableGlobe& globe, float latOffset, float lonOffset);
@@ -86,11 +85,11 @@ struct PosHeightPair {
 };
 
 /**
- * Subdivide line between position v0 and v1 so that it fullfils the maxDistance
- * criteria. Interpolate the height value from * h0 to h1, as well as add the
- * given offset and account for the height map if that should be done.
+ * Subdivide line between position v0 and v1 so that it fullfils the maxDistance criteria.
+ * Interpolate the height value from * h0 to h1, as well as add the given offset and
+ * account for the height map if that should be done.
  *
- * Returns pairs of position and height values
+ * \return Pairs of position and height values
  */
 std::vector<PosHeightPair> subdivideLine(const glm::dvec3& v0, const glm::dvec3& v1,
     double h0, double h1, double maxDistance);
@@ -98,7 +97,7 @@ std::vector<PosHeightPair> subdivideLine(const glm::dvec3& v0, const glm::dvec3&
 /**
  * Subdivide triangle consisting of vertex positions v0, v1 and v2, with height values
  * h0, h1 and h2 into smaller triangles. maxDistance specifies tha maximum distance
- * between two vertices in the subdivided mesh
+ * between two vertices in the subdivided mesh.
  */
 std::vector<rendering::helper::VertexXYZNormal> subdivideTriangle(
     const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2,
diff --git a/modules/globebrowsing/src/gpulayergroup.h b/modules/globebrowsing/src/gpulayergroup.h
index dd9f4697a7..b72d4b0a36 100644
--- a/modules/globebrowsing/src/gpulayergroup.h
+++ b/modules/globebrowsing/src/gpulayergroup.h
@@ -45,7 +45,7 @@ struct LayerGroup;
 struct TileIndex;
 
 /**
- * Manages a GPU representation of a `LayerGroup`
+ * Manages a GPU representation of a `LayerGroup`.
  */
 class GPULayerGroup {
 public:
@@ -64,8 +64,8 @@ public:
     void bind(ghoul::opengl::ProgramObject& programObject, const LayerGroup& layerGroup);
 
     /**
-    * Deactivates any `TextureUnit`s assigned by this object.
-    * This method should be called after the OpenGL draw call.
+    * Deactivates any `TextureUnit`s assigned by this object. This method should be called
+    * after the OpenGL draw call.
     */
     void deactivate();
 
diff --git a/modules/globebrowsing/src/layergroup.h b/modules/globebrowsing/src/layergroup.h
index 899fbbeac0..8ca76d6c31 100644
--- a/modules/globebrowsing/src/layergroup.h
+++ b/modules/globebrowsing/src/layergroup.h
@@ -46,20 +46,28 @@ struct LayerGroup : public properties::PropertyOwner {
     void initialize();
     void deinitialize();
 
-    /// Updates all layers tile providers within this group
+    /**
+     * Updates all layers tile providers within this group.
+     */
     void update();
 
     Layer* addLayer(const ghoul::Dictionary& layerDict);
     void deleteLayer(const std::string& layerName);
     void moveLayer(int oldPosition, int newPosition);
 
-    /// @returns const vector of all layers
+    /**
+     * \return const vector of all layers
+     */
     std::vector<Layer*> layers() const;
 
-    /// @returns const vector of all active layers
+    /**
+     * \return const vector of all active layers
+     */
     const std::vector<Layer*>& activeLayers() const;
 
-    /// @returns the size of the pile to be used in rendering of this layer
+    /**
+     * \return the size of the pile to be used in rendering of this layer
+     */
     int pileSize() const;
 
     bool layerBlendingEnabled() const;
diff --git a/modules/globebrowsing/src/layerrendersettings.h b/modules/globebrowsing/src/layerrendersettings.h
index 69ffad1a50..493a65170f 100644
--- a/modules/globebrowsing/src/layerrendersettings.h
+++ b/modules/globebrowsing/src/layerrendersettings.h
@@ -42,11 +42,14 @@ struct LayerRenderSettings : public properties::PropertyOwner {
 
     void onChange(std::function<void()> callback);
 
-    /// This function matches the function with the same name in the
-    /// shader code
+    /**
+     * This function matches the function with the same name in the shader code.
+     */
     float performLayerSettings(float value) const;
-    /// This function matches the function with the same name in the
-    /// shader code
+
+    /**
+     * This function matches the function with the same name in the shader code.
+     */
     glm::vec4 performLayerSettings(const glm::vec4& currentValue) const;
 };
 
diff --git a/modules/globebrowsing/src/lrucache.h b/modules/globebrowsing/src/lrucache.h
index ed9e21ef74..3212cf75bf 100644
--- a/modules/globebrowsing/src/lrucache.h
+++ b/modules/globebrowsing/src/lrucache.h
@@ -32,8 +32,8 @@
 namespace openspace::globebrowsing::cache {
 
 /**
- * Templated class implementing a Least-Recently-Used Cache.
- * `KeyType` needs to be an enumerable type.
+ * Templated class implementing a Least-Recently-Used Cache. `KeyType` needs to be an
+ * enumerable type.
  */
 template <typename KeyType, typename ValueType, typename HasherType>
 class LRUCache {
@@ -42,7 +42,7 @@ public:
     using Items = std::list<Item>;
 
     /**
-     * \param size is the maximum size of the cache given in number of cached items.
+     * \param size This is the maximum size of the cache given in number of cached items
      */
     LRUCache(size_t size);
 
@@ -53,7 +53,8 @@ public:
 
     /**
      * If value exists, the value is bumped to the front of the queue.
-     * \returns true if value of this key exists.
+     *
+     * \return `true` if value of this key exists
      */
     bool touch(const KeyType& key);
     bool isEmpty() const;
diff --git a/modules/globebrowsing/src/lruthreadpool.h b/modules/globebrowsing/src/lruthreadpool.h
index 3b64ab386e..a86fc02d2e 100644
--- a/modules/globebrowsing/src/lruthreadpool.h
+++ b/modules/globebrowsing/src/lruthreadpool.h
@@ -49,14 +49,14 @@ private:
 };
 
 /**
- * The `LRUThreadPool` will only enqueue a certain number of tasks. The most
- * recently enqueued task is the one that will be executed first. This class is templated
- * on a key type which used as an identifier to determine wheter or not a task with the
- * given key has been enqueued or not. This means that a task can be enqueued several
- * times. The user must ensure that an enqueued task with a given key should be equal in
- * outcome to a second enqueued task with the same key. This is because a second enqueued
- * task with the same key will simply be bumped and prioritised before other enqueued
- * tasks. The given task will be ignored.
+ * The `LRUThreadPool` will only enqueue a certain number of tasks. The most recently
+ * enqueued task is the one that will be executed first. This class is templated on a key
+ * type which used as an identifier to determine wheter or not a task with the given key
+ * has been enqueued or not. This means that a task can be enqueued several times. The
+ * user must ensure that an enqueued task with a given key should be equal in outcome to a
+ * second enqueued task with the same key. This is because a second enqueued task with the
+ * same key will simply be bumped and prioritised before other enqueued tasks. The given
+ * task will be ignored.
  */
 template<typename KeyType>
 class LRUThreadPool {
diff --git a/modules/globebrowsing/src/memoryawaretilecache.h b/modules/globebrowsing/src/memoryawaretilecache.h
index 0a9f6f5431..4bd2810f9e 100644
--- a/modules/globebrowsing/src/memoryawaretilecache.h
+++ b/modules/globebrowsing/src/memoryawaretilecache.h
@@ -107,8 +107,8 @@ private:
     class TextureContainer {
     public:
         /**
-         * \param initData is the description of the texture type.
-         * \param numTextures is the number of textures to allocate.
+         * \param initData is the description of the texture type
+         * \param numTextures is the number of textures to allocate
          */
         TextureContainer(TileTextureInitData initData, size_t numTextures);
 
diff --git a/modules/globebrowsing/src/prioritizingconcurrentjobmanager.h b/modules/globebrowsing/src/prioritizingconcurrentjobmanager.h
index f16ba1a79a..6f452f888d 100644
--- a/modules/globebrowsing/src/prioritizingconcurrentjobmanager.h
+++ b/modules/globebrowsing/src/prioritizingconcurrentjobmanager.h
@@ -45,7 +45,7 @@ public:
     PrioritizingConcurrentJobManager(LRUThreadPool<KeyType> pool);
 
     /**
-     * Enqueues a job which is identified using a given key
+     * Enqueues a job which is identified using a given key.
      */
     void enqueueJob(std::shared_ptr<Job<P>> job, KeyType key);
 
@@ -60,11 +60,11 @@ public:
     std::vector<KeyType> keysToEnqueuedJobs();
 
     /**
-     * Bumps the job identified with `key` to the beginning of the queue.
-     * In case the job was not already enqueued the function simply returns false and
-     * no state is changed.
-     * \param key is the identifier of the job to bump.
-     * \returns true if the job was found, else returns false.
+     * Bumps the job identified with `key` to the beginning of the queue. In case the job
+     * was not already enqueued the function simply returns false and no state is changed.
+     *
+     * \param key this is the identifier of the job to bump
+     * \return `true` if the job was found, else returns false
      */
     bool touch(KeyType key);
 
@@ -76,7 +76,7 @@ public:
     void clearEnqueuedJobs();
 
     /**
-     * \returns one finished job.
+     * \return one finished job
      */
     std::shared_ptr<Job<P>> popFinishedJob();
 
@@ -85,7 +85,7 @@ public:
 private:
     ConcurrentQueue<std::shared_ptr<Job<P>>> _finishedJobs;
     std::mutex _finishedJobsMutex;
-    /// An LRU thread pool is used since the jobs can be bumped and hence prioritized.
+    /// An LRU thread pool is used since the jobs can be bumped and hence prioritized
     LRUThreadPool<KeyType> _threadPool;
 };
 
diff --git a/modules/globebrowsing/src/renderableglobe.h b/modules/globebrowsing/src/renderableglobe.h
index 5c0654f5a4..7d5a6927ba 100644
--- a/modules/globebrowsing/src/renderableglobe.h
+++ b/modules/globebrowsing/src/renderableglobe.h
@@ -156,38 +156,35 @@ private:
     properties::PropertyOwner _shadowMappingPropertyOwner;
 
     /**
-     * Test if a specific chunk can safely be culled without affecting the rendered
-     * image.
+     * Test if a specific chunk can safely be culled without affecting the rendered image.
      *
-     * Goes through all available `ChunkCuller`s and check if any of them
-     * allows culling of the `Chunk`s in question.
+     * Goes through all available `ChunkCuller`s and check if any of them allows culling
+     * of the `Chunk`s in question.
      */
     bool testIfCullable(const Chunk& chunk, const RenderData& renderData,
         const BoundingHeights& heights, const glm::dmat4& mvp) const;
 
     /**
-     * Gets the desired level which can be used to determine if a chunk should split
-     * or merge.
+     * Gets the desired level which can be used to determine if a chunk should split or
+     * merge.
      *
-     * Using `ChunkLevelEvaluator`s, the desired level can be higher or
-     * lower than the current level of the `Chunks`s
-     * `TileIndex`. If the desired level is higher than that of the
-     * `Chunk`, it wants to split. If it is lower, it wants to merge with
-     * its siblings.
+     * Using `ChunkLevelEvaluator`s, the desired level can be higher or lower than the
+     * current level of the `Chunks`s `TileIndex`. If the desired level is higher than
+     * that of the `Chunk`, it wants to split. If it is lower, it wants to merge with its
+     * siblings.
      */
     int desiredLevel(const Chunk& chunk, const RenderData& renderData,
         const BoundingHeights& heights) const;
 
     /**
-     * Calculates the height from the surface of the reference ellipsoid to the
-     * height mapped surface.
+     * Calculates the height from the surface of the reference ellipsoid to the height
+     * mapped surface.
      *
      * The height can be negative if the height map contains negative values.
      *
-     * \param `position` is the position of a point that gets geodetically
-     * projected on the reference ellipsoid. `position` must be in
-     * cartesian model space.
-     * \returns the height from the reference ellipsoid to the globe surface.
+     * \param `position` is the position of a point that gets geodetically projected on
+     *        the reference ellipsoid. `position` must be in Cartesian model space
+     * \return The height from the reference ellipsoid to the globe surface
      */
     float getHeight(const glm::dvec3& position) const;
 
@@ -197,26 +194,26 @@ private:
 
     /**
      * Chunks can be rendered either globally or locally. Global rendering is performed
-     * in the model space of the globe. With global rendering, the vertex positions
-     * of a chunk are calculated in the vertex shader by transforming the geodetic
-     * coordinates of the chunk to model space coordinates. We can only achieve floating
-     * point precision by doing this which means that the camera too close to a global
-     * tile will lead to jagging. We only render global chunks for lower chunk levels.
+     * in the model space of the globe. With global rendering, the vertex positions of a
+     * chunk are calculated in the vertex shader by transforming the geodetic coordinates
+     * of the chunk to model space coordinates. We can only achieve floating point
+     * precision by doing this which means that the camera too close to a global tile will
+     * lead to jagging. We only render global chunks for lower chunk levels.
      */
     void renderChunkGlobally(const Chunk& chunk, const RenderData& data,
         const ShadowComponent::ShadowMapData& shadowData = {}, bool renderGeomOnly = false
     );
 
     /**
-     * Local rendering of chunks are done using linear interpolation in camera space.
-     * All four corner points of the chunk are calculated in double precision on the
-     * CPU and transformed to camera space with double precision matrix transforms.
-     * These positions can then be cast to floats and uploaded to the vertex shader.
-     * The vertex shader rendering performs linear interpolation between the four
-     * corner points to get the resulting chunk. This means that there will be an error
-     * due to the curvature of the globe. The smaller the patch is (with higher chunk
-     * levels) the better the approximation becomes. This is why we only render local
-     * chunks for higher chunk levels.
+     * Local rendering of chunks are done using linear interpolation in camera space. All
+     * four corner points of the chunk are calculated in double precision on the CPU and
+     * transformed to camera space with double precision matrix transforms. These
+     * positions can then be cast to floats and uploaded to the vertex shader. The vertex
+     * shader rendering performs linear interpolation between the four corner points to
+     * get the resulting chunk. This means that there will be an error due to the
+     * curvature of the globe. The smaller the patch is (with higher chunk levels) the
+     * better the approximation becomes. This is why we only render local chunks for
+     * higher chunk levels.
      */
     void renderChunkLocally(const Chunk& chunk, const RenderData& data,
         const ShadowComponent::ShadowMapData& shadowData = {}, bool renderGeomOnly = false
diff --git a/modules/globebrowsing/src/shadowcomponent.h b/modules/globebrowsing/src/shadowcomponent.h
index 8293e0e82a..89beb5f598 100644
--- a/modules/globebrowsing/src/shadowcomponent.h
+++ b/modules/globebrowsing/src/shadowcomponent.h
@@ -63,7 +63,6 @@ public:
     void initialize();
     void initializeGL();
     void deinitializeGL();
-    //bool deinitialize();
 
     bool isReady() const;
 
diff --git a/modules/globebrowsing/src/skirtedgrid.h b/modules/globebrowsing/src/skirtedgrid.h
index ed5bd54885..4175f66b8a 100644
--- a/modules/globebrowsing/src/skirtedgrid.h
+++ b/modules/globebrowsing/src/skirtedgrid.h
@@ -39,8 +39,8 @@ namespace openspace::globebrowsing {
 class SkirtedGrid {
 public:
     /**
-     * \param xSegments is the number of grid cells in the x direction.
-     * \param ySegments is the number of grid cells in the y direction.
+     * \param xSegments is the number of grid cells in the x direction
+     * \param ySegments is the number of grid cells in the y direction
      */
     SkirtedGrid(unsigned int xSegments, unsigned int ySegments);
     ~SkirtedGrid() = default;
@@ -50,11 +50,10 @@ public:
 
     /**
      * Calls OpenGL's draw function to draw the triangles defined in the vertex buffers
-     * using the current bound program object.
-     * The vertex buffer attribute input locations to the shader program comes in the
-     * order of positions (0), texture coordinates (1) and normals (2).
-     * The input locations in the shader program should be specified to match these
-     * locations.
+     * using the current bound program object. The vertex buffer attribute input locations
+     * to the shader program comes in the order of positions (0), texture coordinates (1)
+     * and normals (2). The input locations in the shader program should be specified to
+     * match these locations.
      */
     void drawUsingActiveProgram() const;
 
diff --git a/modules/globebrowsing/src/tileloadjob.h b/modules/globebrowsing/src/tileloadjob.h
index b09c9ef827..ab728afd98 100644
--- a/modules/globebrowsing/src/tileloadjob.h
+++ b/modules/globebrowsing/src/tileloadjob.h
@@ -36,10 +36,10 @@ class RawTileDataReader;
 
 struct TileLoadJob : public Job<RawTile> {
     /**
-     * Allocates enough data for one tile. When calling `product()`, the
-     * ownership of this data will be released. If `product()` has not been
-     * called before the TileLoadJob is finished, the data will be deleted as it has not
-     * been exposed outside of this object.
+     * Allocates enough data for one tile. When calling #product, the ownership of this
+     * data will be released. If `product()` has not been called before the TileLoadJob is
+     * finished, the data will be deleted as it has not been exposed outside of this
+     * object.
      */
     TileLoadJob(RawTileDataReader& rawTileDataReader, TileIndex tileIndex);
 
@@ -57,10 +57,9 @@ struct TileLoadJob : public Job<RawTile> {
     void execute() override;
 
     /**
-    * Marks the job as finised and releases ownership of the data.
-    * Unless the job is marked as finished, the pixel data will be deallocated
-    * when the job is deleted.
-    */
+     * Marks the job as finised and releases ownership of the data. Unless the job is
+     * marked as finished, the pixel data will be deallocated when the job is deleted.
+     */
     RawTile product() override;
 
 protected:
diff --git a/modules/globebrowsing/src/tileprovider/temporaltileprovider.h b/modules/globebrowsing/src/tileprovider/temporaltileprovider.h
index 5c62fe68aa..7abb920d5d 100644
--- a/modules/globebrowsing/src/tileprovider/temporaltileprovider.h
+++ b/modules/globebrowsing/src/tileprovider/temporaltileprovider.h
@@ -39,8 +39,9 @@ namespace openspace::globebrowsing {
  * filepath to a Openspace Temporal dataset description file. This is an xml-file that
  * defines the same meta data as the GDAL wms description
  * (http://www.gdal.org/frmt_wms.html), but augmented with some extra tags describing the
- * temporal properties of the dataset. See
- * `TemporalTileProvider::TemporalXMLTags`
+ * temporal properties of the dataset.
+ *
+ * \sa TemporalTileProvider::TemporalXMLTags
  */
 class TemporalTileProvider : public TileProvider {
 public:
diff --git a/modules/globebrowsing/src/tileprovider/tileprovider.h b/modules/globebrowsing/src/tileprovider/tileprovider.h
index 3aef466827..33a1c58c42 100644
--- a/modules/globebrowsing/src/tileprovider/tileprovider.h
+++ b/modules/globebrowsing/src/tileprovider/tileprovider.h
@@ -115,19 +115,19 @@ struct TileProvider : public properties::PropertyOwner {
     virtual void reset() = 0;
 
     /**
-     * \return The minimum level as defined by the `TileIndex` that this
-     *         TileProvider is capable of providing.
+     * \return The minimum level as defined by the `TileIndex` that this TileProvider is
+     *         capable of providing
      */
     virtual int minLevel() = 0;
 
     /**
-     * \return The maximum level as defined by `TileIndex` that this
-     *         TileProvider is able provide.
+     * \return The maximum level as defined by `TileIndex` that this TileProvider is able
+     *         to provide
      */
     virtual int maxLevel() = 0;
 
     /**
-     * \return the no data value for the dataset. Default is the minimum float value.
+     * \return The no data value for the dataset. Default is the minimum float value
      */
     virtual float noDataValueAsFloat() = 0;
 
diff --git a/modules/globebrowsing/src/tiletextureinitdata.h b/modules/globebrowsing/src/tiletextureinitdata.h
index 2aa7925098..201a004e82 100644
--- a/modules/globebrowsing/src/tiletextureinitdata.h
+++ b/modules/globebrowsing/src/tiletextureinitdata.h
@@ -33,8 +33,9 @@
 
 namespace openspace::globebrowsing {
 
-
-/// All information needed to create a texture used for a Tile.
+/**
+ * All information needed to create a texture used for a Tile.
+ */
 class TileTextureInitData {
 public:
     using HashKey = uint64_t;
diff --git a/modules/globebrowsing/src/timequantizer.h b/modules/globebrowsing/src/timequantizer.h
index cae3ea89e1..b56e1dfc10 100644
--- a/modules/globebrowsing/src/timequantizer.h
+++ b/modules/globebrowsing/src/timequantizer.h
@@ -35,8 +35,8 @@ namespace openspace::globebrowsing {
 
 /**
  * RangedTime class is used to define an acceptable time range. Functionality includes
- * checking if a given date/time is within that range, or clamping a date to enforce
- * this range.
+ * checking if a given date/time is within that range, or clamping a date to enforce this
+ * range.
  */
 class RangedTime {
 public:
@@ -46,8 +46,8 @@ public:
      * Constructor that accepts an ISO8601 date/time string (`YYYY-MM-DDTHH:mm:ss`) for an
      * allowable time range defined by start and end values.
      *
-     * \param start The date/time start of the time range.
-     * \param end   The date/time ending of the time range.
+     * \param start The date/time start of the time range
+     * \param end The date/time ending of the time range
      */
     RangedTime(std::string start, std::string end);
 
@@ -56,18 +56,18 @@ public:
      * instance of the class.
      *
      * \param checkTime The time to test if it falls within the range
-     * \return true if the input date/time falls between the start and end date/times
-    */
+     * \return `true` if the input date/time falls between the start and end date/times
+     */
     bool includes(const Time& checkTime) const;
 
     /**
-     * Enforces the start/end range on a given date/time string by clamping the value
+     * Enforces the start/end range on a given date/time string by clamping the value.
      *
      * \param checkTime An ISO8601 date/time string to clamp if falls outside of range
-     * \return clamped value of input parameter, will be equal to the start value if
-     *         less than start, equal to end if greater than end, or equal to input
-     *         parameter if falls in-between
-    */
+     * \return Clamped value of input parameter, will be equal to the start value if less
+     *         than start, equal to end if greater than end, or equal to input parameter
+     *         if falls in-between
+     */
     const char* clamp(const char* checkTime);
 
     /**
@@ -78,21 +78,21 @@ public:
     std::string_view start() const;
 
     /**
-     * Get the end date/time of the time range
+     * Get the end date/time of the time range.
      *
      * \return The ISO8601 date/time string that defines the end of the range
      */
     std::string_view end() const;
 
     /**
-     * Set the start date/time of the time range
+     * Set the start date/time of the time range.
      *
      * \param start The ISO8601 date/time string that defines the start of the range
      */
     void setStart(const std::string start);
 
     /**
-     * Set the end date/time of the time range
+     * Set the end date/time of the time range.
      *
      * \param start The ISO8601 date/time string that defines the end of the range
      */
@@ -109,6 +109,7 @@ private:
  * DateTime class is used to manage a date/time value and provide methods for increment/
  * decrementing the value, which gets complicated because of the varying days of the
  * different months, leap years, etc.
+ *
  * This class exists to handle date/time values within a "people-friendly" calendar
  * schedule. For example, a temporal data set that's updated on the 10th of every month
  * will sometimes be updated in 28 days, other times in 31 days. The intent of the class
@@ -120,27 +121,27 @@ public:
     /**
      * Constructor that initializes with date/time string.
      *
-     * \param initDateTime the ISO8601 date/time string (`YYYY-MM-DDTHH:mm:ss`)
+     * \param initDateTime The ISO8601 date/time string (`YYYY-MM-DDTHH:mm:ss`)
      */
     DateTime(std::string_view initDateTime);
 
     /**
      * Set the date/time value.
      *
-     * \param input the ISO8601 date/time string (`YYYY-MM-DDTHH:mm:ss`) to set
+     * \param input The ISO8601 date/time string (`YYYY-MM-DDTHH:mm:ss`) to set
      */
     void setTime(std::string_view input);
 
     /**
      * Get the date/time value in ISO8601 format.
      *
-     * \return the date/time value string
+     * \return The date/time value string
      */
     std::string ISO8601() const;
 
     /**
-     * Get the J2000 seconds equivalent of the object's date/time, using
-     * the loaded SPICE kernel.
+     * Get the J2000 seconds equivalent of the object's date/time, using the loaded
+     * SPICE kernel.
      *
      * \return J2000 seconds of date/time
      */
@@ -149,110 +150,110 @@ public:
     /**
      * Get the year of the object's date/time (YYYY format).
      *
-     * \return integer value of the year
+     * \return Integer value of the year
      */
     int year() const;
 
     /**
      * Get the month of the object's date/time (1 - 12).
      *
-     * \return integer value of the month
+     * \return Integer value of the month
      */
     int month() const;
 
     /**
      * Get the day-of-month of the object's date/time (1 - 31).
      *
-     * \return integer value of the day
+     * \return Integer value of the day
      */
     int day() const;
 
     /**
-     * Get the hour of the object's date/time
+     * Get the hour of the object's date/time.
      *
-     * \return integer value of the hour (0 - 23)
+     * \return Integer value of the hour (0 - 23)
      */
     int hour() const;
 
     /**
-     * Get the minute of the object's date/time
+     * Get the minute of the object's date/time.
      *
-     * \return integer value of the minutes
+     * \return Integer value of the minutes
      */
     int minute() const;
 
     /**
-     * Get the seconds of the object's date/time
+     * Get the seconds of the object's date/time.
      *
-     * \return integer value of the seconds
+     * \return Integer value of the seconds
      */
     int second() const;
 
     /**
-     * Set the year of the object's date/time
+     * Set the year of the object's date/time.
      *
-     * \param y integer value of the year
+     * \param y Integer value of the year
      */
     void setYear(int y);
 
     /**
-     * Set the month of the object's date/time (1 - 12)
+     * Set the month of the object's date/time (1 - 12).
      *
-     * \param m integer value of the year
+     * \param m Integer value of the year
      */
     void setMonth(int m);
 
     /**
-     * Set the day-of-month of the object's date/time (1 - 31)
+     * Set the day-of-month of the object's date/time (1 - 31).
      *
-     * \param d integer value of the day
+     * \param d Integer value of the day
      */
     void setDay(int d);
 
     /**
-     * Set the hour of the object's date/time (0 - 23)
+     * Set the hour of the object's date/time (0 - 23).
      *
-     * \param h integer value of the hour
+     * \param h Integer value of the hour
      */
     void setHour(int h);
 
     /**
-     * Set the minute of the object's date/time
+     * Set the minute of the object's date/time.
      *
-     * \param m integer value of the minute
+     * \param m Integer value of the minute
      */
     void setMinute(int m);
 
     /**
-     * Set the seconds of the object's date/time
+     * Set the seconds of the object's date/time.
      *
-     * \param s integer value of the seconds
+     * \param s Integer value of the seconds
      */
     void setSecond(int s);
 
     /**
-     * Increment operation for the date/time
+     * Increment operation for the date/time.
      *
      * \param value integer value for number of units in an operation
      * \param unit single char that specifies the unit of increment. Allowable units are:
-     *             (y)ear, (M)onth, (d)ay, (h)our, (m)inute, (s)econd
-     * \param error The difference in J2000 seconds from current date/time to target
-     *              (a positive value means target is in the future)
+     *        (y)ear, (M)onth, (d)ay, (h)our, (m)inute, (s)econd
+     * \param error The difference in J2000 seconds from current date/time to target (a
+     *        positive value means target is in the future)
      * \param resolution The J2000 seconds of the interval defined by the value & unit
      * \return The number of increments that were performed in order to get as close as
-     *         possible to the target, where each increment is defined by the value &
-     *         unit (and approximated but not fixed by the resolution param)
+     *         possible to the target, where each increment is defined by the value & unit
+     *         (and approximated but not fixed by the resolution param)
      */
     int increment(int value, char unit, double error, double resolution);
 
     /**
-     * Decrement operation for the date/time
+     * Decrement operation for the date/time.
      *
      * \param value integer value for number of units in an operation
      * \param unit single char that specifies the unit of decrement. Allowable units are:
-     *             (y)ear, (M)onth, (d)ay, (h)our, (m)inute, (s)econd
-     * \param error The difference in J2000 seconds from current date/time to target
-     *              (a positive value means target is in the future)
+     *        (y)ear, (M)onth, (d)ay, (h)our, (m)inute, (s)econd
+     * \param error The difference in J2000 seconds from current date/time to target (a
+     *        positive value means target is in the future)
      * \param resolution The J2000 seconds of the interval defined by the value & unit
      * \return The number of decrements that were performed in order to get as close as
      *         possible to the target, where each decrement is defined by the value &
@@ -261,20 +262,20 @@ public:
     int decrement(int value, char unit, double error, double resolution);
 
     /**
-     * Single increment operation for the date/time
+     * Single increment operation for the date/time.
      *
      * \param value integer value for number of units in an operation
      * \param unit single char that specifies the unit of increment. Allowable units are:
-     *             (y)ear, (M)onth, (d)ay, (h)our, (m)inute, (s)econd
+     *        (y)ear, (M)onth, (d)ay, (h)our, (m)inute, (s)econd
      */
     void incrementOnce(int value, char unit);
 
     /**
-     * Single decrement operation for the date/time
+     * Single decrement operation for the date/time.
      *
      * \param value integer value for number of units in an operation
      * \param unit single char that specifies the unit of decrement. Allowable units are:
-     *             (y)ear, (M)onth, (d)ay, (h)our, (m)inute, (s)econd
+     *        (y)ear, (M)onth, (d)ay, (h)our, (m)inute, (s)econd
      */
     void decrementOnce(int value, char unit);
 
@@ -296,7 +297,7 @@ public:
 
     /**
      * Constructor that initializes with formatted strings for start & ends date/times,
-     * and a time resolution within that range
+     * and a time resolution within that range.
      *
      * \param start the ISO8601 date/time string (YYYY-MM-DDTHH:mm:ss) for start
      * \param end the ISO8601 date/time string (YYYY-MM-DDTHH:mm:ss) for end
@@ -314,27 +315,27 @@ public:
      * Set the time range start & end date/time range.
      *
      * \param start The ISO8601 date/time string for start of the time range
-     * \param end The ISO8601 date/time string for end of the time range.
+     * \param end The ISO8601 date/time string for end of the time range
      */
     void setStartEndRange(const std::string& start, const std::string& end);
 
     /**
-     * Set the time resolution
+     * Set the time resolution.
      *
-     * \param resolutionString String that defines the resolution within the time range.
-     *        see comment header for constructor for the allowable values and ranges.
+     * \param resolutionString String that defines the resolution within the time range
+     *        see comment header for constructor for the allowable values and ranges
      */
     void setResolution(const std::string& resolutionString);
 
     /**
-     * Takes a time resulition string and parses it into a double
-     * value representing the time resolution as seconds.
+     * Takes a time resulition string and parses it into a double value representing the
+     * time resolution as seconds.
      *
      * Example: parseTimeResolutionStr("1d");
      *
-     * \param resolutionStr with the format {number}{unit} where supported units are:
-     *        (s)econds, (m)inutes, (h)ours, (d)ays, (y)ears
-     * \return the time resolution in seconds
+     * \param resolutionStr String with the format {number}{unit} where supported units
+     *        are: (s)econds, (m)inutes, (h)ours, (d)ays, (y)ears
+     * \return The time resolution in seconds
      */
     double parseTimeResolutionStr(const std::string& resolutionStr);
 
@@ -344,7 +345,7 @@ public:
      *
      * \param t Time instance, which will be quantized
      * \param clamp Whether or not time should be clamped if not t is in the time range
-     * \return wether or not time was quantized
+     * \return Whether or not time was quantized
      */
     bool quantize(Time& t, bool clamp);
 
diff --git a/modules/imgui/include/guicomponent.h b/modules/imgui/include/guicomponent.h
index dbbc30592c..75c42f6224 100644
--- a/modules/imgui/include/guicomponent.h
+++ b/modules/imgui/include/guicomponent.h
@@ -37,7 +37,9 @@ class GUI;
  */
 class GuiComponent : public properties::PropertyOwner {
 public:
-    /// Constructor that initializes this components member variables
+    /**
+     * Constructor that initializes this components member variables.
+     */
     GuiComponent(std::string identifier, std::string guiName = "");
 
     /**
@@ -56,19 +58,29 @@ public:
      */
     void setEnabled(bool enabled);
 
-    /// Initializes the component with everything that does not require an OpenGL context
+    /**
+     * Initializes the component with everything that does not require an OpenGL context.
+     */
     virtual void initialize();
 
-    /// Initializes the component with everything that requires an OpenGL context
+    /**
+     * Initializes the component with everything that requires an OpenGL context.
+     */
     virtual void initializeGL();
 
-    /// Deinitializes the component with things that do not require an OpenGL context
+    /**
+     * Deinitializes the component with things that do not require an OpenGL context.
+     */
     virtual void deinitialize();
 
-    /// Deinitializes the component with things that require an OpenGL context
+    /**
+     * Deinitializes the component with things that require an OpenGL context.
+     */
     virtual void deinitializeGL();
 
-    /// Renders the individual subcomponents to the screen
+    /**
+     * Renders the individual subcomponents to the screen.
+     */
     virtual void render() = 0;
 
     void setShowHelpTooltip(bool showHelpTooltip);
diff --git a/modules/iswa/rendering/datacygnet.h b/modules/iswa/rendering/datacygnet.h
index b0b8d5d502..6398262ccc 100644
--- a/modules/iswa/rendering/datacygnet.h
+++ b/modules/iswa/rendering/datacygnet.h
@@ -39,7 +39,7 @@ class DataProcessor;
 /**
  * This class abstracts away the the loading of data and creation of textures for all data
  * cygnets. It specifies the interface that needs to be implemented for all concrete
- * subclasses
+ * subclasses.
  */
 class DataCygnet : public IswaCygnet {
 public:
@@ -69,13 +69,13 @@ protected:
     void setPropertyCallbacks();
 
     /**
-     * Subscribes to the group events that are shared by all DataCygnets
+     * Subscribes to the group events that are shared by all DataCygnets.
      */
     void subscribeToGroup();
 
     /**
      * Optional interface method. this has an implementation in datacygnet.cpp, but needs
-     * to be overriden for kameleonplane
+     * to be overriden for KameleonPlane.
      */
     virtual bool updateTextureResource() override;
 
diff --git a/modules/iswa/rendering/dataplane.h b/modules/iswa/rendering/dataplane.h
index 630ca66216..6d1f8dbf65 100644
--- a/modules/iswa/rendering/dataplane.h
+++ b/modules/iswa/rendering/dataplane.h
@@ -46,7 +46,7 @@ public:
 
 private:
     /**
-     * Creates a plane geometry
+     * Creates a plane geometry.
      */
     bool createGeometry() override;
     bool destroyGeometry() override;
diff --git a/modules/iswa/rendering/datasphere.h b/modules/iswa/rendering/datasphere.h
index 8bbe370496..91244a6120 100644
--- a/modules/iswa/rendering/datasphere.h
+++ b/modules/iswa/rendering/datasphere.h
@@ -45,7 +45,7 @@ public:
 
 protected:
     /**
-     * Creates a sphere geometry
+     * Creates a sphere geometry.
      */
     bool createGeometry() override;
     bool destroyGeometry() override;
diff --git a/modules/iswa/rendering/iswacygnet.h b/modules/iswa/rendering/iswacygnet.h
index 946ac3fa8d..2a765b9b90 100644
--- a/modules/iswa/rendering/iswacygnet.h
+++ b/modules/iswa/rendering/iswacygnet.h
@@ -74,7 +74,7 @@ protected:
 
     /**
      * Registers the properties that are equal in all IswaCygnets regardless of being part
-     * of a group or not
+     * of a group or not.
      */
     virtual void registerProperties();
     virtual void unregisterProperties();
@@ -114,7 +114,7 @@ protected:
     virtual bool readyToRender() const = 0;
 
     /**
-     * Should set all uniforms needed to render
+     * Should set all uniforms needed to render.
      */
     virtual void setUniforms() = 0;
 
diff --git a/modules/iswa/rendering/kameleonplane.h b/modules/iswa/rendering/kameleonplane.h
index 547fe3204d..945428b776 100644
--- a/modules/iswa/rendering/kameleonplane.h
+++ b/modules/iswa/rendering/kameleonplane.h
@@ -49,7 +49,7 @@ public:
 
 private:
     /**
-     * Creates a plane geometry
+     * Creates a plane geometry.
      */
     bool createGeometry() override;
     bool destroyGeometry() override;
@@ -62,7 +62,7 @@ private:
 
     /**
      * Given a path to the json index of seedpoints file, this method reads, parses and
-     * adds them as checkbox options in the _fieldlines SelectionProperty
+     * adds them as checkbox options in the _fieldlines SelectionProperty.
      *
      * \param indexFile Path to json index file
      */
@@ -94,9 +94,8 @@ private:
     /**
      * _fieldlineState maps the checkbox value of each fieldline seedpoint file to a tuple
      * containing information that is needed to either add or remove a fieldline from the
-     * scenegraph.
-     * This is the name, path to seedpoints file and a boolean to determine if it is
-     * active or inactive.
+     * scenegraph. This is the name, path to seedpoints file and a boolean to determine if
+     * it is active or inactive.
      */
     std::map<int, std::tuple<std::string, std::string, bool>> _fieldlineState;
     std::string _fieldlineIndexFile;
diff --git a/modules/iswa/rendering/texturecygnet.h b/modules/iswa/rendering/texturecygnet.h
index 6613390945..95e38d06e6 100644
--- a/modules/iswa/rendering/texturecygnet.h
+++ b/modules/iswa/rendering/texturecygnet.h
@@ -30,10 +30,9 @@
 namespace openspace {
 
 /**
- * This class exist to abstract away the loading of images
- * from iSWA and updating of the textures for child geometries.
- * The class specifies the minimum interface that child classes
- * needs to implement.
+ * This class exist to abstract away the loading of images from iSWA and updating of the
+ * textures for child geometries. The class specifies the minimum interface that child
+ * classes needs to implement.
  */
 class TextureCygnet : public IswaCygnet {
 public:
diff --git a/modules/iswa/rendering/textureplane.h b/modules/iswa/rendering/textureplane.h
index ff4b3f7747..66e5431a4b 100644
--- a/modules/iswa/rendering/textureplane.h
+++ b/modules/iswa/rendering/textureplane.h
@@ -32,9 +32,9 @@
 namespace openspace {
 
 /**
- * TexturePlane is a "concrete" IswaCygnet with texture as its input source.
- * It handles the creation, destruction and rendering of a plane geometry.
- * It also specifies which shaders to use and the uniforms that it needs.
+ * TexturePlane is a "concrete" IswaCygnet with texture as its input source. It handles
+ * the creation, destruction and rendering of a plane geometry. It also specifies which
+ * shaders to use and the uniforms that it needs.
  */
 class TexturePlane : public TextureCygnet {
 public:
diff --git a/modules/iswa/util/dataprocessor.h b/modules/iswa/util/dataprocessor.h
index 1a54139f1b..dc27d8697c 100644
--- a/modules/iswa/util/dataprocessor.h
+++ b/modules/iswa/util/dataprocessor.h
@@ -39,8 +39,6 @@ namespace properties { class SelectionProperty; }
 class Histogram;
 
 class DataProcessor {
-    //friend class IswaBaseGroup;
-
 public:
     DataProcessor() = default;
     virtual ~DataProcessor() = default;
diff --git a/modules/kameleon/include/kameleonwrapper.h b/modules/kameleon/include/kameleonwrapper.h
index 9293c7a84d..15bf2a232b 100644
--- a/modules/kameleon/include/kameleonwrapper.h
+++ b/modules/kameleon/include/kameleonwrapper.h
@@ -50,8 +50,8 @@ class KameleonWrapper {
 public:
     enum class Model {
         OpenGGCM,
-        BATSRUS,        // Magnetosphere
-        ENLIL,          // Heliosphere
+        BATSRUS, // Magnetosphere
+        ENLIL, // Heliosphere
         MAS,
         Adapt3D,
         SWMF,
diff --git a/modules/multiresvolume/rendering/tsp.h b/modules/multiresvolume/rendering/tsp.h
index a38cef48b3..b5b8fff25d 100644
--- a/modules/multiresvolume/rendering/tsp.h
+++ b/modules/multiresvolume/rendering/tsp.h
@@ -96,16 +96,21 @@ public:
     bool isOctreeLeaf(unsigned int brickIndex) const;
 
 private:
-    // Returns a list of the octree leaf nodes that a given input
-    // brick covers. If the input is already a leaf, the list will
-    // only contain that one index.
+    /**
+     * Returns a list of the octree leaf nodes that a given input brick covers. If the
+     * input is already a leaf, the list will only contain that one index.
+     */
     std::list<unsigned int> coveredLeafBricks(unsigned int brickIndex) const;
 
-    // Returns a list of the BST leaf nodes that a given input brick
-    // covers (at the same spatial subdivision level).
+    /**
+     * Returns a list of the BST leaf nodes that a given input brick covers (at the same
+     * spatial subdivision level).
+     */
     std::list<unsigned int> coveredBSTLeafBricks(unsigned int brickIndex) const;
 
-    // Return a list of eight children brick incices given a brick index
+    /**
+     * Return a list of eight children brick incices given a brick index.
+     */
     std::list<unsigned int> childBricks(unsigned int brickIndex);
 
     std::string _filename;
diff --git a/modules/server/include/topics/flightcontrollertopic.h b/modules/server/include/topics/flightcontrollertopic.h
index ec839c624e..4a58a30696 100644
--- a/modules/server/include/topics/flightcontrollertopic.h
+++ b/modules/server/include/topics/flightcontrollertopic.h
@@ -32,7 +32,7 @@
 namespace openspace::interaction {
     struct WebsocketInputStates;
     struct WebsocketInputState;
-}
+} // namespace openspace::interaction
 
 namespace openspace {
 
diff --git a/modules/skybrowser/include/utility.h b/modules/skybrowser/include/utility.h
index ee69dbbc03..1e574bc42f 100644
--- a/modules/skybrowser/include/utility.h
+++ b/modules/skybrowser/include/utility.h
@@ -37,6 +37,7 @@ constexpr double CelestialSphereRadius = 4.0 * distanceconstants::Parsec;
 
 /**
  * Converts from Cartesian coordinates to spherical coordinates with unit length.
+ *
  * \param coords Cartesian coordinates
  * \return Spherical coordinates with unit length in degrees
  */
@@ -44,15 +45,16 @@ glm::dvec2 cartesianToSpherical(const glm::dvec3& coords);
 
 /**
  * Converts from spherical coordinates to Cartesian coordinates with unit length.
+ *
  * \param coords Spherical coordinates in degrees
  * \return Cartesian coordinates with unit length
  */
 glm::dvec3 sphericalToCartesian(const glm::dvec2& coords);
 
-// Conversion J2000 equatorial <-> galactic
 /**
  * Converts from Cartesian galactic coordinates to Cartesian equatorial coordinates in
  * epoch J2000 with unit length.
+ *
  * \param coords Cartesian galactic coordinates
  * \return Cartesian equatorial coordinates in the epoch of J2000 with unit length
  */
@@ -61,6 +63,7 @@ glm::dvec3 galacticToEquatorial(const glm::dvec3& coords);
 /**
  * Converts from Cartesian equatorial coordinates to Cartesian galactic coordinates. The
  * galactic coordinates vector has the length of the radius of the Celestial sphere.
+ *
  * \param coords Cartesian equatorial coordinates
  * \return Cartesian galactic coordinates placed on the Celestial sphere
  */
@@ -70,6 +73,7 @@ glm::dvec3 equatorialToGalactic(const glm::dvec3& coords);
 /**
  * Converts from local camera coordinates to screenspace coordinates. The screenspace
  * coordinates are placed on the screenspace plane which has the z-coordinate as -2.1.
+ *
  * \param coords Cartesian local camera coordinates
  * \return Cartesian galactic coordinates placed on the Celestial sphere
  */
@@ -77,6 +81,7 @@ glm::dvec3 localCameraToScreenSpace3d(const glm::dvec3& coords);
 
 /**
  * Converts from pixel coordinates to screenspace coordinates in 2D.
+ *
  * \param mouseCoordinate Pixel coordinate
  * \return Cartesian ScreenSpace coordinate
  */
@@ -85,6 +90,7 @@ glm::vec2 pixelToScreenSpace2d(const glm::vec2& mouseCoordinate);
 // Conversion local camera space <-> galactic / equatorial
 /**
  * Converts from Cartesian equatorial coordinates in epoch J2000 to local camera space.
+ *
  * \param coords Cartesian equatorial coordinates in epoch J2000
  * \return Local camera coordinates with unit length
  */
@@ -92,6 +98,7 @@ glm::dvec3 equatorialToLocalCamera(const glm::dvec3& coords);
 
 /**
  * Converts from Cartesian galactic coordinates to local camera space with unit length.
+ *
  * \param coords Cartesian galactic coordinates
  * \return Cartesian local camera coordinates with unit length
  */
@@ -99,6 +106,7 @@ glm::dvec3 galacticToLocalCamera(const glm::dvec3& coords);
 
 /**
  * Converts from Cartesian local camera coordinates to galactic coordinates.
+ *
  * \param coords Cartesian local camera coordinates
  * \return Cartesian galactic coordinates placed on the Celestial sphere
  */
@@ -107,6 +115,7 @@ glm::dvec3 localCameraToGalactic(const glm::dvec3& coords);
 /**
  * Converts from local camera coordinates to Cartesian equatorial coordinates in the epoch
  * J2000.
+ *
  * \param coords Cartesian local camera coordinates
  * \return Cartesian equatorial coordinates with unit length
  */
@@ -116,8 +125,9 @@ glm::dvec3 localCameraToEquatorial(const glm::dvec3& coords);
 /**
  * Returns the angle between the up direction of the OpenSpace camera and the equatorial
  * North Pole direction.
+ *
  * \return Angle in degrees between the OpenSpace camera's up direction vector and the
- * equatorial North Pole direction.
+ *         equatorial North Pole direction.
  */
 double targetRoll(const glm::dvec3& up, const glm::dvec3& forward);
 
@@ -130,35 +140,39 @@ glm::dvec3 cameraDirectionGalactic();
 /**
  * Returns the view direction of the OpenSpace camera in equatorial coordinates in epoch
  * J2000.
+ *
  * \return View direction of the OpenSpace camera in Cartesian equatorial coordinates in
  *         epoch J2000.
  */
 glm::dvec3 cameraDirectionEquatorial();
 
-// Window and field of view
 /**
  * Returns the window ratio r which is calculated as x / y.
+ *
  * \return The window ratio x / y
  */
 float windowRatio();
 
 /**
  * Returns the vertical and horizontal field of view of the OpenSpace window.
- * \return The horizontal and vertical field of view in degrees.
+ *
+ * \return The horizontal and vertical field of view in degrees
  */
 glm::dvec2 fovWindow();
 
 /**
  * Returns true if the Cartesian equatorial coordinate is in the current view of the
  * camera.
+ *
  * \param equatorial Cartesian equatorial coordinates in epoch J2000
- * \return True if the coordinates are in the camera's current field of view
+ * \return `true` if the coordinates are in the camera's current field of view
  */
 bool isCoordinateInView(const glm::dvec3& equatorial);
 
 // Animation for target and camera
 /**
  * Returns the angle between two vectors.
+ *
  * \param start Cartesian vector
  * \param end Cartesian vector
  * \return Angle between two vectors in radians
@@ -168,10 +182,11 @@ double angleBetweenVectors(const glm::dvec3& start, const glm::dvec3& end);
 /**
  * Returns a 4x4 matrix for an incremental rotation of a vector. The matrix should be used
  * multiple times in order to animate.
+ *
  * \param start Cartesian vector
  * \param end Cartesian vector
  * \param percentage Percentage of the angle between the vectors that the matrix should
- * rotate
+ *        rotate
  * \return 4x4 matrix for incremental rotation animation of a vector
  */
 glm::dmat4 incrementalAnimationMatrix(const glm::dvec3& start, const glm::dvec3& end,
@@ -180,6 +195,7 @@ glm::dmat4 incrementalAnimationMatrix(const glm::dvec3& start, const glm::dvec3&
 /**
  * Returns the size in meters that for example a plane would need to have in order to
  * display a specified field of view.
+ *
  * \param fov The set field of view
  * \param worldPosition The galactic position of the plane
  * \return Field of view
diff --git a/modules/space/horizonsfile.h b/modules/space/horizonsfile.h
index cd3eaf6078..c492e7486a 100644
--- a/modules/space/horizonsfile.h
+++ b/modules/space/horizonsfile.h
@@ -36,7 +36,7 @@ namespace openspace {
 /**
  * A Horizons file is a text file generated from NASA JPL HORIZONS Website
  * (https://ssd.jpl.nasa.gov/horizons.cgi). The implementation supports both Vector
- * and Observer as Horizons data table
+ * and Observer as Horizons data table.
  *
  * In case of Vector table data the implementation expects a file with format:
  * TIME(JulianDayNumber = A.D. YYYY-MM-DD HH:MM:SS TDB)
@@ -46,8 +46,9 @@ namespace openspace {
  * Y - Y position in kilometers in Ecliptic J2000 reference frame
  * Z - Z position in kilometers in Ecliptic J2000 reference frame
  * Changes required in the "Table Settings" for compatible data:
- * 1. Under "Select Output Quantities" choose option "Position components {x, y, z} only"
- * 2. Uncheck the "Vector labels" options
+ *   1. Under "Select Output Quantities" choose option "Position components {x, y, z}
+ *      only"
+ *   2. Uncheck the "Vector labels" options
  *
  * In case of Observer table data the implementation expects a file with format:
  * TIME(YYYY-MM-DD HH:MM:SS) Range(km) GalLon(degrees) GalLat(degrees)
@@ -55,10 +56,10 @@ namespace openspace {
  * GalLon - Galactic Longitude in degrees
  * GalLat - Galactic Latitude in degrees
  * Changes required in the "Table Settings" for compatible data:
- * 1. Under "Observer Table Settings" uncheck all options except
- *    "Observer range & range-rate" and "Galactic longitude & latitude"
- * 2. Change "Range units" to "kilometers (km)" instead of "astronomical units (au)"
- * 3. Check the "Suppress range-rate" option
+ *   1. Under "Observer Table Settings" uncheck all options except
+ *      "Observer range & range-rate" and "Galactic longitude & latitude"
+ *   2. Change "Range units" to "kilometers (km)" instead of "astronomical units (au)"
+ *   3. Check the "Suppress range-rate" option
  */
 enum class HorizonsResultCode {
     Valid,
diff --git a/modules/space/kepler.h b/modules/space/kepler.h
index 0911587ccd..7786e0c48c 100644
--- a/modules/space/kepler.h
+++ b/modules/space/kepler.h
@@ -32,10 +32,10 @@
 namespace openspace::kepler {
 
 struct Parameters {
-    // Some human-readable name for the object represented by this kepler parameter set
+    /// Some human-readable name for the object represented by this kepler parameter set
     std::string name;
 
-    // Some form of unique identifier for the object represented by this data
+    /// Some form of unique identifier for the object represented by this data
     std::string id;
 
     double inclination = 0.0;
@@ -86,7 +86,7 @@ std::vector<Parameters> readOmmFile(std::filesystem::path file);
 std::vector<Parameters> readSbdbFile(std::filesystem::path file);
 
 /**
- * The different formats that the readFile function is capable of loading
+ * The different formats that the readFile function is capable of loading.
  */
 enum class Format {
     TLE,
diff --git a/modules/space/rendering/renderableconstellationbounds.h b/modules/space/rendering/renderableconstellationbounds.h
index f331bfdfeb..bfccd0cca9 100644
--- a/modules/space/rendering/renderableconstellationbounds.h
+++ b/modules/space/rendering/renderableconstellationbounds.h
@@ -38,9 +38,10 @@ namespace documentation { struct Documentation; }
  * http://cdsarc.u-strasbg.fr/viz-bin/Cat?cat=VI%2F49. It contains the bounds on the
  * celestial sky for the different constellations and is used to determine in which region
  * of the sky a specific object is located.
- * The bounds are drawn as lines on a sphere with variable radius, set by the
- * `_distance` property. Currently, all constellation bounds are lines, which
- * leads to artifacts if the radius is very small.
+ *
+ * The bounds are drawn as lines on a sphere with variable radius, set by the `_distance`
+ * property. Currently, all constellation bounds are lines, which leads to artifacts if
+ * the radius is very small.
  */
 class RenderableConstellationBounds : public RenderableConstellationsBase {
 public:
@@ -57,13 +58,18 @@ public:
     static documentation::Documentation Documentation();
 
 private:
-    /// Stores the constellation bounds
+    /**
+     * Stores the constellation bounds.
+     */
     struct ConstellationBound {
-        std::string constellationAbbreviation; ///< The abbreviation of the constellation
+        /// The abbreviation of the constellation
+        std::string constellationAbbreviation;
         std::string constellationFullName;
         bool isEnabled = false;
-        GLsizei startIndex; ///< The index of the first vertex describing the bounds
-        GLsizei nVertices; ///< The number of vertices describing the bounds
+        /// The index of the first vertex describing the bounds
+        GLsizei startIndex;
+        /// The number of vertices describing the bounds
+        GLsizei nVertices;
     };
 
     /**
diff --git a/modules/space/rendering/renderableconstellationlines.h b/modules/space/rendering/renderableconstellationlines.h
index d659811990..74a2795ebb 100644
--- a/modules/space/rendering/renderableconstellationlines.h
+++ b/modules/space/rendering/renderableconstellationlines.h
@@ -77,7 +77,7 @@ private:
     bool readSpeckFile();
 
     /**
-     * Callback method that gets triggered when `_constellationSelection` changes
+     * Callback method that gets triggered when `_constellationSelection` changes.
      */
     void selectionPropertyHasChanged() override;
 
diff --git a/modules/space/rendering/renderableconstellationsbase.h b/modules/space/rendering/renderableconstellationsbase.h
index 13a013dfd2..7c86c12e4b 100644
--- a/modules/space/rendering/renderableconstellationsbase.h
+++ b/modules/space/rendering/renderableconstellationsbase.h
@@ -45,7 +45,7 @@ namespace openspace {
 namespace documentation { struct Documentation; }
 
 /**
- * This is a base class for constellation lines and bounds
+ * This is a base class for constellation lines and bounds.
  */
 class RenderableConstellationsBase : public Renderable {
 public:
@@ -65,44 +65,47 @@ protected:
     explicit RenderableConstellationsBase(const ghoul::Dictionary& dictionary);
 
     /**
-     * Callback method that gets triggered when `_constellationSelection` changes
+     * Callback method that gets triggered when `_constellationSelection` changes.
      */
     virtual void selectionPropertyHasChanged() = 0;
 
-    /// Takes the given constellation `identifier` and returns the corresponding
-    /// full name
+    /**
+     * Takes the given constellation `identifier` and returns the corresponding full name.
+     */
     std::string constellationFullName(const std::string& identifier) const;
 
-    // Width for the rendered lines
+    /// Width for the rendered lines
     properties::FloatProperty _lineWidth;
 
-    // Property that stores all constellations chosen by the user to be drawn
+    /// Property that stores all constellations chosen by the user to be drawn
     properties::SelectionProperty _selection;
 
-    // Temporary storage of which constellations should be rendered as stated in the
-    // asset file
+    /// Temporary storage of which constellations should be rendered as stated in the
+    /// asset file
     std::vector<std::string> _assetSelection;
 
-    // Labels
+    /// Labels
     bool _hasLabels = false;
-    // Everything related to the labels is handled by LabelsComponent
+    /// Everything related to the labels is handled by LabelsComponent
     std::unique_ptr<LabelsComponent> _labels;
 
 private:
-    // Map over the constellations names and their abbreviations
-    // key = abbreviation, value = full name
+    /// Map over the constellations names and their abbreviations
+    /// key = abbreviation, value = full name
     std::map<std::string, std::string> _namesTranslation;
 
     /**
-     * Loads the file specified in `_constellationNamesFilename` that contains
-     * the mapping between abbreviations and full names of constellations
+     * Loads the file specified in `_constellationNamesFilename` that contains the mapping
+     * between abbreviations and full names of constellations.
      */
     void loadConstellationFile();
 
-    /// Fills the `_constellationSelection` property with all constellations
+    /**
+     * Fills the `_constellationSelection` property with all constellations.
+     */
     void fillSelectionProperty();
 
-    // The file containing constellation names and abbreviations
+    /// The file containing constellation names and abbreviations
     properties::StringProperty _namesFilename;
 };
 
diff --git a/modules/space/rendering/renderablehabitablezone.h b/modules/space/rendering/renderablehabitablezone.h
index 296cc0de53..fc24ab26f9 100644
--- a/modules/space/rendering/renderablehabitablezone.h
+++ b/modules/space/rendering/renderablehabitablezone.h
@@ -49,12 +49,14 @@ private:
 
     /**
      * Compute the inner and outer boundary of the habitable zone of a star, according to
-     * formula and coefficients by Kopparapu et al. (2015) https://arxiv.org/abs/1404.5292
+     * formula and coefficients by Kopparapu et al. (2015).
      *
      * \param teff The effective temperature of the star, in Kelvin
      * \param luminosity The luminosity of the star, in solar luminosities
-     * \return A vec4 with the boundaries in atronomical units, in the order:
-               optimistic inner, conservative inner, conservative outer, optimistic outer
+     * \return A vec4 with the boundaries in atronomical units, in the order: optimistic
+     *         inner, conservative inner, conservative outer, optimistic outer
+     *
+     * \sa https://arxiv.org/abs/1404.5292
      */
     glm::dvec4 computeKopparapuZoneBoundaries(float teff, float luminosity);
 
diff --git a/modules/space/rendering/renderabletravelspeed.h b/modules/space/rendering/renderabletravelspeed.h
index e2a62b0a54..d379ef064a 100644
--- a/modules/space/rendering/renderabletravelspeed.h
+++ b/modules/space/rendering/renderabletravelspeed.h
@@ -84,8 +84,8 @@ private:
     double _timeSinceStart = -1.0;
 
     ghoul::opengl::ProgramObject* _shaderProgram = nullptr;
-    // The vertex attribute location for position
-    // must correlate to layout location in vertex shader
+    // The vertex attribute location for position must correlate to layout location in
+    // vertex shader
     GLuint _vaoId = 0;
     GLuint _vBufferId = 0;
 };
diff --git a/modules/space/tasks/generatedebrisvolumetask.h b/modules/space/tasks/generatedebrisvolumetask.h
index f36045c8a5..adcca2e02a 100644
--- a/modules/space/tasks/generatedebrisvolumetask.h
+++ b/modules/space/tasks/generatedebrisvolumetask.h
@@ -26,20 +26,16 @@
 #define __OPENSPACE_MODULE_SPACE___GENERATEDEBRISVOLUMETASK___H__
 
 #include <openspace/util/task.h>
-#include <openspace/util/time.h>
+
 
 #include <modules/space/rendering/renderableorbitalkepler.h>
 #include <modules/space/translation/keplertranslation.h>
-
-
+#include <openspace/util/time.h>
 #include <ghoul/glm.h>
-
 #include <string>
 #include <vector>
 
-namespace openspace {
-namespace volume {
-
+namespace openspace::volume {
 
 class GenerateDebrisVolumeTask : public Task {
 public:
@@ -65,12 +61,8 @@ private:
     std::vector<KeplerParameters> _TLEDataVector;
 
     float _maxApogee;
-
-    // not sure if it should be local function or hidden function.
-    //std::vector<KeplerParameters> readTLEFile(const std::string& filename);
 };
 
-} // namespace volume
-} // namespace openspace
+} // namespace openspace::volume
 
 #endif // __OPENSPACE_MODULE_SPACE___GENERATEDEBRISVOLUMETASK___H__
diff --git a/modules/space/translation/gptranslation.h b/modules/space/translation/gptranslation.h
index e07d2925a0..7aa68679f6 100644
--- a/modules/space/translation/gptranslation.h
+++ b/modules/space/translation/gptranslation.h
@@ -31,7 +31,7 @@ namespace openspace {
 
 /**
  * A specialization of the KeplerTranslation that utilizes general pertubation file
- * formats to extracts the Keplerian elements
+ * formats to extracts the Keplerian elements.
  */
 class GPTranslation : public KeplerTranslation {
 public:
@@ -50,7 +50,7 @@ public:
      * that can be passed to the constructor.
      *
      * \return The openspace::Documentation that describes the ghoul::Dicitonary that can
-     * be passed to the constructor
+     *         be passed to the constructor
      */
     static documentation::Documentation Documentation();
 };
diff --git a/modules/space/translation/horizonstranslation.h b/modules/space/translation/horizonstranslation.h
index 76562a2643..5542b286fa 100644
--- a/modules/space/translation/horizonstranslation.h
+++ b/modules/space/translation/horizonstranslation.h
@@ -42,7 +42,7 @@ namespace documentation { struct Documentation; }
 /**
  * The HorizonsTranslation is based on text files generated from NASA JPL HORIZONS Website
  * (https://ssd.jpl.nasa.gov/horizons.cgi). The implementation supports both Vector
- * and Observer as Horizons data table
+ * and Observer as Horizons data table.
  *
  * In case of Vector table data the implementation expects a file with format:
  * TIME(JulianDayNumber = A.D. YYYY-MM-DD HH:MM:SS TDB)
@@ -52,8 +52,9 @@ namespace documentation { struct Documentation; }
  * Y - Y position in kilometers in Ecliptic J2000 reference frame
  * Z - Z position in kilometers in Ecliptic J2000 reference frame
  * Changes required in the "Table Settings" for compatible data:
- * 1. Under "Select Output Quantities" choose option "Position components {x, y, z} only"
- * 2. Uncheck the "Vector labels" options
+ *   1. Under "Select Output Quantities" choose option "Position components {x, y, z}
+ *      only"
+ *   2. Uncheck the "Vector labels" options
  *
  * In case of Observer table data the implementation expects a file with format:
  * TIME(YYYY-MM-DD HH:MM:SS) Range(km) GalLon(degrees) GalLat(degrees)
@@ -61,10 +62,10 @@ namespace documentation { struct Documentation; }
  * GalLon - Galactic Longitude in degrees
  * GalLat - Galactic Latitude in degrees
  * Changes required in the "Table Settings" for compatible data:
- * 1. Under "Observer Table Settings" uncheck all options except
- *    "Observer range & range-rate" and "Galactic longitude & latitude"
- * 2. Change "Range units" to "kilometers (km)" instead of "astronomical units (au)"
- * 3. Check the "Suppress range-rate" option
+ *   1. Under "Observer Table Settings" uncheck all options except
+ *      "Observer range & range-rate" and "Galactic longitude & latitude"
+ *   2. Change "Range units" to "kilometers (km)" instead of "astronomical units (au)"
+ *   3. Check the "Suppress range-rate" option
  */
 class HorizonsTranslation : public Translation {
 public:
diff --git a/modules/space/translation/keplertranslation.h b/modules/space/translation/keplertranslation.h
index 99f4c375cb..79cf251142 100644
--- a/modules/space/translation/keplertranslation.h
+++ b/modules/space/translation/keplertranslation.h
@@ -52,8 +52,8 @@ public:
     /**
      * The constructor that retrieves the required Keplerian elements from the passed
      * \p dictionary. These values are then apssed to the setKeplerElements method for
-     * further processing.
-     * The \p dictionary is tested against the Documentation for conformance.
+     * further processing. The \p dictionary is tested against the Documentation for
+     * conformance.
      *
      * \param dictionary The ghoul::Dictionary containing all the information about the
      *        Keplerian elements (see Documentation)
@@ -66,7 +66,7 @@ public:
     /**
     * Method returning the translation vector at a given time.
     *
-    * \param data provides information from the engine about, for example, the time
+    * \param data Provides information from the engine about, for example, the time
     */
     glm::dvec3 position(const UpdateData& data) const override;
 
@@ -121,10 +121,14 @@ public:
         double ascendingNode, double argumentOfPeriapsis, double meanAnomalyAtEpoch,
         double orbitalPeriod, double epoch);
 
-    /// Default construct that initializes all the properties and member variables
+    /**
+     * Default construct that initializes all the properties and member variables.
+     */
     KeplerTranslation();
 
-    /// Recombutes the rotation matrix used in the update method
+    /**
+     * Recombutes the rotation matrix used in the update method.
+     */
     void computeOrbitPlane() const;
 
 private:
diff --git a/modules/spacecraftinstruments/rendering/renderablefov.h b/modules/spacecraftinstruments/rendering/renderablefov.h
index 92a45ce93d..42f539c5b1 100644
--- a/modules/spacecraftinstruments/rendering/renderablefov.h
+++ b/modules/spacecraftinstruments/rendering/renderablefov.h
@@ -60,10 +60,12 @@ public:
     static documentation::Documentation Documentation();
 
 private:
-    // Checks the field of view of the instrument for the current \p time against all of
-    // the potential targets are returns the first name of the target that is in field of
-    // view, the previous target, or the closest target to the space craft. The second
-    // return value is whether the target is currently in the field of view
+    /**
+     * Checks the field of view of the instrument for the current \p time against all of
+     * the potential targets are returns the first name of the target that is in field of
+     * view, the previous target, or the closest target to the space craft. The second
+     * return value is whether the target is currently in the field of view.
+     */
     std::pair<std::string, bool> determineTarget(double time);
 
     void updateGPU();
@@ -129,13 +131,20 @@ private:
     RenderInformation _fieldOfViewBounds;
 
     struct {
-        properties::Vec3Property defaultStart; // Start color for uninteresting times
-        properties::Vec3Property defaultEnd; // End color for uninteresting times
-        properties::Vec3Property active; // Color use when a field-of-view is projecting
-        properties::Vec3Property targetInFieldOfView; // Color to use for target in fov
-        properties::Vec3Property intersectionStart; // Color at the start of intersection
-        properties::Vec3Property intersectionEnd; // Color at the end of intersection
-        properties::Vec3Property square; // Color for the orthogonal square
+        /// Start color for uninteresting times
+        properties::Vec3Property defaultStart;
+        /// End color for uninteresting times
+        properties::Vec3Property defaultEnd;
+        /// Color use when a field-of-view is projecting
+        properties::Vec3Property active;
+        /// Color to use for target in fov
+        properties::Vec3Property targetInFieldOfView;
+        /// Color at the start of intersection
+        properties::Vec3Property intersectionStart;
+        /// Color at the end of intersection
+        properties::Vec3Property intersectionEnd;
+        /// Color for the orthogonal square
+        properties::Vec3Property square;
     } _colors;
 };
 
diff --git a/modules/spacecraftinstruments/util/imagesequencer.h b/modules/spacecraftinstruments/util/imagesequencer.h
index ed8c1f2947..fd79fa3f71 100644
--- a/modules/spacecraftinstruments/util/imagesequencer.h
+++ b/modules/spacecraftinstruments/util/imagesequencer.h
@@ -47,13 +47,13 @@ class SequenceParser;
  * to function the client must provide or write a parser that fills the ImageSequencers
  * private members.
  *
- * \see SequenceParser
- * \see ImageSequencer::runSequenceParser(SequenceParser* parser)
+ * \sa SequenceParser
+ * \sa ImageSequencer::runSequenceParser(SequenceParser* parser)
  */
 class ImageSequencer {
 public:
     /**
-     * Singleton instantiation
+     * Singleton instantiation.
      */
     static ImageSequencer* _instance;
 
@@ -82,6 +82,7 @@ public:
 
     /**
      * Runs parser and recieves the datastructures filled by it.
+     *
      * \see SequenceParser
      */
     void runSequenceParser(SequenceParser& parser);
@@ -128,7 +129,7 @@ public:
     float instrumentActiveTime(double time, const std::string& instrumentID) const;
 
     /**
-     * Returns latest captured image
+     * Returns latest captured image.
      */
     Image latestImageForInstrument(const std::string& instrumentID) const;
 
@@ -141,14 +142,16 @@ private:
      * This handles any types of ambiguities between the data and SPICE calls. This map is
      * composed of a key that is a string in the data to be translated and a Decoder that
      * holds the corresponding translation provided through as asset.
-     * \see Decoder
+     *
+     * \sa Decoder
      */
     std::map<std::string, std::unique_ptr<Decoder>> _fileTranslation;
 
     /**
      * This is the main container of image data. The key is the target name, the value is
      * a subset of images.
-     * \see SequenceParser
+     *
+     * \sa SequenceParser
      */
     std::map<std::string, ImageSubset> _subsetMap;
 
@@ -168,7 +171,7 @@ private:
 
     /**
      * Holds the time ranges of each instruments on and off periods. An instrument
-     * rendering class may ask the ImageSequencer whether or not it
+     * rendering class may ask the ImageSequencer whether or not it.
      */
     std::vector<std::pair<std::string, TimeRange>> _instrumentTimes;
 
diff --git a/modules/statemachine/include/statemachine.h b/modules/statemachine/include/statemachine.h
index b78e36bf84..346290607b 100644
--- a/modules/statemachine/include/statemachine.h
+++ b/modules/statemachine/include/statemachine.h
@@ -44,14 +44,15 @@ public:
     bool canTransitionTo(const std::string& state) const;
 
     /**
-     * Return the identifiers of all possible transitions from the current state
+     * Return the identifiers of all possible transitions from the current state.
      */
     std::vector<std::string> possibleTransitions() const;
 
     /**
      * Saves the state machine to a .dot file, as a directed graph.
-     * filename is the full name of the file, including the directory,
-     * but without the extension.
+     *
+     * \param filename This is the full name of the file, including the directory,
+     *        but without the extension
      */
     void saveToDotFile(const std::string& filename) const;
 
diff --git a/modules/statemachine/statemachinemodule.h b/modules/statemachine/statemachinemodule.h
index 08b9359647..1521dc1f92 100644
--- a/modules/statemachine/statemachinemodule.h
+++ b/modules/statemachine/statemachinemodule.h
@@ -56,7 +56,7 @@ public:
 
     /**
      * Save the state machine to a file given by the name and optional directory.
-     * If no directory is given, the TEMP folder is used
+     * If no directory is given, the TEMP folder is used.
      */
     void saveToFile(const std::string& fileName,
         std::string directory = "${TEMPORARY}/") const;
diff --git a/modules/sync/syncs/httpsynchronization.h b/modules/sync/syncs/httpsynchronization.h
index ed7c6c0317..d1d1744f98 100644
--- a/modules/sync/syncs/httpsynchronization.h
+++ b/modules/sync/syncs/httpsynchronization.h
@@ -41,6 +41,7 @@ namespace openspace {
  * of this synchronization. That list of files can have empty lines and commented out
  * lines (starting with a #) that will be ignored. Every other line is URL that will be
  * downloaded into the #directory.
+ *
  * Each requested set of files is identified by a triplet of (identifier, file version,
  * application version). The identifier is denoting the group of files that is requested,
  * the file version is the specific version of this set of files, and the application
@@ -67,7 +68,9 @@ public:
         std::filesystem::path synchronizationRoot,
         std::vector<std::string> synchronizationRepositories);
 
-    /// Destructor that will close the asynchronous file transfer, if it is still ongoing
+    /**
+     * Destructor that will close the asynchronous file transfer, if it is still ongoing.
+     */
     ~HttpSynchronization() override;
 
     /**
@@ -85,7 +88,9 @@ public:
      */
     void start() override;
 
-    /// Cancels any ongoing synchronization of this ResourceSynchronization
+    /**
+     * Cancels any ongoing synchronization of this ResourceSynchronization.
+     */
     void cancel() override;
 
     std::string generateUid() override;
@@ -93,15 +98,20 @@ public:
     static documentation::Documentation Documentation();
 
 protected:
-    /// Creates a file next to the directory that indicates that this
-    /// ResourceSynchronization has successfully synchronized its contents
+    /** Creates a file next to the directory that indicates that this
+     * ResourceSynchronization has successfully synchronized its contents.
+     */
     void createSyncFile(bool isFullySynchronized = true) const override;
 
-    /// Check ossync file and returns true if all files are downloaded or false
-    /// if partially synched or if there is an ossync file error (rejected)
+    /**
+     * Check ossync file and returns true if all files are downloaded or false if
+     * partially synched or if there is an ossync file error (rejected).
+     */
     bool isEachFileDownloaded();
 
-    /// Representation of 'global' synchronization state that encodes where a fail happen.
+    /**
+     * Representation of 'global' synchronization state that encodes where a fail happen.
+     */
     enum class SynchronizationState {
         Success,
         ListDownloadFail,
@@ -109,7 +119,9 @@ protected:
     };
 
 private:
-    /// Tries to get a reply from the provided URL and returns that success to the caller
+    /**
+     * Tries to get a reply from the provided URL and returns that success to the caller.
+     */
     SynchronizationState trySyncFromUrl(std::string url);
 
     /// Contains a flag whether the current transfer should be cancelled
diff --git a/modules/sync/syncs/urlsynchronization.h b/modules/sync/syncs/urlsynchronization.h
index 0545d2c6a1..3691150f00 100644
--- a/modules/sync/syncs/urlsynchronization.h
+++ b/modules/sync/syncs/urlsynchronization.h
@@ -56,7 +56,9 @@ public:
     UrlSynchronization(const ghoul::Dictionary& dictionary,
         std::filesystem::path synchronizationRoot);
 
-    /// Contructor that will terminate the synchronization thread if it is still running
+    /**
+     * Contructor that will terminate the synchronization thread if it is still running.
+     */
     ~UrlSynchronization() override;
 
     /**
@@ -67,10 +69,14 @@ public:
      */
     std::filesystem::path directory() const override;
 
-    /// Starts the synchronization for this ResourceSynchronization
+    /**
+     * Starts the synchronization for this ResourceSynchronization.
+     */
     void start() override;
 
-    /// Cancels any ongoing synchronization of this ResourceSynchronization
+    /**
+     * Cancels any ongoing synchronization of this ResourceSynchronization.
+     */
     void cancel() override;
 
     std::string generateUid() override;
@@ -78,19 +84,25 @@ public:
     static documentation::Documentation Documentation();
 
 protected:
-    /// Read the `ossync` file and check if the downloaded files can be used. Returns 
-    /// `true` if they are valid and `false` if we should download them again
+    /**
+     * Read the `ossync` file and check if the downloaded files can be used. Returns
+     * `true` if they are valid and `false` if we should download them again.
+     */
     bool isEachFileValid();
 
 private:
     static constexpr double MaxDateAsJ2000 = 252424036869.18289;
 
-    /// Creates a file next to the directory that indicates that this
-    /// ResourceSynchronization has successfully synchronized its contents
+    /**
+     * Creates a file next to the directory that indicates that this
+     * ResourceSynchronization has successfully synchronized its contents.
+     */
     void createSyncFile(bool isFullySynchronized = true) const override;
 
-    /// Tries to get a reply from the asset URLs and returns that success to the caller
-    bool trySyncUrls(); 
+    /**
+     * Tries to get a reply from the asset URLs and returns that success to the caller.
+     */
+    bool trySyncUrls();
 
     /// The list of URLs that will be downloaded
     std::vector<std::string> _urls;
diff --git a/modules/touch/include/directinputsolver.h b/modules/touch/include/directinputsolver.h
index 062f2d9561..b142c8ea9a 100644
--- a/modules/touch/include/directinputsolver.h
+++ b/modules/touch/include/directinputsolver.h
@@ -29,20 +29,21 @@
 #include <modules/touch/ext/levmarq.h>
 #include <vector>
 
-
 namespace openspace {
 
 class Camera;
 class SceneGraphNode;
 
 /**
- * The DirectInputSolver is used to minimize the L2 error of touch input
- * to 3D camera position. It uses the levmarq algorithm in order to do this.
- * */
+ * The DirectInputSolver is used to minimize the L2 error of touch input to 3D camera
+ * position. It uses the levmarq algorithm in order to do this.
+ */
 class DirectInputSolver {
 public:
-    // Stores the selected node, the cursor ID as well as the surface coordinates the
-    // cursor touched
+    /**
+     * Stores the selected node, the cursor ID as well as the surface coordinates the
+     * cursor touched
+     */
     struct SelectedBody {
         size_t id = 0;
         SceneGraphNode* node = nullptr;
@@ -52,10 +53,10 @@ public:
     DirectInputSolver();
 
     /**
-     * Returns true if the error could be minimized within certain bounds.
-     * If the error is found to be outside the bounds after a certain amount of
-     * iterations, this function fails.
-     * */
+     * Returns true if the error could be minimized within certain bounds. If the error is
+     * found to be outside the bounds after a certain amount of iterations, this function
+     * fails.
+     */
     bool solve(const std::vector<TouchInputHolder>& list,
         const std::vector<SelectedBody>& selectedBodies,
         std::vector<double>* calculatedValues, const Camera& camera);
diff --git a/modules/touch/include/touchinteraction.h b/modules/touch/include/touchinteraction.h
index 4d79add788..8278e600d4 100644
--- a/modules/touch/include/touchinteraction.h
+++ b/modules/touch/include/touchinteraction.h
@@ -83,17 +83,17 @@ public:
     };
 
     /**
-     * Main function call
-     * 1 Checks if doubleTap occured
-     * 2 If the node in focus is large enough and all contact points have selected it,
-     *   calls directControl() function for direct-manipulation
-     * 3 Updates std::vector<SelectedBody> _selectedContactPoints (only if LMA
-     *   successfully converged, avoids interaction to snap on LMA fails)
-     * 4 If directControl() wasn't called this frame, interpret the incoming
-     *   list and decide what type of interaction this frame should do
-     * 5 Compute the new total velocities after interaction
-     * 6 Evaluate if directControl should be called next frame- true if all contact points
-     *   select the same node and said node is larger than _nodeRadiusThreshold
+     * Main function call:
+     *   1. Checks if doubleTap occured
+     *   2. If the node in focus is large enough and all contact points have selected it,
+     *     calls directControl() function for direct-manipulation
+     *   3. Updates std::vector<SelectedBody> _selectedContactPoints (only if LMA
+     *     successfully converged, avoids interaction to snap on LMA fails)
+     *   4. If directControl() wasn't called this frame, interpret the incoming
+     *      list and decide what type of interaction this frame should do
+     *   5. Compute the new total velocities after interaction
+     *   6. Evaluate if directControl should be called next frame- true if all contact
+     *      points select the same node and said node is larger than _nodeRadiusThreshold
      */
 
     void updateStateFromInput(const std::vector<TouchInputHolder>& list,
@@ -101,13 +101,19 @@ public:
 
     bool hasNonZeroVelocities() const;
 
-    // Calculates the new camera state with velocities and time since last frame
+    /**
+     * Calculates the new camera state with velocities and time since last frame.
+     */
     void step(double dt, bool directTouch = false);
 
-    // Called each frame we have no new input, used to reset data
+    /**
+     * Called each frame we have no new input, used to reset data.
+     */
     void resetAfterInput();
 
-    // Sets _tap to true, called if tap occured current frame (called from touchmodule)
+    /**
+     * Sets _tap to true, called if tap occured current frame (called from touchmodule).
+     */
     void tap();
 
     void setCamera(Camera* camera);
@@ -115,33 +121,39 @@ public:
 private:
     /**
      * Function that calculates the new camera state such that it minimizes the L2 error
-     * in screenspace
-     * between contact points and surface coordinates projected to clip space using LMA
+     * in screenspace between contact points and surface coordinates projected to clip
+     * space using LMA.
      */
     void directControl(const std::vector<TouchInputHolder>& list);
 
     /**
-     * Traces each contact point into the scene as a ray and find the intersection
-     * points on the surface of the current anchor node, if any. Saves the input id
-     * the node and surface coordinates the cursor hit
+     * Traces each contact point into the scene as a ray and find the intersection points
+     * on the surface of the current anchor node, if any. Saves the input id the node and
+     * surface coordinates the cursor hit.
      */
     void updateNodeSurfacePoints(const std::vector<TouchInputHolder>& list);
 
     /**
      * Returns an enum for what interaction to be used, depending on what input was
-     * received
+     * received.
      */
     InteractionType interpretInteraction(const std::vector<TouchInputHolder>& list,
         const std::vector<TouchInput>& lastProcessed);
 
-    // Compute new velocity according to the interpreted action
+    /**
+     * Compute new velocity according to the interpreted action.
+     */
     void computeVelocities(const std::vector<TouchInputHolder>& list,
         const std::vector<TouchInput>& lastProcessed);
 
-    // Compute velocity based on double-tap for zooming
+    /**
+     * Compute velocity based on double-tap for zooming.
+     */
     double computeTapZoomDistance(double zoomGain);
 
-    // Compute coefficient for velocity decay to be applied in decceleration
+    /**
+     * Compute coefficient for velocity decay to be applied in decceleration.
+     */
     double computeConstTimeDecayCoefficient(double velocity);
 
     /**
@@ -150,10 +162,14 @@ private:
      */
     void decelerate(double dt);
 
-    // Resets all properties that can be changed in the GUI to default
+    /**
+     * Resets all properties that can be changed in the GUI to default.
+     */
     void resetPropertiesToDefault();
 
-    // Set all velocities to zero
+    /**
+     * Set all velocities to zero.
+     */
     void resetVelocities();
 
     Camera* _camera = nullptr;
diff --git a/modules/touch/include/tuioear.h b/modules/touch/include/tuioear.h
index 55ec2d5b15..3ec380cc83 100644
--- a/modules/touch/include/tuioear.h
+++ b/modules/touch/include/tuioear.h
@@ -58,8 +58,8 @@ public:
     ~TuioEar();
 
     /**
-    * Callback functions, listens to the TUIO server
-    */
+     * Callback functions, listens to the TUIO server.
+     */
     void addTuioObject(TUIO::TuioObject *tobj);
     void updateTuioObject(TUIO::TuioObject *tobj);
     void removeTuioObject(TUIO::TuioObject *tobj);
@@ -75,8 +75,8 @@ public:
     void refresh(TUIO::TuioTime frameTime);
 
     /**
-        * Lock-swap the containers of this listener
-        */
+     * Lock-swap the containers of this listener.
+     */
     std::vector<TouchInput> takeInput();
     std::vector<TouchInput> takeRemovals();
 
diff --git a/modules/touch/touchmodule.h b/modules/touch/touchmodule.h
index 7600a42c16..eb263060f7 100644
--- a/modules/touch/touchmodule.h
+++ b/modules/touch/touchmodule.h
@@ -48,15 +48,19 @@ public:
     TouchModule();
     ~TouchModule();
 
-    // Function to check if the given renderable type is one that should
-    // use direct maniuplation
+    /**
+     * Function to check if the given renderable type is one that should use direct
+     * manipulation.
+     */
     bool isDefaultDirectTouchType(std::string_view renderableType) const;
 
 protected:
     void internalInitialize(const ghoul::Dictionary& dictionary) override;
 
 private:
-    /// Returns true if new touch input occured since the last frame
+    /**
+     * Returns true if new touch input occured since the last frame.
+     */
     bool processNewInput();
 
     void clearInputs();
diff --git a/modules/volume/rendering/renderabletimevaryingvolume.h b/modules/volume/rendering/renderabletimevaryingvolume.h
index d3f9bb1a9d..66e3cfaf99 100644
--- a/modules/volume/rendering/renderabletimevaryingvolume.h
+++ b/modules/volume/rendering/renderabletimevaryingvolume.h
@@ -42,7 +42,6 @@ namespace openspace {
 
 namespace openspace::volume {
 
-//class TransferFunction;
 class BasicVolumeRaycaster;
 template <typename T> class RawVolume;
 class VolumeClipPlanes;
diff --git a/modules/webbrowser/include/browserinstance.h b/modules/webbrowser/include/browserinstance.h
index 73fc907c0d..9c15eaf6fe 100644
--- a/modules/webbrowser/include/browserinstance.h
+++ b/modules/webbrowser/include/browserinstance.h
@@ -75,12 +75,12 @@ public:
     /**
      * Call when the window has been reshaped.
      *
-     * \param windowSize the size of the window in pixels
+     * \param windowSize The size of the window in pixels
      */
     void reshape(const glm::ivec2& windowSize);
 
     /**
-     * Encapsulate renderHandler's draw method
+     * Encapsulate renderHandler's draw method.
      */
     void draw();
     void close(bool force = false);
@@ -97,15 +97,17 @@ public:
     bool sendMouseMoveEvent(const CefMouseEvent& event);
 
     /**
-     * Send scroll wheel event to browser
+     * Send scroll wheel event to browser.
      *
      * \param event Key event with position
      * \param delta The scroll amount in pixels
-     * \return if this scroll should be blocked or not
+     * \return `true` if this scroll should be blocked or not
      */
     bool sendMouseWheelEvent(const CefMouseEvent& event, const glm::ivec2& delta);
 
-    /// Set the browser zoom level. 1.0 = default, 2.0 = double, etc.
+    /**
+     * Set the browser zoom level. 1.0 = default, 2.0 = double, etc.
+     */
     void setZoom(float ratio);
 
     void reloadBrowser();
diff --git a/modules/webbrowser/include/eventhandler.h b/modules/webbrowser/include/eventhandler.h
index b2754eb7ef..fdc904c038 100644
--- a/modules/webbrowser/include/eventhandler.h
+++ b/modules/webbrowser/include/eventhandler.h
@@ -75,7 +75,7 @@ private:
      * \param key the pressed key
      * \param mods the key modifier that was pressed
      * \param action the action that was performed that triggered this event
-     * \return true if event found, false otherwise
+     * \return `true` if event found, `false` otherwise
      */
     bool specialKeyEvent(Key key, KeyModifier mods, KeyAction action);
 
@@ -116,7 +116,7 @@ private:
     MouseButtonState _leftButton;
     MouseButtonState _rightButton;
 
-    // This vector assumes first element to be the active one:
+    /// This vector assumes first element to be the active one
     std::vector<TouchInput> _validTouchStates;
 
     /**
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index c0c383cbe2..a147c084dc 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -326,7 +326,6 @@ set(OPENSPACE_HEADER
   ${PROJECT_SOURCE_DIR}/include/openspace/rendering/screenspacerenderable.h
   ${PROJECT_SOURCE_DIR}/include/openspace/rendering/texturecomponent.h
   ${PROJECT_SOURCE_DIR}/include/openspace/rendering/transferfunction.h
-  ${PROJECT_SOURCE_DIR}/include/openspace/rendering/volume.h
   ${PROJECT_SOURCE_DIR}/include/openspace/rendering/volumeraycaster.h
   ${PROJECT_SOURCE_DIR}/include/openspace/scene/asset.h
   ${PROJECT_SOURCE_DIR}/include/openspace/scene/assetmanager.h