diff --git a/include/coal/collision_data.h b/include/coal/collision_data.h
index 26c12ad79810a3c4def3cb4486bf75a742f8c638..863372d5d68df0fa399526f1c74454da575d0a61 100644
--- a/include/coal/collision_data.h
+++ b/include/coal/collision_data.h
@@ -321,14 +321,14 @@ struct COAL_DLLAPI CollisionRequest : QueryRequest {
   bool enable_distance_lower_bound;
 
   /// @brief Distance below which objects are considered in collision.
-  /// See \ref hpp_fcl_collision_and_distance_lower_bound_computation
+  /// See \ref coal_collision_and_distance_lower_bound_computation
   /// @note If set to -inf, the objects tested for collision are considered
   ///       as collision free and no test is actually performed by functions
-  ///       hpp::fcl::collide of class hpp::fcl::ComputeCollision.
+  ///       coal::collide of class coal::ComputeCollision.
   FCL_REAL security_margin;
 
   /// @brief Distance below which bounding volumes are broken down.
-  /// See \ref hpp_fcl_collision_and_distance_lower_bound_computation
+  /// See \ref coal_collision_and_distance_lower_bound_computation
   FCL_REAL break_distance;
 
   /// @brief Distance above which GJK solver makes an early stopping.
@@ -394,7 +394,7 @@ struct COAL_DLLAPI CollisionResult : QueryResult {
 
  public:
   /// Lower bound on distance between objects if they are disjoint.
-  /// See \ref hpp_fcl_collision_and_distance_lower_bound_computation
+  /// See \ref coal_collision_and_distance_lower_bound_computation
   /// @note Always computed. If \ref CollisionRequest::distance_upper_bound is
   /// set to infinity, distance_lower_bound is the actual distance between the
   /// shapes.
@@ -499,14 +499,14 @@ struct COAL_DLLAPI CollisionResult : QueryResult {
 /// and second shape of a collision pair, a contact patch is represented as a
 /// polytope which vertices all belong to `P & S1 & S2`, where `&` denotes the
 /// set-intersection. Since a contact patch is a subset of a plane supported by
-/// `n`, it has a preferred direction. In HPP-FCL, the `Contact::normal` points
+/// `n`, it has a preferred direction. In Coal, the `Contact::normal` points
 /// from S1 to S2. In the same way, a contact patch points by default from S1
 /// to S2.
 ///
 /// @note For now (April 2024), a `ContactPatch` is a polygon (2D polytope),
 /// so the points of the set, forming the convex-hull of the polytope, are
 /// stored in a counter-clockwise fashion.
-/// @note If needed, the internal algorithms of hpp-fcl can easily be extended
+/// @note If needed, the internal algorithms of Coal can easily be extended
 /// to compute a contact volume instead of a contact patch.
 struct COAL_DLLAPI ContactPatch {
  public:
@@ -517,12 +517,12 @@ struct COAL_DLLAPI ContactPatch {
   Transform3f tf;
 
   /// @brief Direction of ContactPatch.
-  /// When doing collision detection, the convention of HPP-FCL is that the
+  /// When doing collision detection, the convention of Coal is that the
   /// normal always points from the first to the second shape of the collision
   /// pair i.e. from shape1 to shape2 when calling `collide(shape1, shape2)`.
   /// The PatchDirection enum allows to identify if the patch points from
   /// shape 1 to shape 2 (Default type) or from shape 2 to shape 1 (Inverted
-  /// type). The Inverted type should only be used for internal HPP-FCL
+  /// type). The Inverted type should only be used for internal Coal
   /// computations (it allows to properly define two separate contact patches in
   /// the same frame).
   enum PatchDirection { DEFAULT = 0, INVERTED = 1 };
@@ -555,7 +555,7 @@ struct COAL_DLLAPI ContactPatch {
   /// @brief Default constructor.
   /// Note: the preallocated size does not determine the maximum number of
   /// points in the patch, it only serves as preallocation if the maximum size
-  /// of the patch is known in advance. HPP-FCL will automatically expand/shrink
+  /// of the patch is known in advance. Coal will automatically expand/shrink
   /// the contact patch if needed.
   explicit ContactPatch(size_t preallocated_size = default_preallocated_size)
       : tf(Transform3f::Identity()),
diff --git a/include/coal/collision_utility.h b/include/coal/collision_utility.h
index 7f72d0e9c5895aafd89f3db8c16befe53dbf7f7e..19aa534a8d467ac4c0ea66fe805774ad3d7ef605 100644
--- a/include/coal/collision_utility.h
+++ b/include/coal/collision_utility.h
@@ -2,18 +2,18 @@
 // Copyright (c) 2022 INRIA
 // Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
 //
-// This file is part of hpp-fcl.
-// hpp-fcl is free software: you can redistribute it
+// This file is part of Coal.
+// Coal is free software: you can redistribute it
 // and/or modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation, either version
 // 3 of the License, or (at your option) any later version.
 //
-// hpp-fcl is distributed in the hope that it will be
+// Coal is distributed in the hope that it will be
 // useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // General Lesser Public License for more details.  You should have
 // received a copy of the GNU Lesser General Public License along with
-// hpp-fcl. If not, see <http://www.gnu.org/licenses/>.
+// Coal. If not, see <http://www.gnu.org/licenses/>.
 
 #ifndef COAL_COLLISION_UTILITY_H
 #define COAL_COLLISION_UTILITY_H
diff --git a/include/coal/contact_patch_func_matrix.h b/include/coal/contact_patch_func_matrix.h
index 50b08d291b40224df652c93b9286e627363c3a1f..ec2aeb49682758f9eee8912f91bf6965a0fef5df 100644
--- a/include/coal/contact_patch_func_matrix.h
+++ b/include/coal/contact_patch_func_matrix.h
@@ -52,12 +52,12 @@ struct COAL_DLLAPI ContactPatchFunctionMatrix {
   /// 1. two objects o1 and o2 and their configuration in world coordinate tf1
   ///    and tf2;
   /// 2. the collision result that generated contact patches candidates
-  ///    (`hpp::fcl::Contact`), from which contact patches will be expanded;
+  ///    (`coal::Contact`), from which contact patches will be expanded;
   /// 3. the solver for computation of contact patches;
   /// 4. the request setting for contact patches (e.g. maximum amount of
   ///    patches, patch tolerance etc.)
   /// 5. the structure to return contact patches
-  ///    (`hpp::fcl::ContactPatchResult`).
+  ///    (`coal::ContactPatchResult`).
   ///
   /// Note: we pass a GJKSolver, because it allows to reuse internal computation
   /// that was made during the narrow phase. It also allows to experiment with
diff --git a/include/coal/doc.hh b/include/coal/doc.hh
index ade896a29b99eeedfa1d76b67b62975f4f1a7d82..7b86b9d730e2a823db4620ec7c791592e7b21be5 100644
--- a/include/coal/doc.hh
+++ b/include/coal/doc.hh
@@ -35,26 +35,26 @@
 namespace coal {
 
 /// \mainpage
-/// \anchor hpp_fcl_documentation
+/// \anchor coal_documentation
 ///
-/// \section hpp_fcl_introduction Introduction
+/// \section coal_introduction Introduction
 ///
-/// hpp-fcl is a modified version the FCL libraries.
+/// Coal is a modified version the FCL libraries.
 ///
 /// It is a library for collision detection and distance computation between
 /// various types of geometric shapes reprensented either by
-/// \li basic shapes (hpp::fcl::ShapeBase) like box, sphere, cylinders, ...
-/// \li or by bounding volume hierarchies of various types (hpp::fcl::BVHModel)
+/// \li basic shapes (coal::ShapeBase) like box, sphere, cylinders, ...
+/// \li or by bounding volume hierarchies of various types (coal::BVHModel)
 ///
-/// \par Using hpp-fcl
+/// \par Using Coal
 ///
 /// The main entry points to the library are functions
-/// \li hpp::fcl::collide(const CollisionObject*, const CollisionObject*, const
-/// CollisionRequest&, CollisionResult&) \li hpp::fcl::distance(const
+/// \li coal::collide(const CollisionObject*, const CollisionObject*, const
+/// CollisionRequest&, CollisionResult&) \li coal::distance(const
 /// CollisionObject*, const CollisionObject*, const DistanceRequest&,
 /// DistanceResult&)
 ///
-/// \section hpp_fcl_collision_and_distance_lower_bound_computation Collision
+/// \section coal_collision_and_distance_lower_bound_computation Collision
 /// detection and distance lower bound
 ///
 /// Collision queries can return a distance lower bound between the two objects,
@@ -71,8 +71,8 @@ namespace coal {
 /// is only guaranted that it will be inferior to
 /// <em>distance - security_margin</em> and superior to \em break_distance.
 /// \note If CollisionRequest::security_margin is set to -inf, no collision test
-/// is performed by function hpp::fcl::collide or class
-/// hpp::fcl::ComputeCollision and the objects are considered as not
+/// is performed by function coal::collide or class
+/// coal::ComputeCollision and the objects are considered as not
 /// colliding.
 
 }  // namespace coal
diff --git a/include/coal/logging.h b/include/coal/logging.h
index c75db2fbed43d847d402aeccefb25f6a858cb266..235b475c53a0f9e135811510927f892d9a97b3c3 100644
--- a/include/coal/logging.h
+++ b/include/coal/logging.h
@@ -32,7 +32,7 @@
  *  POSSIBILITY OF SUCH DAMAGE.
  */
 
-/// This file defines basic logging macros for HPP-FCL, based on Boost.Log.
+/// This file defines basic logging macros for Coal, based on Boost.Log.
 /// To enable logging, define the preprocessor macro `COAL_ENABLE_LOGGING`.
 
 #ifndef COAL_LOGGING_H
diff --git a/include/coal/shape/geometric_shapes.h b/include/coal/shape/geometric_shapes.h
index ea3ad988216d51a9a23a85e85c14b87e002273ea..9d6a62f2e3ac7cce5ab52b050f941839f71bd4f8 100644
--- a/include/coal/shape/geometric_shapes.h
+++ b/include/coal/shape/geometric_shapes.h
@@ -646,7 +646,7 @@ class COAL_DLLAPI ConvexBase : public ShapeBase {
   ///          "Qt". If \c NULL, "Qt" is passed to Qhull.
   ///        - if \c keepTriangles is \c false, an empty string is passed to
   ///          Qhull.
-  /// \note hpp-fcl must have been compiled with option \c COAL_HAS_QHULL set
+  /// \note Coal must have been compiled with option \c COAL_HAS_QHULL set
   ///       to \c ON.
   static ConvexBase* convexHull(std::shared_ptr<std::vector<Vec3f>>& points,
                                 unsigned int num_points, bool keepTriangles,
diff --git a/python/version.cc b/python/version.cc
index 0b3b1d4ce8cb1b51551f4b562ae3254b34bd84c5..658a94297b21e1e78c845c94f550ec9f82f371f3 100644
--- a/python/version.cc
+++ b/python/version.cc
@@ -17,7 +17,7 @@ inline bool checkVersionAtMost(int major, int minor, int patch) {
 }
 
 void exposeVersion() {
-  // Define release numbers of the current hpp-fcl version.
+  // Define release numbers of the current Coal version.
   bp::scope().attr("__version__") =
       BOOST_PP_STRINGIZE(COAL_MAJOR_VERSION) "." BOOST_PP_STRINGIZE(COAL_MINOR_VERSION) "." BOOST_PP_STRINGIZE(COAL_PATCH_VERSION);
   bp::scope().attr("__raw_version__") = COAL_VERSION;
diff --git a/src/collision_utility.cpp b/src/collision_utility.cpp
index 213075724b09ba74a24fcc84adfe5c1f5ec31536..8fe84680e63851077214c7df7bf29f8006892769 100644
--- a/src/collision_utility.cpp
+++ b/src/collision_utility.cpp
@@ -1,18 +1,18 @@
 // Copyright (c) 2017, Joseph Mirabel
 // Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
 //
-// This file is part of hpp-fcl.
-// hpp-fcl is free software: you can redistribute it
+// This file is part of Coal.
+// Coal is free software: you can redistribute it
 // and/or modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation, either version
 // 3 of the License, or (at your option) any later version.
 //
-// hpp-fcl is distributed in the hope that it will be
+// Coal is distributed in the hope that it will be
 // useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // General Lesser Public License for more details.  You should have
 // received a copy of the GNU Lesser General Public License along with
-// hpp-fcl. If not, see <http://www.gnu.org/licenses/>.
+// Coal. If not, see <http://www.gnu.org/licenses/>.
 
 #include "coal/collision_utility.h"
 #include "coal/BVH/BVH_utility.h"
diff --git a/src/mesh_loader/assimp.cpp b/src/mesh_loader/assimp.cpp
index 2fe7498089f0f808f68f7ad663912ab6ebb74829..dc947ab0c1395a908c185184fef66cc6f6e252ab 100644
--- a/src/mesh_loader/assimp.cpp
+++ b/src/mesh_loader/assimp.cpp
@@ -39,7 +39,7 @@
 
 // Assimp >= 5.0 is forcing the use of C++11 keywords. A fix has been submitted
 // https://github.com/assimp/assimp/pull/2758. The next lines fixes the bug for
-// current version of hpp-fcl.
+// current version of Coal.
 #include <assimp/defs.h>
 #if !(__cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) && \
     defined(AI_NO_EXCEPT)
diff --git a/src/mesh_loader/loader.cpp b/src/mesh_loader/loader.cpp
index e7e275d4e05bdd0553f419a6099f6d81c1940ece..5ebe872d29697600f7bb2e04b23948866a64dba1 100644
--- a/src/mesh_loader/loader.cpp
+++ b/src/mesh_loader/loader.cpp
@@ -94,7 +94,7 @@ CollisionGeometryPtr_t MeshLoader::loadOctree(const std::string& filename) {
   shared_ptr<octomap::OcTree> octree(new octomap::OcTree(filename));
   return CollisionGeometryPtr_t(new coal::OcTree(octree));
 #else
-  COAL_THROW_PRETTY("hpp-fcl compiled without OctoMap. Cannot create OcTrees.",
+  COAL_THROW_PRETTY("Coal compiled without OctoMap. Cannot create OcTrees.",
                     std::logic_error);
 #endif
 }
diff --git a/src/narrowphase/gjk.cpp b/src/narrowphase/gjk.cpp
index 863c37a43ed640613591353e165d47d64cda3256..f6959bbdd9862fdca6fce18cf2763b8a8e45d442 100644
--- a/src/narrowphase/gjk.cpp
+++ b/src/narrowphase/gjk.cpp
@@ -152,7 +152,7 @@ void getClosestPoints(const GJK::Simplex& simplex, Vec3f& w0, Vec3f& w1) {
 /// Inflate the points along a normal.
 /// The normal is typically the normal of the separating plane found by GJK
 /// or the normal found by EPA.
-/// The normal should follow hpp-fcl convention: it points from shape0 to
+/// The normal should follow coal convention: it points from shape0 to
 /// shape1.
 template <bool Separated>
 void inflate(const MinkowskiDiff& shape, const Vec3f& normal, Vec3f& w0,
diff --git a/test/benchmark.cpp b/test/benchmark.cpp
index 372c8f06f7242434dfb62d39a8d2833cff6b8194..6cca3275c11a6a9ff3f5198c5e356905a68cb1a7 100644
--- a/test/benchmark.cpp
+++ b/test/benchmark.cpp
@@ -1,18 +1,18 @@
 // Copyright (c) 2016, Joseph Mirabel
 // Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
 //
-// This file is part of hpp-fcl.
-// hpp-fcl is free software: you can redistribute it
+// This file is part of Coal.
+// Coal is free software: you can redistribute it
 // and/or modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation, either version
 // 3 of the License, or (at your option) any later version.
 //
-// hpp-fcl is distributed in the hope that it will be
+// Coal is distributed in the hope that it will be
 // useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // General Lesser Public License for more details.  You should have
 // received a copy of the GNU Lesser General Public License along with
-// hpp-fcl. If not, see <http://www.gnu.org/licenses/>.
+// Coal. If not, see <http://www.gnu.org/licenses/>.
 
 #include <boost/filesystem.hpp>
 
diff --git a/test/profiling.cpp b/test/profiling.cpp
index f755661496276c89a293b0b82c51af2108fa8c3b..5ac747714ee2417713e9c0d5b5e296efb3e276d0 100644
--- a/test/profiling.cpp
+++ b/test/profiling.cpp
@@ -1,18 +1,18 @@
 // Copyright (c) 2017, Joseph Mirabel
 // Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
 //
-// This file is part of hpp-fcl.
-// hpp-fcl is free software: you can redistribute it
+// This file is part of Coal.
+// Coal is free software: you can redistribute it
 // and/or modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation, either version
 // 3 of the License, or (at your option) any later version.
 //
-// hpp-fcl is distributed in the hope that it will be
+// Coal is distributed in the hope that it will be
 // useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // General Lesser Public License for more details.  You should have
 // received a copy of the GNU Lesser General Public License along with
-// hpp-fcl. If not, see <http://www.gnu.org/licenses/>.
+// Coal. If not, see <http://www.gnu.org/licenses/>.
 
 #include <boost/filesystem.hpp>
 
diff --git a/test/swept_sphere_radius.cpp b/test/swept_sphere_radius.cpp
index f9ef8a1d85b9de95fc9aaec55d19693818da3662..6d2c33642a69e83d3c3eb80cfd13fc571442a42d 100644
--- a/test/swept_sphere_radius.cpp
+++ b/test/swept_sphere_radius.cpp
@@ -99,7 +99,7 @@ int line;
 // So we can also easily recover the witness points of the swept sphere shapes.
 //
 // This suite of test is designed to verify that property and generally test for
-// swept-sphere radius support in hpp-fcl.
+// swept-sphere radius support in Coal.
 // Notes:
 //   - not all collision pairs use GJK/EPA, so this test makes sure that
 //     swept-sphere radius is taken into account even for specialized collision