Use // comments when possible.

69 files changed, 726 insertions, 761 deletions

diff --git a/libdimension/bench/array.c b/libdimension/bench/array.c
index 3fe0c83..b48a03f 100644
--- a/libdimension/bench/array.c
+++ b/libdimension/bench/array.c
@@ -34,7 +34,7 @@ main(void)
     return EXIT_FAILURE;
   }
 
-  /* Benchmark allocation and deallocation */
+  // Benchmark allocation and deallocation
   dmnsn_array *array;
   sandglass_bench_fine(&sandglass, {
     array = dmnsn_new_array(sizeof(object));
@@ -42,10 +42,10 @@ main(void)
   });
   printf("dmnsn_new_array() + dmnsn_delete_array(): %ld\n", sandglass.grains);
 
-  /* Create our test array */
+  // Create our test array
   array = dmnsn_new_array(sizeof(object));
 
-  /* dmnsn_array_push() */
+  // dmnsn_array_push()
 
   printf("dmnsn_array_push():");
 
@@ -55,25 +55,25 @@ main(void)
   }
   printf("\n");
 
-  /* dmnsn_array_get() */
+  // dmnsn_array_get()
   sandglass_bench_fine(&sandglass, dmnsn_array_get(array, count/2, &object));
   printf("dmnsn_array_get(): %ld\n", sandglass.grains);
 
-  /* dmnsn_array_set() */
+  // dmnsn_array_set()
   sandglass_bench_fine(&sandglass, dmnsn_array_set(array, count/2, &object));
   printf("dmnsn_array_set(): %ld\n", sandglass.grains);
 
-  /* dmnsn_array_at() */
+  // dmnsn_array_at()
   void *ptr;
   sandglass_bench_fine(&sandglass, ptr = dmnsn_array_at(array, count/2));
   printf("dmnsn_array_at() = %p: %ld\n", ptr, sandglass.grains);
 
-  /* dmnsn_array_size() */
+  // dmnsn_array_size()
   size_t size;
   sandglass_bench_fine(&sandglass, size = dmnsn_array_size(array));
   printf("dmnsn_array_size() = %zu: %ld\n", size, sandglass.grains);
 
-  /* dmnsn_array_resize() */
+  // dmnsn_array_resize()
   dmnsn_array_resize(array, count);
   sandglass_bench_noprecache(&sandglass, dmnsn_array_resize(array, count * 2));
   printf("dmnsn_array_resize(): %ld", sandglass.grains);
@@ -81,7 +81,7 @@ main(void)
   sandglass_bench_noprecache(&sandglass, dmnsn_array_resize(array, count));
   printf(" %ld\n", sandglass.grains);
 
-  /* dmnsn_array_insert() */
+  // dmnsn_array_insert()
 
   printf("dmnsn_array_insert():");
 
@@ -92,7 +92,7 @@ main(void)
   }
   printf("\n");
 
-  /* dmnsn_array_remove() */
+  // dmnsn_array_remove()
 
   printf("dmnsn_array_remove():");
 
@@ -103,7 +103,7 @@ main(void)
   }
   printf("\n");
 
-  /* dmnsn_array_pop() */
+  // dmnsn_array_pop()
 
   printf("dmnsn_array_pop():");
 
diff --git a/libdimension/bench/future.c b/libdimension/bench/future.c
index f42430e..fd26363 100644
--- a/libdimension/bench/future.c
+++ b/libdimension/bench/future.c
@@ -37,7 +37,7 @@ dmnsn_bench_future_increment(void)
     exit(EXIT_FAILURE);
   }
 
-  /* Benchmark the increment operation. */
+  // Benchmark the increment operation.
   sandglass_bench_fine(&sandglass, dmnsn_future_increment(future));
   printf("dmnsn_future_increment(): %ld\n", sandglass.grains);
 
@@ -62,7 +62,7 @@ dmnsn_bench_future_thread(void *ptr)
   size_t nthreads = 2*dmnsn_ncpus();
   dmnsn_future_set_total(future, nthreads*ITERATIONS);
 
-  /* Now run a bunch of increments concurrently. */
+  // Now run a bunch of increments concurrently.
   return dmnsn_execute_concurrently(future, dmnsn_bench_future_ccthread,
                                     future, nthreads);
 }
diff --git a/libdimension/bench/geometry.c b/libdimension/bench/geometry.c
index 4b8c12a..56c8b58 100644
--- a/libdimension/bench/geometry.c
+++ b/libdimension/bench/geometry.c
@@ -35,13 +35,13 @@ main(void)
     return EXIT_FAILURE;
   }
 
-  /* dmnsn_new_vector() */
+  // dmnsn_new_vector()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_new_vector(1.0, 2.0, 3.0);
   });
   printf("dmnsn_new_vector(): %ld\n", sandglass.grains);
 
-  /* dmnsn_matrix_construct() */
+  // dmnsn_matrix_construct()
   sandglass_bench_fine(&sandglass, {
     matrix = dmnsn_new_matrix(1.0, 1.0, 0.0, 0.0,
                               1.0, 1.0, 1.0, 0.0,
@@ -49,92 +49,92 @@ main(void)
   });
   printf("dmnsn_new_matrix(): %ld\n", sandglass.grains);
 
-  /* dmnsn_identity_matrix() */
+  // dmnsn_identity_matrix()
   sandglass_bench_fine(&sandglass, {
     matrix = dmnsn_identity_matrix();
   });
   printf("dmnsn_identity_matrix(): %ld\n", sandglass.grains);
 
-  /* dmnsn_scale_matrix() */
+  // dmnsn_scale_matrix()
   sandglass_bench_fine(&sandglass, {
     matrix = dmnsn_scale_matrix(vector);
   });
   printf("dmnsn_scale_matrix(): %ld\n", sandglass.grains);
 
-  /* dmnsn_identity_matrix() */
+  // dmnsn_identity_matrix()
   sandglass_bench_fine(&sandglass, {
     matrix = dmnsn_translation_matrix(vector);
   });
   printf("dmnsn_translation_matrix(): %ld\n", sandglass.grains);
 
-  /* dmnsn_rotation_matrix() */
+  // dmnsn_rotation_matrix()
   sandglass_bench_fine(&sandglass, {
     matrix = dmnsn_rotation_matrix(vector);
   });
   printf("dmnsn_rotation_matrix(): %ld\n", sandglass.grains);
 
-  /* dmnsn_new_line() */
+  // dmnsn_new_line()
   vector2 = dmnsn_new_vector(3.0, 2.0, 1.0);
   sandglass_bench_fine(&sandglass, {
     line = dmnsn_new_line(vector, vector2);
   });
   printf("dmnsn_new_line(): %ld\n", sandglass.grains);
 
-  /* dmnsn_vector_add() */
+  // dmnsn_vector_add()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_vector_add(vector, vector2);
   });
   printf("dmnsn_vector_add(): %ld\n", sandglass.grains);
 
-  /* dmnsn_vector_sub() */
+  // dmnsn_vector_sub()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_vector_sub(vector, vector2);
   });
   printf("dmnsn_vector_sub(): %ld\n", sandglass.grains);
 
-  /* dmnsn_vector_mul() */
+  // dmnsn_vector_mul()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_vector_mul(2.0, vector);
   });
   printf("dmnsn_vector_mul(): %ld\n", sandglass.grains);
 
-  /* dmnsn_vector_div() */
+  // dmnsn_vector_div()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_vector_div(vector, 2.0);
   });
   printf("dmnsn_vector_div(): %ld\n", sandglass.grains);
 
-  /* dmnsn_vector_cross() */
+  // dmnsn_vector_cross()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_vector_cross(vector, vector2);
   });
   printf("dmnsn_vector_cross(): %ld\n", sandglass.grains);
 
-  /* dmnsn_vector_dot() */
+  // dmnsn_vector_dot()
   sandglass_bench_fine(&sandglass, {
     result = dmnsn_vector_dot(vector, vector2);
   });
   printf("dmnsn_vector_dot(): %ld\n", sandglass.grains);
 
-  /* dmnsn_vector_norm() */
+  // dmnsn_vector_norm()
   sandglass_bench_fine(&sandglass, {
     result = dmnsn_vector_norm(vector);
   });
   printf("dmnsn_vector_norm(): %ld\n", sandglass.grains);
 
-  /* dmnsn_vector_normalized() */
+  // dmnsn_vector_normalized()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_vector_normalized(vector);
   });
   printf("dmnsn_vector_normalized(): %ld\n", sandglass.grains);
 
-  /* dmnsn_matrix_inverse() */
+  // dmnsn_matrix_inverse()
   sandglass_bench_fine(&sandglass, {
     matrix = dmnsn_matrix_inverse(matrix);
   });
   printf("dmnsn_matrix_inverse(): %ld\n", sandglass.grains);
 
-  /* dmnsn_matrix_inverse(HARD) */
+  // dmnsn_matrix_inverse(HARD)
   matrix2 = dmnsn_new_matrix(1.0, 1.0, 0.0, 0.0,
                              1.0, 1.0, 1.0, 0.0,
                              0.0, 1.0, 1.0, 0.0);
@@ -143,37 +143,37 @@ main(void)
   });
   printf("dmnsn_matrix_inverse(HARD): %ld\n", sandglass.grains);
 
-  /* dmnsn_matrix_mul() */
+  // dmnsn_matrix_mul()
   sandglass_bench_fine(&sandglass, {
     matrix = dmnsn_matrix_mul(matrix, matrix2);
   });
   printf("dmnsn_matrix_mul(): %ld\n", sandglass.grains);
 
-  /* dmnsn_transform_point() */
+  // dmnsn_transform_point()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_transform_point(matrix, vector);
   });
   printf("dmnsn_transform_point(): %ld\n", sandglass.grains);
 
-  /* dmnsn_transform_direction() */
+  // dmnsn_transform_direction()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_transform_direction(matrix, vector);
   });
   printf("dmnsn_transform_direction(): %ld\n", sandglass.grains);
 
-  /* dmnsn_transform_normal() */
+  // dmnsn_transform_normal()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_transform_normal(matrix, vector);
   });
   printf("dmnsn_transform_normal(): %ld\n", sandglass.grains);
 
-  /* dmnsn_transform_line() */
+  // dmnsn_transform_line()
   sandglass_bench_fine(&sandglass, {
     line = dmnsn_transform_line(matrix, line);
   });
   printf("dmnsn_transform_line(): %ld\n", sandglass.grains);
 
-  /* dmnsn_line_point() */
+  // dmnsn_line_point()
   sandglass_bench_fine(&sandglass, {
     vector = dmnsn_line_point(line, result);
   });
diff --git a/libdimension/bench/polynomial.c b/libdimension/bench/polynomial.c
index b66648c..bf3d2b0 100644
--- a/libdimension/bench/polynomial.c
+++ b/libdimension/bench/polynomial.c
@@ -27,29 +27,29 @@ main(void)
 #define NPOLY 5
   double p[NPOLY][NPOLY + 1], x[NPOLY];
 
-  /* p[0][] = x - 0.5; */
+  // p[0][] = x - 0.5;
   p[0][1] =  1.0;
   p[0][0] = -0.5;
 
-  /* p[1][] = (x + 0.5)*(x - 0.5) */
+  // p[1][] = (x + 0.5)*(x - 0.5)
   p[1][2] =  1.0;
   p[1][1] =  0.0;
   p[1][0] = -0.25;
 
-  /* p[2][] = (x + 1)*(x - 1.2345)*(x - 100) */
+  // p[2][] = (x + 1)*(x - 1.2345)*(x - 100)
   p[2][3] =  1.0;
   p[2][2] = -100.2345;
   p[2][1] =  22.2155;
   p[2][0] =  123.45;
 
-  /* p[3][] = (x + 1)*(x - 1.2345)*(x - 5)*(x - 100) */
+  // p[3][] = (x + 1)*(x - 1.2345)*(x - 5)*(x - 100)
   p[3][4] =  1.0;
   p[3][3] = -105.2345;
   p[3][2] =  523.388;
   p[3][1] =  12.3725;
   p[3][0] = -617.25;
 
-  /* p[4][] = (x + 1)*(x - 1.2345)*(x - 2.3456)*(x - 5)*(x - 100) */
+  // p[4][] = (x + 1)*(x - 1.2345)*(x - 2.3456)*(x - 5)*(x - 100)
   p[4][5] =  1.0;
   p[4][4] = -107.5801;
   p[4][3] =  770.2260432;
diff --git a/libdimension/bench/prtree.c b/libdimension/bench/prtree.c
index dc5a90d..6c5d3ef 100644
--- a/libdimension/bench/prtree.c
+++ b/libdimension/bench/prtree.c
@@ -98,7 +98,7 @@ main(void)
   });
   printf("dmnsn_new_bvh(DMNSN_BVH_PRTREE): %ld\n", sandglass.grains);
 
-  /* dmnsn_bvh_intersection() */
+  // dmnsn_bvh_intersection()
   dmnsn_line ray = dmnsn_new_line(
     dmnsn_new_vector( 1.0,  1.0, -2.0),
     dmnsn_new_vector(-0.5, -0.5,  1.0)
@@ -115,13 +115,13 @@ main(void)
   });
   printf("dmnsn_bvh_intersection(nocache): %ld\n", sandglass.grains);
 
-  /* dmnsn_bvh_inside() */
+  // dmnsn_bvh_inside()
   sandglass_bench_fine(&sandglass, {
     dmnsn_bvh_inside(bvh, dmnsn_zero);
   });
   printf("dmnsn_bvh_inside(): %ld\n", sandglass.grains);
 
-  /* Cleanup */
+  // Cleanup
   dmnsn_delete_bvh(bvh);
   dmnsn_delete_pool(pool);
   return EXIT_SUCCESS;
diff --git a/libdimension/bench/triangle.c b/libdimension/bench/triangle.c
index 05b8f47..b2b91d0 100644
--- a/libdimension/bench/triangle.c
+++ b/libdimension/bench/triangle.c
@@ -46,7 +46,7 @@ main(void)
   dmnsn_line line;
   bool intersected;
 
-  /* Intersecting case */
+  // Intersecting case
   line = dmnsn_new_line(dmnsn_new_vector(2.0, 1.0, -1.0), dmnsn_z);
   sandglass_bench_fine(&sandglass, {
     intersected = dmnsn_object_intersection(triangle, line, &intersection);
@@ -54,7 +54,7 @@ main(void)
   dmnsn_assert(intersected, "Didn't intersect");
   printf("dmnsn_triangle_intersection(true): %ld\n", sandglass.grains);
 
-  /* Non-intersecting case */
+  // Non-intersecting case
   line = dmnsn_new_line(dmnsn_new_vector(3.0, 3.0, -1.0), dmnsn_z);
   sandglass_bench_fine(&sandglass, {
     intersected = dmnsn_object_intersection(triangle, line, &intersection);
diff --git a/libdimension/bvh.c b/libdimension/bvh.c
index 0a31662..462cbee 100644
--- a/libdimension/bvh.c
+++ b/libdimension/bvh.c
@@ -25,7 +25,7 @@
 
 #include "dimension-internal.h"
 
-/** Implementation for DMNSN_BVH_NONE: just stick all objects in one node. */
+/// Implementation for DMNSN_BVH_NONE: just stick all objects in one node.
 static dmnsn_bvh_node *
 dmnsn_new_stupid_bvh(const dmnsn_array *objects)
 {
@@ -39,21 +39,21 @@ dmnsn_new_stupid_bvh(const dmnsn_array *objects)
   return root;
 }
 
-/* Implementation of opaque dmnsn_bvh type. */
+// Implementation of opaque dmnsn_bvh type.
 struct dmnsn_bvh {
-  dmnsn_array *unbounded;           /**< The unbounded objects. */
-  dmnsn_array *bounded;             /**< The BVH of the bounded objects. */
-  pthread_key_t intersection_cache; /**< The thread-local intersection cache. */
+  dmnsn_array *unbounded;           ///< The unbounded objects.
+  dmnsn_array *bounded;             ///< The BVH of the bounded objects.
+  pthread_key_t intersection_cache; ///< The thread-local intersection cache.
 };
 
-/** A flat BVH node for storing in an array for fast pre-order traversal. */
+/// A flat BVH node for storing in an array for fast pre-order traversal.
 typedef struct dmnsn_flat_bvh_node {
-  dmnsn_bounding_box bounding_box; /* The bounding box of this node. */
-  dmnsn_object *object;            /* The referenced object, for leaf nodes. */
-  ptrdiff_t skip;                  /* Displacement to the next sibling. */
+  dmnsn_bounding_box bounding_box; // The bounding box of this node.
+  dmnsn_object *object;            // The referenced object, for leaf nodes.
+  ptrdiff_t skip;                  // Displacement to the next sibling.
 } dmnsn_flat_bvh_node;
 
-/** Add an object or its children, if any, to an array. */
+/// Add an object or its children, if any, to an array.
 static void
 dmnsn_split_add_object(dmnsn_array *objects, const dmnsn_object *object)
 {
@@ -66,7 +66,7 @@ dmnsn_split_add_object(dmnsn_array *objects, const dmnsn_object *object)
   }
 }
 
-/** Split unions to create the input for the BVH. */
+/// Split unions to create the input for the BVH.
 static dmnsn_array *
 dmnsn_split_objects(const dmnsn_array *objects)
 {
@@ -77,7 +77,7 @@ dmnsn_split_objects(const dmnsn_array *objects)
   return split;
 }
 
-/** Split unbounded objects into a new array. */
+/// Split unbounded objects into a new array.
 static dmnsn_array *
 dmnsn_split_unbounded(dmnsn_array *objects)
 {
@@ -98,7 +98,7 @@ dmnsn_split_unbounded(dmnsn_array *objects)
   return unbounded;
 }
 
-/** Recursively flatten a BVH into an array of flat nodes. */
+/// Recursively flatten a BVH into an array of flat nodes.
 static void
 dmnsn_flatten_bvh_recursive(dmnsn_bvh_node *node, dmnsn_array *flat)
 {
@@ -113,12 +113,12 @@ dmnsn_flatten_bvh_recursive(dmnsn_bvh_node *node, dmnsn_array *flat)
     dmnsn_flatten_bvh_recursive(node->children[i], flat);
   }
 
-  /* Array could have been realloc()'d somewhere else above */
+  // Array could have been realloc()'d somewhere else above
   flatnode = dmnsn_array_at(flat, currenti);
   flatnode->skip = dmnsn_array_size(flat) - currenti;
 }
 
-/** Flatten a BVH into an array of flat nodes. */
+/// Flatten a BVH into an array of flat nodes.
 static dmnsn_array *
 dmnsn_flatten_bvh(dmnsn_bvh_node *root)
 {
@@ -171,13 +171,13 @@ dmnsn_delete_bvh(dmnsn_bvh *bvh)
   }
 }
 
-/** A line with pre-calculated reciprocals to avoid divisions. */
+/// A line with pre-calculated reciprocals to avoid divisions.
 typedef struct dmnsn_optimized_line {
-  dmnsn_vector x0;    /**< The origin of the line. */
-  dmnsn_vector n_inv; /**< The inverse of each component of the line's slope .*/
+  dmnsn_vector x0;    ///< The origin of the line.
+  dmnsn_vector n_inv; ///< The inverse of each component of the line's slope
 } dmnsn_optimized_line;
 
-/** Precompute inverses for faster ray-box intersection tests. */
+/// Precompute inverses for faster ray-box intersection tests.
 static inline dmnsn_optimized_line
 dmnsn_optimize_line(dmnsn_line line)
 {
@@ -188,19 +188,17 @@ dmnsn_optimize_line(dmnsn_line line)
   return optline;
 }
 
-/** Ray-AABB intersection test, by the slab method.  Highly optimized. */
+/// Ray-AABB intersection test, by the slab method.  Highly optimized.
 static inline bool
 dmnsn_ray_box_intersection(dmnsn_optimized_line optline,
                            dmnsn_bounding_box box, double t)
 {
-  /*
-   * This is actually correct, even though it appears not to handle edge cases
-   * (line.n.{x,y,z} == 0).  It works because the infinities that result from
-   * dividing by zero will still behave correctly in the comparisons.  Lines
-   * which are parallel to an axis and outside the box will have tmin == inf
-   * or tmax == -inf, while lines inside the box will have tmin and tmax
-   * unchanged.
-   */
+  // This is actually correct, even though it appears not to handle edge cases
+  // (line.n.{x,y,z} == 0).  It works because the infinities that result from
+  // dividing by zero will still behave correctly in the comparisons.  Lines
+  // which are parallel to an axis and outside the box will have tmin == inf
+  // or tmax == -inf, while lines inside the box will have tmin and tmax
+  // unchanged.
 
   double tx1 = (box.min.x - optline.x0.x)*optline.n_inv.x;
   double tx2 = (box.max.x - optline.x0.x)*optline.n_inv.x;
@@ -223,10 +221,10 @@ dmnsn_ray_box_intersection(dmnsn_optimized_line optline,
   return tmax >= dmnsn_max(0.0, tmin) && tmin < t;
 }
 
-/** The number of intersections to cache. */
+/// The number of intersections to cache.
 #define DMNSN_INTERSECTION_CACHE_SIZE 32
 
-/** An array of cached intersections. */
+/// An array of cached intersections.
 typedef struct dmnsn_intersection_cache {
   size_t i;
   dmnsn_object *objects[DMNSN_INTERSECTION_CACHE_SIZE];
@@ -250,7 +248,7 @@ dmnsn_get_intersection_cache(const dmnsn_bvh *bvh)
   return cache;
 }
 
-/** Test for a closer object intersection than we've found so far. */
+/// Test for a closer object intersection than we've found so far.
 static inline bool
 dmnsn_closer_intersection(dmnsn_object *object, dmnsn_line ray,
                           dmnsn_intersection *intersection, double *t)
@@ -272,15 +270,15 @@ dmnsn_bvh_intersection(const dmnsn_bvh *bvh, dmnsn_line ray,
 {
   double t = INFINITY;
 
-  /* Search the unbounded objects */
+  // Search the unbounded objects
   DMNSN_ARRAY_FOREACH (dmnsn_object **, object, bvh->unbounded) {
     dmnsn_closer_intersection(*object, ray, intersection, &t);
   }
 
-  /* Precalculate 1.0/ray.n.{x,y,z} to save time in intersection tests */
+  // Precalculate 1.0/ray.n.{x,y,z} to save time in intersection tests
   dmnsn_optimized_line optline = dmnsn_optimize_line(ray);
 
-  /* Search the intersection cache */
+  // Search the intersection cache
   dmnsn_intersection_cache *cache = dmnsn_get_intersection_cache(bvh);
   if (dmnsn_unlikely(reset)) {
     cache->i = 0;
@@ -295,7 +293,7 @@ dmnsn_bvh_intersection(const dmnsn_bvh *bvh, dmnsn_line ray,
     }
   }
 
-  /* Search the bounded objects */
+  // Search the bounded objects
   dmnsn_flat_bvh_node *node = dmnsn_array_first(bvh->bounded);
   dmnsn_flat_bvh_node *last = dmnsn_array_last(bvh->bounded);
   while (node <= last) {
@@ -311,7 +309,7 @@ dmnsn_bvh_intersection(const dmnsn_bvh *bvh, dmnsn_line ray,
     }
   }
 
-  /* Update the cache */
+  // Update the cache
   if (dmnsn_likely(cache->i < DMNSN_INTERSECTION_CACHE_SIZE)) {
     cache->objects[cache->i] = found;
     ++cache->i;
@@ -323,13 +321,13 @@ dmnsn_bvh_intersection(const dmnsn_bvh *bvh, dmnsn_line ray,
 DMNSN_HOT bool
 dmnsn_bvh_inside(const dmnsn_bvh *bvh, dmnsn_vector point)
 {
-  /* Search the unbounded objects */
+  // Search the unbounded objects
   DMNSN_ARRAY_FOREACH (dmnsn_object **, object, bvh->unbounded) {
     if (dmnsn_object_inside(*object, point))
       return true;
   }
 
-  /* Search the bounded objects */
+  // Search the bounded objects
   dmnsn_flat_bvh_node *node = dmnsn_array_first(bvh->bounded);
   dmnsn_flat_bvh_node *last = dmnsn_array_last(bvh->bounded);
   while (node <= last) {
diff --git a/libdimension/bvh.h b/libdimension/bvh.h
index 2c3a8a4..27652c1 100644
--- a/libdimension/bvh.h
+++ b/libdimension/bvh.h
@@ -27,50 +27,50 @@
 
 #include <stdbool.h>
 
-/** A bounding volume hierarchy. */
+/// A bounding volume hierarchy.
 typedef struct dmnsn_bvh dmnsn_bvh;
 
-/** Available BVH implementations. */
+/// Available BVH implementations.
 typedef enum dmnsn_bvh_kind {
   DMNSN_BVH_NONE,
   DMNSN_BVH_PRTREE,
 } dmnsn_bvh_kind;
 
-/** Create a BVH. */
+/// Create a BVH.
 DMNSN_INTERNAL dmnsn_bvh *dmnsn_new_bvh(const dmnsn_array *objects,
                                         dmnsn_bvh_kind kind);
-/** Delete a BVH. */
+/// Delete a BVH.
 DMNSN_INTERNAL void dmnsn_delete_bvh(dmnsn_bvh *bvh);
 
-/** Find the closest ray-object intersection in the tree. */
+/// Find the closest ray-object intersection in the tree.
 DMNSN_INTERNAL bool dmnsn_bvh_intersection(const dmnsn_bvh *bvh,
                                            dmnsn_line ray,
                                            dmnsn_intersection *intersection,
                                            bool reset);
-/** Determine whether a point is inside any object in the tree. */
+/// Determine whether a point is inside any object in the tree.
 DMNSN_INTERNAL bool dmnsn_bvh_inside(const dmnsn_bvh *bvh, dmnsn_vector point);
-/** Return the bounding box of the whole hierarchy. */
+/// Return the bounding box of the whole hierarchy.
 DMNSN_INTERNAL dmnsn_bounding_box dmnsn_bvh_bounding_box(const dmnsn_bvh *bvh);
 
-/** A non-flat BVH representation, used by BVH implementations. */
+/// A non-flat BVH representation, used by BVH implementations.
 typedef struct dmnsn_bvh_node {
-  dmnsn_bounding_box bounding_box;   /** The bounding box of this node. */
-  dmnsn_object *object;              /** The object, for leaf nodes. */
-  int data;                          /** Extra field for implementation use. */
-  size_t nchildren;                  /** How many children this node has. */
-  size_t max_children;               /** Maximum number of children. */
-  struct dmnsn_bvh_node *children[]; /** Flexible array of children. */
+  dmnsn_bounding_box bounding_box;   /// The bounding box of this node.
+  dmnsn_object *object;              /// The object, for leaf nodes.
+  int data;                          /// Extra field for implementation use.
+  size_t nchildren;                  /// How many children this node has.
+  size_t max_children;               /// Maximum number of children.
+  struct dmnsn_bvh_node *children[]; /// Flexible array of children.
 } dmnsn_bvh_node;
 
-/** Create a BVH node. */
+/// Create a BVH node.
 DMNSN_INTERNAL dmnsn_bvh_node *dmnsn_new_bvh_node(size_t max_children);
 
-/** Create a BVH leaf node. */
+/// Create a BVH leaf node.
 DMNSN_INTERNAL dmnsn_bvh_node *dmnsn_new_bvh_leaf_node(dmnsn_object *object);
 
-/** Delete a BVH node. */
+/// Delete a BVH node.
 DMNSN_INTERNAL void dmnsn_delete_bvh_node(dmnsn_bvh_node *node);
 
-/** Add a child to a BVH node. */
+/// Add a child to a BVH node.
 DMNSN_INTERNAL void dmnsn_bvh_node_add(dmnsn_bvh_node *parent,
                                        dmnsn_bvh_node *child);
diff --git a/libdimension/camera.c b/libdimension/camera.c
index 3db9f2c..550b41c 100644
--- a/libdimension/camera.c
+++ b/libdimension/camera.c
@@ -26,7 +26,7 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
-/* Allocate a new dummy camera */
+// Allocate a new dummy camera
 dmnsn_camera *
 dmnsn_new_camera(dmnsn_pool *pool)
 {
@@ -35,14 +35,14 @@ dmnsn_new_camera(dmnsn_pool *pool)
   return camera;
 }
 
-/* Initialize a camera */
+// Initialize a camera
 void
 dmnsn_init_camera(dmnsn_camera *camera)
 {
   camera->trans = dmnsn_identity_matrix();
 }
 
-/* Invoke the camera ray function */
+// Invoke the camera ray function
 dmnsn_line
 dmnsn_camera_ray(const dmnsn_camera *camera, double x, double y)
 {
diff --git a/libdimension/canvas.c b/libdimension/canvas.c
index cb7e5ce..b605108 100644
--- a/libdimension/canvas.c
+++ b/libdimension/canvas.c
@@ -25,7 +25,7 @@
 
 #include "dimension-internal.h"
 
-/** cleanup_fn for canvases. */
+/// cleanup_fn for canvases.
 static void dmnsn_canvas_cleanup(void *ptr);
 
 dmnsn_canvas *
@@ -44,7 +44,7 @@ dmnsn_canvas_cleanup(void *ptr)
 {
   dmnsn_canvas *canvas = ptr;
 
-  /* Free the optimizers */
+  // Free the optimizers
   DMNSN_ARRAY_FOREACH (dmnsn_canvas_optimizer *, i, canvas->optimizers) {
     if (i->free_fn) {
       i->free_fn(i->ptr);
@@ -53,7 +53,7 @@ dmnsn_canvas_cleanup(void *ptr)
   dmnsn_delete_array(canvas->optimizers);
 }
 
-/* Set a canvas optimizer */
+// Set a canvas optimizer
 void
 dmnsn_canvas_optimize(dmnsn_canvas *canvas,
                       const dmnsn_canvas_optimizer *optimizer)
@@ -61,7 +61,7 @@ dmnsn_canvas_optimize(dmnsn_canvas *canvas,
   dmnsn_array_push(canvas->optimizers, optimizer);
 }
 
-/* Find an optimizer if it's already installed */
+// Find an optimizer if it's already installed
 dmnsn_canvas_optimizer *
 dmnsn_canvas_find_optimizer(const dmnsn_canvas *canvas,
                             dmnsn_canvas_optimizer_fn *optimizer_fn)
@@ -75,7 +75,7 @@ dmnsn_canvas_find_optimizer(const dmnsn_canvas *canvas,
   return NULL;
 }
 
-/* Set the value of a pixel */
+// Set the value of a pixel
 void
 dmnsn_canvas_set_pixel(dmnsn_canvas *canvas, size_t x, size_t y,
                        dmnsn_tcolor tcolor)
@@ -84,16 +84,16 @@ dmnsn_canvas_set_pixel(dmnsn_canvas *canvas, size_t x, size_t y,
                "Canvas access out of bounds.");
   dmnsn_assert(!dmnsn_tcolor_isnan(tcolor), "Pixel has NaN component.");
 
-  /* Set the pixel */
+  // Set the pixel
   canvas->pixels[y*canvas->width + x] = tcolor;
 
-  /* Call the optimizers */
+  // Call the optimizers
   DMNSN_ARRAY_FOREACH (dmnsn_canvas_optimizer *, i, canvas->optimizers) {
     i->optimizer_fn(canvas, i->ptr, x, y);
   }
 }
 
-/* Fill a canvas with a solid color */
+// Fill a canvas with a solid color
 void
 dmnsn_canvas_clear(dmnsn_canvas *canvas, dmnsn_tcolor tcolor)
 {
diff --git a/libdimension/canvas_pigment.c b/libdimension/canvas_pigment.c
index d4812cf..2b1e2b6 100644
--- a/libdimension/canvas_pigment.c
+++ b/libdimension/canvas_pigment.c
@@ -25,13 +25,13 @@
 
 #include "dimension.h"
 
-/** Canvas pigment type. */
+/// Canvas pigment type.
 typedef struct dmnsn_canvas_pigment {
   dmnsn_pigment pigment;
   dmnsn_canvas *canvas;
 } dmnsn_canvas_pigment;
 
-/** Canvas pigment color callback. */
+/// Canvas pigment color callback.
 static dmnsn_tcolor
 dmnsn_canvas_pigment_fn(const dmnsn_pigment *pigment, dmnsn_vector v)
 {
@@ -43,7 +43,7 @@ dmnsn_canvas_pigment_fn(const dmnsn_pigment *pigment, dmnsn_vector v)
   return dmnsn_canvas_get_pixel(canvas, x%canvas->width, y%canvas->height);
 }
 
-/* Create a canvas color */
+// Create a canvas color
 dmnsn_pigment *
 dmnsn_new_canvas_pigment(dmnsn_pool *pool, dmnsn_canvas *canvas)
 {
diff --git a/libdimension/checker.c b/libdimension/checker.c
index 01b19f3..740abe8 100644
--- a/libdimension/checker.c
+++ b/libdimension/checker.c
@@ -25,7 +25,7 @@
 
 #include "dimension-internal.h"
 
-/** Checker pattern callback. */
+/// Checker pattern callback.
 static double
 dmnsn_checker_pattern_fn(const dmnsn_pattern *checker, dmnsn_vector v)
 {
@@ -40,7 +40,7 @@ dmnsn_checker_pattern_fn(const dmnsn_pattern *checker, dmnsn_vector v)
   if (zmod < -dmnsn_epsilon)
     zmod += 2.0;
 
-  /* Return 0 when an even number of coordinates are in [0, 1), 1 otherwise */
+  // Return 0 when an even number of coordinates are in [0, 1), 1 otherwise
   unsigned int n = 0;
   if (xmod >= 1.0)
     ++n;
@@ -51,7 +51,7 @@ dmnsn_checker_pattern_fn(const dmnsn_pattern *checker, dmnsn_vector v)
   return (n%2 == 0) ? 0.0 : 1.0;
 }
 
-/** The singleton instance. */
+/// The singleton instance.
 static dmnsn_pattern dmnsn_checker_instance = {
   .pattern_fn = dmnsn_checker_pattern_fn,
 };
diff --git a/libdimension/cone.c b/libdimension/cone.c
index fb05231..1e95b0a 100644
--- a/libdimension/cone.c
+++ b/libdimension/cone.c
@@ -26,13 +26,13 @@
 #include "dimension.h"
 #include <math.h>
 
-/** Cone type. */
+/// Cone type.
 typedef struct dmnsn_cone {
   dmnsn_object object;
   double r1, r2;
 } dmnsn_cone;
 
-/** Intersection callback for a cone. */
+/// Intersection callback for a cone.
 static bool
 dmnsn_cone_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                            dmnsn_intersection *intersection)
@@ -40,8 +40,7 @@ dmnsn_cone_intersection_fn(const dmnsn_object *object, dmnsn_line l,
   const dmnsn_cone *cone = (const dmnsn_cone *)object;
   double r1 = cone->r1, r2 = cone->r2;
 
-  /* Solve (x0 + nx*t)^2 + (z0 + nz*t)^2
-           == (((r2 - r1)*(y0 + ny*t) + r1 + r2)/2)^2 */
+  // Solve (x0 + nx*t)^2 + (z0 + nz*t)^2 == (((r2 - r1)*(y0 + ny*t) + r1 + r2)/2)^2
   double poly[3], x[2];
   poly[2] = l.n.x*l.n.x + l.n.z*l.n.z - l.n.y*l.n.y*(r2 - r1)*(r2 - r1)/4.0;
   poly[1] = 2.0*(l.n.x*l.x0.x + l.n.z*l.x0.z)
@@ -78,7 +77,7 @@ dmnsn_cone_intersection_fn(const dmnsn_object *object, dmnsn_line l,
   return false;
 }
 
-/** Inside callback for a cone. */
+/// Inside callback for a cone.
 static bool
 dmnsn_cone_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
@@ -89,7 +88,7 @@ dmnsn_cone_inside_fn(const dmnsn_object *object, dmnsn_vector point)
          && point.y > -1.0 && point.y < 1.0;
 }
 
-/** Cone bounding callback. */
+/// Cone bounding callback.
 static dmnsn_bounding_box
 dmnsn_cone_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
 {
@@ -100,20 +99,20 @@ dmnsn_cone_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
   return dmnsn_transform_bounding_box(trans, box);
 }
 
-/** Cone vtable. */
+/// Cone vtable.
 static const dmnsn_object_vtable dmnsn_cone_vtable = {
   .intersection_fn = dmnsn_cone_intersection_fn,
   .inside_fn = dmnsn_cone_inside_fn,
   .bounding_fn = dmnsn_cone_bounding_fn,
 };
 
-/** Cone cap type. */
+/// Cone cap type.
 typedef struct dmnsn_cone_cap {
   dmnsn_object object;
   double r;
 } dmnsn_cone_cap;
 
-/** Cone cap intersection function. */
+/// Cone cap intersection function.
 static bool
 dmnsn_cone_cap_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                                dmnsn_intersection *intersection)
@@ -133,14 +132,14 @@ dmnsn_cone_cap_intersection_fn(const dmnsn_object *object, dmnsn_line l,
   return false;
 }
 
-/** Inside callback for a cone cap. */
+/// Inside callback for a cone cap.
 static bool
 dmnsn_cone_cap_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
   return false;
 }
 
-/** Cone cap bounding callback. */
+/// Cone cap bounding callback.
 static dmnsn_bounding_box
 dmnsn_cone_cap_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
 {
@@ -149,14 +148,14 @@ dmnsn_cone_cap_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
   return dmnsn_transform_bounding_box(trans, box);
 }
 
-/** Cone cap vtable. */
+/// Cone cap vtable.
 static const dmnsn_object_vtable dmnsn_cone_cap_vtable = {
   .intersection_fn = dmnsn_cone_cap_intersection_fn,
   .inside_fn = dmnsn_cone_cap_inside_fn,
   .bounding_fn = dmnsn_cone_cap_bounding_fn,
 };
 
-/** Allocate a new cone cap. */
+/// Allocate a new cone cap.
 dmnsn_object *
 dmnsn_new_cone_cap(dmnsn_pool *pool, double r)
 {
@@ -169,7 +168,7 @@ dmnsn_new_cone_cap(dmnsn_pool *pool, double r)
   return object;
 }
 
-/* Allocate a new cone object */
+// Allocate a new cone object
 dmnsn_object *
 dmnsn_new_cone(dmnsn_pool *pool, double r1, double r2, bool open)
 {
@@ -185,7 +184,7 @@ dmnsn_new_cone(dmnsn_pool *pool, double r1, double r2, bool open)
     return object;
   }
 
-  /* Implement closed cones as a union with the caps */
+  // Implement closed cones as a union with the caps
   dmnsn_object *cap1 = dmnsn_new_cone_cap(pool, r1);
   dmnsn_object *cap2 = dmnsn_new_cone_cap(pool, r2);
   cap1->intrinsic_trans = dmnsn_translation_matrix(
@@ -194,7 +193,7 @@ dmnsn_new_cone(dmnsn_pool *pool, double r1, double r2, bool open)
   cap2->intrinsic_trans = dmnsn_translation_matrix(
     dmnsn_new_vector(0.0, +1.0, 0.0)
   );
-  /* Flip the normal around for the top cap */
+  // Flip the normal around for the top cap
   cap2->intrinsic_trans.n[1][1] = -1.0;
 
   dmnsn_array *withcaps = DMNSN_PALLOC_ARRAY(pool, dmnsn_object *);
diff --git a/libdimension/csg.c b/libdimension/csg.c
index 713bd16..e31cb0e 100644
--- a/libdimension/csg.c
+++ b/libdimension/csg.c
@@ -26,16 +26,16 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
-/*
- * Unions
- */
+////////////
+// Unions //
+////////////
 
 typedef struct {
   dmnsn_object object;
   dmnsn_bvh *bvh;
 } dmnsn_csg_union;
 
-/** CSG union intersection callback. */
+/// CSG union intersection callback.
 static bool
 dmnsn_csg_union_intersection_fn(const dmnsn_object *object,
                                 dmnsn_line line,
@@ -45,7 +45,7 @@ dmnsn_csg_union_intersection_fn(const dmnsn_object *object,
   return dmnsn_bvh_intersection(csg->bvh, line, intersection, true);
 }
 
-/** CSG union inside callback. */
+/// CSG union inside callback.
 static bool
 dmnsn_csg_union_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
@@ -53,7 +53,7 @@ dmnsn_csg_union_inside_fn(const dmnsn_object *object, dmnsn_vector point)
   return dmnsn_bvh_inside(csg->bvh, point);
 }
 
-/** CSG union precomputation callback. */
+/// CSG union precomputation callback.
 static void
 dmnsn_csg_union_precompute_fn(dmnsn_object *object)
 {
@@ -65,14 +65,14 @@ dmnsn_csg_union_precompute_fn(dmnsn_object *object)
   csg->object.bounding_box = dmnsn_bvh_bounding_box(bvh);
 }
 
-/** CSG union vtable. */
+/// CSG union vtable.
 static const dmnsn_object_vtable dmnsn_csg_union_vtable = {
   .intersection_fn = dmnsn_csg_union_intersection_fn,
   .inside_fn = dmnsn_csg_union_inside_fn,
   .precompute_fn = dmnsn_csg_union_precompute_fn,
 };
 
-/** CSG union destruction callback. */
+/// CSG union destruction callback.
 static void
 dmnsn_csg_union_cleanup(void *ptr)
 {
@@ -80,7 +80,7 @@ dmnsn_csg_union_cleanup(void *ptr)
   dmnsn_delete_bvh(csg->bvh);
 }
 
-/* Bulk-load a union */
+// Bulk-load a union
 dmnsn_object *
 dmnsn_new_csg_union(dmnsn_pool *pool, dmnsn_array *objects)
 {
@@ -171,11 +171,11 @@ dmnsn_csg_intersection_fn(const dmnsn_object *csg, dmnsn_line line,
   return true;
 }
 
-/*
- * Intersections
- */
+///////////////////
+// Intersections //
+///////////////////
 
-/** CSG intersection intersection callback. */
+/// CSG intersection intersection callback.
 static bool
 dmnsn_csg_intersection_intersection_fn(const dmnsn_object *csg,
                                        dmnsn_line line,
@@ -184,7 +184,7 @@ dmnsn_csg_intersection_intersection_fn(const dmnsn_object *csg,
   return dmnsn_csg_intersection_fn(csg, line, intersection, true, true);
 }
 
-/** CSG intersection inside callback. */
+/// CSG intersection inside callback.
 static bool
 dmnsn_csg_intersection_inside_fn(const dmnsn_object *csg, dmnsn_vector point)
 {
@@ -193,7 +193,7 @@ dmnsn_csg_intersection_inside_fn(const dmnsn_object *csg, dmnsn_vector point)
   return dmnsn_object_inside(A, point) && dmnsn_object_inside(B, point);
 }
 
-/** CSG intersection precomputation callback. */
+/// CSG intersection precomputation callback.
 static void
 dmnsn_csg_intersection_precompute_fn(dmnsn_object *csg)
 {
@@ -205,7 +205,7 @@ dmnsn_csg_intersection_precompute_fn(dmnsn_object *csg)
   csg->bounding_box.max = dmnsn_vector_min(A->bounding_box.max, B->bounding_box.max);
 }
 
-/** CSG intersection vtable. */
+/// CSG intersection vtable.
 static const dmnsn_object_vtable dmnsn_csg_intersection_vtable = {
   .intersection_fn = dmnsn_csg_intersection_intersection_fn,
   .inside_fn = dmnsn_csg_intersection_inside_fn,
@@ -225,11 +225,11 @@ dmnsn_new_csg_intersection(dmnsn_pool *pool, dmnsn_object *A, dmnsn_object *B)
   return csg;
 }
 
-/*
- * Differences
- */
+/////////////////
+// Differences //
+/////////////////
 
-/** CSG difference intersection callback. */
+/// CSG difference intersection callback.
 static bool
 dmnsn_csg_difference_intersection_fn(const dmnsn_object *csg,
                                      dmnsn_line line,
@@ -238,7 +238,7 @@ dmnsn_csg_difference_intersection_fn(const dmnsn_object *csg,
   return dmnsn_csg_intersection_fn(csg, line, intersection, true, false);
 }
 
-/** CSG difference inside callback. */
+/// CSG difference inside callback.
 static bool
 dmnsn_csg_difference_inside_fn(const dmnsn_object *csg, dmnsn_vector point)
 {
@@ -247,7 +247,7 @@ dmnsn_csg_difference_inside_fn(const dmnsn_object *csg, dmnsn_vector point)
   return dmnsn_object_inside(A, point)  && !dmnsn_object_inside(B, point);
 }
 
-/** CSG difference precomputation callback. */
+/// CSG difference precomputation callback.
 static void
 dmnsn_csg_difference_precompute_fn(dmnsn_object *csg)
 {
@@ -257,7 +257,7 @@ dmnsn_csg_difference_precompute_fn(dmnsn_object *csg)
   csg->bounding_box = A->bounding_box;
 }
 
-/** CSG difference vtable. */
+/// CSG difference vtable.
 static const dmnsn_object_vtable dmnsn_csg_difference_vtable = {
   .intersection_fn = dmnsn_csg_difference_intersection_fn,
   .inside_fn = dmnsn_csg_difference_inside_fn,
@@ -277,11 +277,11 @@ dmnsn_new_csg_difference(dmnsn_pool *pool, dmnsn_object *A, dmnsn_object *B)
   return csg;
 }
 
-/*
- * Merges
- */
+////////////
+// Merges //
+////////////
 
-/** CSG merge intersection callback. */
+/// CSG merge intersection callback.
 static bool
 dmnsn_csg_merge_intersection_fn(const dmnsn_object *csg,
                                 dmnsn_line line,
@@ -290,7 +290,7 @@ dmnsn_csg_merge_intersection_fn(const dmnsn_object *csg,
   return dmnsn_csg_intersection_fn(csg, line, intersection, false, false);
 }
 
-/** CSG merge inside callback. */
+/// CSG merge inside callback.
 static bool
 dmnsn_csg_merge_inside_fn(const dmnsn_object *csg, dmnsn_vector point)
 {
@@ -299,7 +299,7 @@ dmnsn_csg_merge_inside_fn(const dmnsn_object *csg, dmnsn_vector point)
   return dmnsn_object_inside(A, point) || dmnsn_object_inside(B, point);
 }
 
-/** CSG merge precomputation callback. */
+/// CSG merge precomputation callback.
 static void
 dmnsn_csg_merge_precompute_fn(dmnsn_object *csg)
 {
@@ -311,7 +311,7 @@ dmnsn_csg_merge_precompute_fn(dmnsn_object *csg)
   csg->bounding_box.max = dmnsn_vector_max(A->bounding_box.max, B->bounding_box.max);
 }
 
-/** CSG merge vtable. */
+/// CSG merge vtable.
 static const dmnsn_object_vtable dmnsn_csg_merge_vtable = {
   .intersection_fn = dmnsn_csg_merge_intersection_fn,
   .inside_fn = dmnsn_csg_merge_inside_fn,
diff --git a/libdimension/cube.c b/libdimension/cube.c
index 4c1b955..c455467 100644
--- a/libdimension/cube.c
+++ b/libdimension/cube.c
@@ -26,12 +26,12 @@
 #include "dimension.h"
 #include <math.h>
 
-/** Intersection callback for a cube. */
+/// Intersection callback for a cube.
 static bool
 dmnsn_cube_intersection_fn(const dmnsn_object *cube, dmnsn_line line,
                            dmnsn_intersection *intersection)
 {
-  /* Clip the given line against the X, Y, and Z slabs */
+  // Clip the given line against the X, Y, and Z slabs
 
   dmnsn_vector nmin, nmax;
   double tmin, tmax;
@@ -120,7 +120,7 @@ dmnsn_cube_intersection_fn(const dmnsn_object *cube, dmnsn_line line,
   }
 }
 
-/** Inside callback for a cube. */
+/// Inside callback for a cube.
 static bool
 dmnsn_cube_inside_fn(const dmnsn_object *cube, dmnsn_vector point)
 {
@@ -129,7 +129,7 @@ dmnsn_cube_inside_fn(const dmnsn_object *cube, dmnsn_vector point)
       && point.z > -1.0 && point.z < 1.0;
 }
 
-/** Boundary callback for a cube. */
+/// Boundary callback for a cube.
 static dmnsn_bounding_box
 dmnsn_cube_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
 {
@@ -137,14 +137,14 @@ dmnsn_cube_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
   return dmnsn_transform_bounding_box(trans, box);
 }
 
-/** Cube vtable. */
+/// Cube vtable.
 static const dmnsn_object_vtable dmnsn_cube_vtable = {
   .intersection_fn = dmnsn_cube_intersection_fn,
   .inside_fn = dmnsn_cube_inside_fn,
   .bounding_fn = dmnsn_cube_bounding_fn,
 };
 
-/* Allocate a new cube object */
+// Allocate a new cube object
 dmnsn_object *
 dmnsn_new_cube(dmnsn_pool *pool)
 {
diff --git a/libdimension/dictionary.c b/libdimension/dictionary.c
index 4001d2f..84ebedf 100644
--- a/libdimension/dictionary.c
+++ b/libdimension/dictionary.c
@@ -26,10 +26,10 @@
 #include "dimension.h"
 
 struct dmnsn_dictionary {
-  size_t obj_size;       /**< The size of the objects in the trie. */
-  char *prefix;          /**< The local string prefix of the current node. */
-  void *value;           /**< The node's stored object, if it's a leaf. */
-  dmnsn_array *children; /**< The node's children. */
+  size_t obj_size;       ///< The size of the objects in the trie.
+  char *prefix;          ///< The local string prefix of the current node.
+  void *value;           ///< The node's stored object, if it's a leaf.
+  dmnsn_array *children; ///< The node's children.
 };
 
 dmnsn_dictionary *
@@ -73,10 +73,8 @@ dmnsn_dictionary_get(const dmnsn_dictionary *dict, const char *key, void *obj)
 void *
 dmnsn_dictionary_at(const dmnsn_dictionary *dict, const char *key)
 {
-  /*
-   * PATRICIA trie search: O(k), where k is the length of the longest string
-   * in the trie.
-   */
+  // PATRICIA trie search: O(k), where k is the length of the longest string in
+  // the trie.
 
   size_t len = strlen(dict->prefix);
   if (strncmp(key, dict->prefix, len) != 0)
@@ -110,16 +108,14 @@ void
 dmnsn_dictionary_insert(dmnsn_dictionary *dict, const char *key,
                         const void *obj)
 {
-  /*
-   * PATRICIA trie insertion: O(k), where k is the length of the longest string
-   * in the trie.
-   */
+  // PATRICIA trie insertion: O(k), where k is the length of the longest string
+  // in the trie.
 
   while (true) {
     if (dict->prefix[0] == '\0' && !dict->value
         && dmnsn_array_size(dict->children) == 0)
     {
-      /* Replace an empty tree with a single-element tree */
+      // Replace an empty tree with a single-element tree
       dict->prefix = dmnsn_realloc(dict->prefix, strlen(key) + 1);
       strcpy(dict->prefix, key);
 
@@ -135,14 +131,14 @@ dmnsn_dictionary_insert(dmnsn_dictionary *dict, const char *key,
     }
 
     if (*key == '\0' && *prefix == '\0') {
-      /* Complete match */
+      // Complete match
       if (!dict->value) {
         dict->value = dmnsn_malloc(dict->obj_size);
       }
       memcpy(dict->value, obj, dict->obj_size);
       break;
     } else if (*prefix == '\0') {
-      /* Partial match; key starts with prefix */
+      // Partial match; key starts with prefix
       dmnsn_dictionary **first = dmnsn_array_first(dict->children), **subtrie;
       ptrdiff_t size = dmnsn_array_size(dict->children);
       for (subtrie = first; subtrie - first < size; ++subtrie) {
@@ -153,13 +149,13 @@ dmnsn_dictionary_insert(dmnsn_dictionary *dict, const char *key,
       }
 
       if (subtrie - first == size) {
-        /* No submatch found, add a new child */
+        // No submatch found, add a new child
         dmnsn_dictionary *child = dmnsn_new_dictionary(dict->obj_size);
         dmnsn_array_push(dict->children, &child);
         dict = child;
       }
     } else {
-      /* Split the tree */
+      // Split the tree
       dmnsn_dictionary *copy = dmnsn_new_dictionary(dict->obj_size);
       copy->prefix = dmnsn_realloc(copy->prefix, strlen(prefix) + 1);
       strcpy(copy->prefix, prefix);
@@ -183,13 +179,11 @@ dmnsn_dictionary_insert(dmnsn_dictionary *dict, const char *key,
 bool
 dmnsn_dictionary_remove(dmnsn_dictionary *dict, const char *key)
 {
-  /*
-   * PATRICIA trie removal: O(k), where k is the length of the longest string
-   * in the trie.
-   *
-   * This implementation doesn't actually collapse the tree back upwards if a
-   * node is left with only one child, to reduce complexity.
-   */
+  // PATRICIA trie removal: O(k), where k is the length of the longest string
+  // in the trie.
+
+  // This implementation doesn't actually collapse the tree back upwards if a
+  // node is left with only one child, to reduce complexity.
 
   size_t len = strlen(dict->prefix);
   if (strncmp(key, dict->prefix, len) != 0)
diff --git a/libdimension/dimension-internal.h b/libdimension/dimension-internal.h
index 197447f..53fa24c 100644
--- a/libdimension/dimension-internal.h
+++ b/libdimension/dimension-internal.h
@@ -37,4 +37,4 @@
 #include "prtree.h"
 #include "rgba.h"
 
-#endif /* DIMENSION_INTERNAL_H */
+#endif // DIMENSION_INTERNAL_H
diff --git a/libdimension/error.c b/libdimension/error.c
index 1facc72..cdc9e31 100644
--- a/libdimension/error.c
+++ b/libdimension/error.c
@@ -30,7 +30,7 @@
 #include <stdlib.h>
 #include <errno.h>
 
-/** Report internal errors in this file. */
+/// Report internal errors in this file.
 #define DMNSN_LOCAL_ERROR(str)                          \
   do {                                                  \
     fprintf(stderr, "Dimension ERROR: %s, %s:%u: %s\n", \
@@ -38,7 +38,7 @@
     abort();                                            \
   } while (0)
 
-/** dmnsn_local_lock_mutex implementation. */
+/// dmnsn_local_lock_mutex implementation.
 static void
 dmnsn_local_lock_mutex_impl(pthread_mutex_t *mutex)
 {
@@ -47,7 +47,7 @@ dmnsn_local_lock_mutex_impl(pthread_mutex_t *mutex)
   }
 }
 
-/** dmnsn_local_unlock_mutex implementation. */
+/// dmnsn_local_unlock_mutex implementation.
 static void
 dmnsn_local_unlock_mutex_impl(pthread_mutex_t *mutex)
 {
@@ -56,32 +56,32 @@ dmnsn_local_unlock_mutex_impl(pthread_mutex_t *mutex)
   }
 }
 
-/** Lock a mutex, bailing out without dmnsn_error() on error. */
+/// Lock a mutex, bailing out without dmnsn_error() on error.
 #define dmnsn_local_lock_mutex(mutex)           \
   dmnsn_local_lock_mutex_impl((mutex)); {
-/** Unlock a mutex, bailing out without dmnsn_error() on error. */
+/// Unlock a mutex, bailing out without dmnsn_error() on error.
 #define dmnsn_local_unlock_mutex(mutex)         \
   dmnsn_local_unlock_mutex_impl((mutex)); }
 
-/** The default fatal error handler. */
+/// The default fatal error handler.
 static void dmnsn_default_fatal_error_fn(void);
 
-/** The current fatal error handler. */
+/// The current fatal error handler.
 static dmnsn_fatal_error_fn *dmnsn_fatal = dmnsn_default_fatal_error_fn;
-/** Mutex which protects \c dmnsn_fatal. */
+/// Mutex which protects \c dmnsn_fatal.
 static pthread_mutex_t dmnsn_fatal_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-/** The current resilience. */
+/// The current resilience.
 static bool dmnsn_always_die = false;
-/** Mutex which protects \c dmnsn_always_die. */
+/// Mutex which protects \c dmnsn_always_die.
 static pthread_mutex_t dmnsn_always_die_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-/* Called by dmnsn_error macro (don't call directly) */
+// Called by dmnsn_error macro (don't call directly)
 void
 dmnsn_report_error(bool die, const char *func, const char *file,
                    unsigned int line, const char *str)
 {
-  /* Save the value of errno */
+  // Save the value of errno
   int err = errno;
 
   bool always_die;
@@ -89,11 +89,11 @@ dmnsn_report_error(bool die, const char *func, const char *file,
     always_die = dmnsn_always_die;
   dmnsn_local_unlock_mutex(&dmnsn_always_die_mutex);
 
-  /* Print the diagnostic string */
+  // Print the diagnostic string
   fprintf(stderr, "Dimension %s: %s, %s:%u: %s\n",
           die ? "ERROR" : "WARNING", func, file, line, str);
 
-  /* Print the value of errno */
+  // Print the value of errno
   if (err != 0) {
     fprintf(stderr, "Last error: %d", err);
 #if DMNSN_STRERROR_R
@@ -109,17 +109,17 @@ dmnsn_report_error(bool die, const char *func, const char *file,
     fprintf(stderr, "\n");
   }
 
-  /* Print a stack trace to standard error */
+  // Print a stack trace to standard error
   dmnsn_backtrace(stderr);
 
-  /* Call the fatal error handler if needed */
+  // Call the fatal error handler if needed
   if (die || always_die) {
     static __thread bool thread_exiting = false;
 
     if (thread_exiting) {
       if (die) {
-        /* Prevent infinite recursion if the fatal error function itself calls
-           dmnsn_error() (not dmnsn_warning()) */
+        // Prevent infinite recursion if the fatal error function itself calls
+        // dmnsn_error() (not dmnsn_warning()) */
         DMNSN_LOCAL_ERROR("Error raised while in error handler, aborting.");
       }
     } else {
diff --git a/libdimension/future-internal.h b/libdimension/future-internal.h
index 5fcd553..7ca318a 100644
--- a/libdimension/future-internal.h
+++ b/libdimension/future-internal.h
@@ -25,47 +25,47 @@
 
 #include <pthread.h>
 
-/** Allocate a new future object. */
+/// Allocate a new future object.
 DMNSN_INTERNAL dmnsn_future *dmnsn_new_future(void);
 
-/** Set the total number of loop iterations. */
+/// Set the total number of loop iterations.
 DMNSN_INTERNAL void dmnsn_future_set_total(dmnsn_future *future, size_t total);
-/** Increment the progress of a background task. */
+/// Increment the progress of a background task.
 DMNSN_INTERNAL void dmnsn_future_increment(dmnsn_future *future);
-/** Instantly complete the background teask. */
+/// Instantly complete the background teask.
 DMNSN_INTERNAL void dmnsn_future_finish(dmnsn_future *future);
-/** Set the number of worker threads. */
+/// Set the number of worker threads.
 DMNSN_INTERNAL void dmnsn_future_set_nthreads(dmnsn_future *future,
                                               unsigned int nthreads);
-/** Notify completion of a worker thread. */
+/// Notify completion of a worker thread.
 DMNSN_INTERNAL void dmnsn_future_finish_thread(dmnsn_future *future);
 
 struct dmnsn_future {
-  size_t progress; /**< Completed loop iterations. */
-  size_t total;    /**< Total expected loop iterations. */
+  size_t progress; ///< Completed loop iterations.
+  size_t total;    ///< Total expected loop iterations.
 
-  /** The worker thread. */
+  /// The worker thread.
   pthread_t thread;
 
-  /** Mutex to guard progress and total. */
+  /// Mutex to guard progress and total.
   pthread_mutex_t mutex;
 
-  /** Condition variable for waiting for a particular amount of progress. */
+  /// Condition variable for waiting for a particular amount of progress.
   pthread_cond_t cond;
 
-  /** Minimum waited-on value. */
+  /// Minimum waited-on value.
   double min_wait;
 
-  /** Number of threads working on the future's background task. */
+  /// Number of threads working on the future's background task.
   unsigned int nthreads;
-  /** Number of threads not yet paused. */
+  /// Number of threads not yet paused.
   unsigned int nrunning;
-  /** Count of threads holding the future paused. */
+  /// Count of threads holding the future paused.
   unsigned int npaused;
-  /** Condition variable for waiting for nrunning == 0. */
+  /// Condition variable for waiting for nrunning == 0.
   pthread_cond_t none_running_cond;
-  /** Condition variable for waiting for nrunning == nthreads. */
+  /// Condition variable for waiting for nrunning == nthreads.
   pthread_cond_t all_running_cond;
-  /** Condition variable for waiting for npaused == 0. */
+  /// Condition variable for waiting for npaused == 0.
   pthread_cond_t resume_cond;
 };
diff --git a/libdimension/future.c b/libdimension/future.c
index 0b16234..ef3f5e2 100644
--- a/libdimension/future.c
+++ b/libdimension/future.c
@@ -33,7 +33,7 @@
  */
 #define MUTATE(future) ((dmnsn_future *)(future))
 
-/* Allocate a new dmnsn_future* */
+// Allocate a new dmnsn_future*
 dmnsn_future *
 dmnsn_new_future(void)
 {
@@ -68,7 +68,7 @@ dmnsn_delete_future(dmnsn_future *future)
   }
 }
 
-/* Join the worker thread and delete `future'. */
+// Join the worker thread and delete `future'.
 int
 dmnsn_future_join(dmnsn_future *future)
 {
@@ -78,21 +78,21 @@ dmnsn_future_join(dmnsn_future *future)
   if (future) {
     dmnsn_assert(future->npaused == 0, "Attempt to join future while paused");
 
-    /* Get the thread's return value */
+    // Get the thread's return value
     dmnsn_join_thread(future->thread, &ptr);
     if (ptr && ptr != PTHREAD_CANCELED) {
       retval = *(int *)ptr;
       dmnsn_free(ptr);
     }
 
-    /* Free the future object */
+    // Free the future object
     dmnsn_delete_future(future);
   }
 
   return retval;
 }
 
-/* Cancel a background thread */
+// Cancel a background thread
 void
 dmnsn_future_cancel(dmnsn_future *future)
 {
@@ -110,7 +110,7 @@ dmnsn_future_progress_unlocked(const dmnsn_future *future)
   return (double)future->progress/future->total;
 }
 
-/* Get the current progress of the worker thread, in [0.0, 1.0] */
+// Get the current progress of the worker thread, in [0.0, 1.0]
 double
 dmnsn_future_progress(const dmnsn_future *future)
 {
@@ -124,7 +124,7 @@ dmnsn_future_progress(const dmnsn_future *future)
   return progress;
 }
 
-/* Find out whether the task is complete. */
+// Find out whether the task is complete.
 bool
 dmnsn_future_is_done(const dmnsn_future *future)
 {
@@ -138,7 +138,7 @@ dmnsn_future_is_done(const dmnsn_future *future)
   return result;
 }
 
-/* Wait until dmnsn_future_progress(future) >= progress */
+// Wait until dmnsn_future_progress(future) >= progress
 void
 dmnsn_future_wait(const dmnsn_future *future, double progress)
 {
@@ -146,7 +146,7 @@ dmnsn_future_wait(const dmnsn_future *future, double progress)
 
   dmnsn_lock_mutex(&mfuture->mutex);
     while (dmnsn_future_progress_unlocked(mfuture) < progress) {
-      /* Set the minimum waited-on value */
+      // Set the minimum waited-on value
       if (progress < mfuture->min_wait) {
         mfuture->min_wait = progress;
       }
@@ -156,7 +156,7 @@ dmnsn_future_wait(const dmnsn_future *future, double progress)
   dmnsn_unlock_mutex(&mfuture->mutex);
 }
 
-/* Pause all threads working on a future. */
+// Pause all threads working on a future.
 void
 dmnsn_future_pause(dmnsn_future *future)
 {
@@ -172,7 +172,7 @@ dmnsn_future_pause(dmnsn_future *future)
   dmnsn_unlock_mutex(&future->mutex);
 }
 
-/* Resume all threads working on a future. */
+// Resume all threads working on a future.
 void
 dmnsn_future_resume(dmnsn_future *future)
 {
@@ -185,7 +185,7 @@ dmnsn_future_resume(dmnsn_future *future)
   dmnsn_unlock_mutex(&future->mutex);
 }
 
-/* Set the total number of loop iterations */
+// Set the total number of loop iterations
 void
 dmnsn_future_set_total(dmnsn_future *future, size_t total)
 {
@@ -202,13 +202,13 @@ dmnsn_future_increment_cleanup(void *ptr)
   dmnsn_unlock_mutex_impl(&future->mutex);
 }
 
-/* Increment the number of completed loop iterations */
+// Increment the number of completed loop iterations
 void
 dmnsn_future_increment(dmnsn_future *future)
 {
-  /* Allow a thread to be canceled whenever it increments a future object --
-     this is close to PTHREAD_CANCEL_ASYNCHRONOUS but allows consistent state
-     on cancellation */
+  // Allow a thread to be canceled whenever it increments a future object --
+  // this is close to PTHREAD_CANCEL_ASYNCHRONOUS but allows consistent state
+  // on cancellation
   pthread_testcancel();
 
   dmnsn_lock_mutex(&future->mutex);
@@ -239,7 +239,7 @@ dmnsn_future_increment(dmnsn_future *future)
   dmnsn_unlock_mutex(&future->mutex);
 }
 
-/* Immediately set to 100% completion */
+// Immediately set to 100% completion
 void
 dmnsn_future_finish(dmnsn_future *future)
 {
@@ -252,7 +252,7 @@ dmnsn_future_finish(dmnsn_future *future)
   dmnsn_unlock_mutex(&future->mutex);
 }
 
-/* Set the number of threads */
+// Set the number of threads
 void
 dmnsn_future_set_nthreads(dmnsn_future *future, unsigned int nthreads)
 {
@@ -263,7 +263,7 @@ dmnsn_future_set_nthreads(dmnsn_future *future, unsigned int nthreads)
   dmnsn_unlock_mutex(&future->mutex);
 }
 
-/* Notify completion of a worker thread */
+// Notify completion of a worker thread
 void
 dmnsn_future_finish_thread(dmnsn_future *future)
 {
diff --git a/libdimension/geometry.c b/libdimension/geometry.c
index c6a4da2..1ec2801 100644
--- a/libdimension/geometry.c
+++ b/libdimension/geometry.c
@@ -26,7 +26,7 @@
 #include "dimension-internal.h"
 #include <math.h>
 
-/* Identity matrix */
+// Identity matrix
 dmnsn_matrix
 dmnsn_identity_matrix(void)
 {
@@ -35,7 +35,7 @@ dmnsn_identity_matrix(void)
                           0.0, 0.0, 1.0, 0.0);
 }
 
-/* Scaling matrix */
+// Scaling matrix
 dmnsn_matrix
 dmnsn_scale_matrix(dmnsn_vector s)
 {
@@ -44,7 +44,7 @@ dmnsn_scale_matrix(dmnsn_vector s)
                           0.0, 0.0, s.z, 0.0);
 }
 
-/* Translation matrix */
+// Translation matrix
 dmnsn_matrix
 dmnsn_translation_matrix(dmnsn_vector d)
 {
@@ -53,11 +53,11 @@ dmnsn_translation_matrix(dmnsn_vector d)
                           0.0, 0.0, 1.0, d.z);
 }
 
-/* Left-handed rotation matrix; theta/|theta| = axis, |theta| = angle */
+// Left-handed rotation matrix; theta/|theta| = axis, |theta| = angle
 dmnsn_matrix
 dmnsn_rotation_matrix(dmnsn_vector theta)
 {
-  /* Two trig calls, 25 multiplications, 13 additions */
+  // Two trig calls, 25 multiplications, 13 additions
 
   double angle = dmnsn_vector_norm(theta);
   if (fabs(angle) < dmnsn_epsilon) {
@@ -65,7 +65,7 @@ dmnsn_rotation_matrix(dmnsn_vector theta)
   }
   dmnsn_vector axis = dmnsn_vector_div(theta, angle);
 
-  /* Shorthand to make dmnsn_new_matrix() call legible */
+  // Shorthand to make dmnsn_new_matrix() call legible
 
   double s = sin(angle);
   double t = 1.0 - cos(angle);
@@ -81,7 +81,7 @@ dmnsn_rotation_matrix(dmnsn_vector theta)
   );
 }
 
-/* Find the angle between two vectors with respect to an axis */
+// Find the angle between two vectors with respect to an axis
 static double
 dmnsn_axis_angle(dmnsn_vector from, dmnsn_vector to, dmnsn_vector axis)
 {
@@ -106,7 +106,7 @@ dmnsn_axis_angle(dmnsn_vector from, dmnsn_vector to, dmnsn_vector axis)
   }
 }
 
-/* Alignment matrix */
+// Alignment matrix
 dmnsn_matrix
 dmnsn_alignment_matrix(dmnsn_vector from, dmnsn_vector to,
                        dmnsn_vector axis1, dmnsn_vector axis2)
@@ -122,67 +122,63 @@ dmnsn_alignment_matrix(dmnsn_vector from, dmnsn_vector to,
   return dmnsn_matrix_mul(align2, align1);
 }
 
-/* Matrix inversion helper functions */
+// Matrix inversion helper functions
 
-/** A 2x2 matrix for inversion by partitioning. */
+/// A 2x2 matrix for inversion by partitioning.
 typedef struct { double n[2][2]; } dmnsn_matrix2;
 
-/** Construct a 2x2 matrix. */
+/// Construct a 2x2 matrix.
 static dmnsn_matrix2 dmnsn_new_matrix2(double a1, double a2,
                                        double b1, double b2);
-/** Invert a 2x2 matrix. */
+/// Invert a 2x2 matrix.
 static dmnsn_matrix2 dmnsn_matrix2_inverse(dmnsn_matrix2 A);
-/** Negate a 2x2 matrix. */
+/// Negate a 2x2 matrix.
 static dmnsn_matrix2 dmnsn_matrix2_negate(dmnsn_matrix2 A);
-/** Subtract two 2x2 matricies. */
+/// Subtract two 2x2 matricies.
 static dmnsn_matrix2 dmnsn_matrix2_sub(dmnsn_matrix2 lhs, dmnsn_matrix2 rhs);
-/** Add two 2x2 matricies. */
+/// Add two 2x2 matricies.
 static dmnsn_matrix2 dmnsn_matrix2_mul(dmnsn_matrix2 lhs, dmnsn_matrix2 rhs);
 
-/** Invert a matrix with the slower cofactor algorithm, if partitioning
-    failed.  */
+/// Invert a matrix with the slower cofactor algorithm, if partitioning failed.
 static dmnsn_matrix dmnsn_matrix_inverse_generic(dmnsn_matrix A);
-/** Get the [\p row, \p col] cofactor of A. */
+/// Get the [\p row, \p col] cofactor of A.
 static double dmnsn_matrix_cofactor(dmnsn_matrix A,
                                     unsigned int row, unsigned int col);
 
-/* Invert a matrix, by partitioning */
+// Invert a matrix, by partitioning
 dmnsn_matrix
 dmnsn_matrix_inverse(dmnsn_matrix A)
 {
-  /*
-   * Use partitioning to invert a matrix:
-   *
-   *     [ P Q ] -1
-   *     [ R S ]
-   *
-   *   = [ PP QQ ]
-   *     [ RR SS ],
-   *
-   * with PP = inv(P) - inv(P)*Q*RR,
-   *      QQ = -inv(P)*Q*SS,
-   *      RR = -SS*R*inv(P), and
-   *      SS = inv(S - R*inv(P)*Q).
-   */
-
-  /* The algorithm uses 2 inversions, 6 multiplications, and 2 subtractions,
-     giving 52 multiplications, 34 additions, and 8 divisions. */
+  // Use partitioning to invert a matrix:
+  //
+  //     [ P Q ] -1
+  //     [ R S ]
+  //
+  //   = [ PP QQ ]
+  //     [ RR SS ],
+  //
+  // with PP = inv(P) - inv(P)*Q*RR,
+  //      QQ = -inv(P)*Q*SS,
+  //      RR = -SS*R*inv(P), and
+  //      SS = inv(S - R*inv(P)*Q).
+
+  // The algorithm uses 2 inversions, 6 multiplications, and 2 subtractions,
+  // giving 52 multiplications, 34 additions, and 8 divisions.
 
   dmnsn_matrix2 P, Q, R, S, Pi, RPi, PiQ, RPiQ, PP, QQ, RR, SS;
   double Pdet = A.n[0][0]*A.n[1][1] - A.n[0][1]*A.n[1][0];
 
   if (dmnsn_unlikely(fabs(Pdet) < dmnsn_epsilon)) {
-    /* If P is close to singular, try a more generic algorithm; this is very
-     * unlikely, but not impossible, eg.
-     *   [ 1 1 0 0 ]
-     *   [ 1 1 1 0 ]
-     *   [ 0 1 1 0 ]
-     *   [ 0 0 0 1 ]
-     */
+    // If P is close to singular, try a more generic algorithm; this is very
+    // unlikely, but not impossible, eg.
+    //   [ 1 1 0 0 ]
+    //   [ 1 1 1 0 ]
+    //   [ 0 1 1 0 ]
+    //   [ 0 0 0 1 ]
     return dmnsn_matrix_inverse_generic(A);
   }
 
-  /* Partition the matrix */
+  // Partition the matrix
   P = dmnsn_new_matrix2(A.n[0][0], A.n[0][1],
                         A.n[1][0], A.n[1][1]);
   Q = dmnsn_new_matrix2(A.n[0][2], A.n[0][3],
@@ -192,28 +188,28 @@ dmnsn_matrix_inverse(dmnsn_matrix A)
   S = dmnsn_new_matrix2(A.n[2][2], A.n[2][3],
                         0.0,       1.0);
 
-  /* Do this inversion ourselves, since we already have the determinant */
+  // Do this inversion ourselves, since we already have the determinant
   Pi = dmnsn_new_matrix2( P.n[1][1]/Pdet, -P.n[0][1]/Pdet,
                          -P.n[1][0]/Pdet,  P.n[0][0]/Pdet);
 
-  /* Calculate R*inv(P), inv(P)*Q, and R*inv(P)*Q */
+  // Calculate R*inv(P), inv(P)*Q, and R*inv(P)*Q
   RPi  = dmnsn_matrix2_mul(R, Pi);
   PiQ  = dmnsn_matrix2_mul(Pi, Q);
   RPiQ = dmnsn_matrix2_mul(R, PiQ);
 
-  /* Calculate the partitioned inverse */
+  // Calculate the partitioned inverse
   SS = dmnsn_matrix2_inverse(dmnsn_matrix2_sub(S, RPiQ));
   RR = dmnsn_matrix2_negate(dmnsn_matrix2_mul(SS, RPi));
   QQ = dmnsn_matrix2_negate(dmnsn_matrix2_mul(PiQ, SS));
   PP = dmnsn_matrix2_sub(Pi, dmnsn_matrix2_mul(PiQ, RR));
 
-  /* Reconstruct the matrix */
+  // Reconstruct the matrix
   return dmnsn_new_matrix(PP.n[0][0], PP.n[0][1], QQ.n[0][0], QQ.n[0][1],
                           PP.n[1][0], PP.n[1][1], QQ.n[1][0], QQ.n[1][1],
                           RR.n[0][0], RR.n[0][1], SS.n[0][0], SS.n[0][1]);
 }
 
-/* For nice shorthand */
+// For nice shorthand
 static dmnsn_matrix2
 dmnsn_new_matrix2(double a1, double a2, double b1, double b2)
 {
@@ -222,17 +218,17 @@ dmnsn_new_matrix2(double a1, double a2, double b1, double b2)
   return m;
 }
 
-/* Invert a 2x2 matrix */
+// Invert a 2x2 matrix
 static dmnsn_matrix2
 dmnsn_matrix2_inverse(dmnsn_matrix2 A)
 {
-  /* 4 divisions, 2 multiplications, 1 addition */
+  // 4 divisions, 2 multiplications, 1 addition
   double det = A.n[0][0]*A.n[1][1] - A.n[0][1]*A.n[1][0];
   return dmnsn_new_matrix2( A.n[1][1]/det, -A.n[0][1]/det,
                            -A.n[1][0]/det,  A.n[0][0]/det);
 }
 
-/* Also basically a shorthand */
+// Also basically a shorthand
 static dmnsn_matrix2
 dmnsn_matrix2_negate(dmnsn_matrix2 A)
 {
@@ -240,22 +236,22 @@ dmnsn_matrix2_negate(dmnsn_matrix2 A)
                            -A.n[1][0], -A.n[1][1]);
 }
 
-/* 2x2 matrix subtraction */
+// 2x2 matrix subtraction
 static dmnsn_matrix2
 dmnsn_matrix2_sub(dmnsn_matrix2 lhs, dmnsn_matrix2 rhs)
 {
-  /* 4 additions */
+  // 4 additions
   return dmnsn_new_matrix2(
     lhs.n[0][0] - rhs.n[0][0], lhs.n[0][1] - rhs.n[0][1],
     lhs.n[1][0] - rhs.n[1][0], lhs.n[1][1] - rhs.n[1][1]
   );
 }
 
-/* 2x2 matrix multiplication */
+// 2x2 matrix multiplication
 static dmnsn_matrix2
 dmnsn_matrix2_mul(dmnsn_matrix2 lhs, dmnsn_matrix2 rhs)
 {
-  /* 8 multiplications, 4 additions */
+  // 8 multiplications, 4 additions
   return dmnsn_new_matrix2(
     lhs.n[0][0]*rhs.n[0][0] + lhs.n[0][1]*rhs.n[1][0],
       lhs.n[0][0]*rhs.n[0][1] + lhs.n[0][1]*rhs.n[1][1],
@@ -264,33 +260,31 @@ dmnsn_matrix2_mul(dmnsn_matrix2 lhs, dmnsn_matrix2 rhs)
   );
 }
 
-/* Invert a matrix, if partitioning failed (|P| == 0) */
+// Invert a matrix, if partitioning failed (|P| == 0)
 static dmnsn_matrix
 dmnsn_matrix_inverse_generic(dmnsn_matrix A)
 {
-  /*
-   * For A = [ A'      b ], A^-1 = [ A'^-1   -(A'^-1)*b ].
-   *         [ 0 ... 0 1 ]         [ 0 ... 0      1     ]
-   *
-   * Invert A' by calculating its adjucate.
-   */
+  // For A = [ A'      b ]  A^-1 = [ A'^-1   -(A'^-1)*b ]
+  //         [ 0 ... 0 1 ],        [ 0 ... 0      1     ].
+  //
+  // Invert A' by calculating its adjucate.
   dmnsn_matrix inv;
   double det = 0.0, C;
 
-  /* Perform a Laplace expansion along the first row to give us the adjugate's
-     first column and the determinant */
+  // Perform a Laplace expansion along the first row to give us the adjugate's
+  // first column and the determinant
   for (size_t j = 0; j < 3; ++j) {
     C = dmnsn_matrix_cofactor(A, 0, j);
     det += A.n[0][j]*C;
     inv.n[j][0] = C;
   }
 
-  /* Divide the first column by the determinant */
+  // Divide the first column by the determinant
   for (size_t j = 0; j < 3; ++j) {
     inv.n[j][0] /= det;
   }
 
-  /* Find the rest of A' */
+  // Find the rest of A'
   for (size_t j = 0; j < 3; ++j) {
     for (size_t i = 1; i < 3; ++i) {
       inv.n[j][i] = dmnsn_matrix_cofactor(A, i, j)/det;
@@ -298,7 +292,7 @@ dmnsn_matrix_inverse_generic(dmnsn_matrix A)
     inv.n[j][3] = 0.0;
   }
 
-  /* Find the translational component of the inverse */
+  // Find the translational component of the inverse
   for (size_t i = 0; i < 3; ++i) {
     for (size_t j = 0; j < 3; ++j) {
       inv.n[i][3] -= inv.n[i][j]*A.n[j][3];
@@ -308,13 +302,13 @@ dmnsn_matrix_inverse_generic(dmnsn_matrix A)
   return inv;
 }
 
-/* Gives the cofactor at row, col; the determinant of the matrix formed from the
-   upper-left 3x3 corner of A by ignoring row `row' and column `col',
-   times (-1)^(row + col) */
+// Gives the cofactor at row, col; the determinant of the matrix formed from the
+// upper-left 3x3 corner of A by ignoring row `row' and column `col',
+// times (-1)^(row + col)
 static double
 dmnsn_matrix_cofactor(dmnsn_matrix A, unsigned int row, unsigned int col)
 {
-  /* 2 multiplications, 1 addition */
+  // 2 multiplications, 1 addition
   double n[4];
   size_t k = 0;
   for (size_t i = 0; i < 3; ++i) {
@@ -334,48 +328,36 @@ dmnsn_matrix_cofactor(dmnsn_matrix A, unsigned int row, unsigned int col)
   }
 }
 
-/* 4x4 matrix multiplication */
+// 4x4 matrix multiplication
 dmnsn_matrix
 dmnsn_matrix_mul(dmnsn_matrix lhs, dmnsn_matrix rhs)
 {
-  /* 36 multiplications, 27 additions */
+  // 36 multiplications, 27 additions
   dmnsn_matrix r;
 
-  r.n[0][0] = lhs.n[0][0]*rhs.n[0][0] + lhs.n[0][1]*rhs.n[1][0]
-    + lhs.n[0][2]*rhs.n[2][0];
-  r.n[0][1] = lhs.n[0][0]*rhs.n[0][1] + lhs.n[0][1]*rhs.n[1][1]
-    + lhs.n[0][2]*rhs.n[2][1];
-  r.n[0][2] = lhs.n[0][0]*rhs.n[0][2] + lhs.n[0][1]*rhs.n[1][2]
-    + lhs.n[0][2]*rhs.n[2][2];
-  r.n[0][3] = lhs.n[0][0]*rhs.n[0][3] + lhs.n[0][1]*rhs.n[1][3]
-    + lhs.n[0][2]*rhs.n[2][3] + lhs.n[0][3];
-
-  r.n[1][0] = lhs.n[1][0]*rhs.n[0][0] + lhs.n[1][1]*rhs.n[1][0]
-    + lhs.n[1][2]*rhs.n[2][0];
-  r.n[1][1] = lhs.n[1][0]*rhs.n[0][1] + lhs.n[1][1]*rhs.n[1][1]
-    + lhs.n[1][2]*rhs.n[2][1];
-  r.n[1][2] = lhs.n[1][0]*rhs.n[0][2] + lhs.n[1][1]*rhs.n[1][2]
-    + lhs.n[1][2]*rhs.n[2][2];
-  r.n[1][3] = lhs.n[1][0]*rhs.n[0][3] + lhs.n[1][1]*rhs.n[1][3]
-    + lhs.n[1][2]*rhs.n[2][3] + lhs.n[1][3];
-
-  r.n[2][0] = lhs.n[2][0]*rhs.n[0][0] + lhs.n[2][1]*rhs.n[1][0]
-    + lhs.n[2][2]*rhs.n[2][0];
-  r.n[2][1] = lhs.n[2][0]*rhs.n[0][1] + lhs.n[2][1]*rhs.n[1][1]
-    + lhs.n[2][2]*rhs.n[2][1];
-  r.n[2][2] = lhs.n[2][0]*rhs.n[0][2] + lhs.n[2][1]*rhs.n[1][2]
-    + lhs.n[2][2]*rhs.n[2][2];
-  r.n[2][3] = lhs.n[2][0]*rhs.n[0][3] + lhs.n[2][1]*rhs.n[1][3]
-    + lhs.n[2][2]*rhs.n[2][3] + lhs.n[2][3];
+  r.n[0][0] = lhs.n[0][0]*rhs.n[0][0] + lhs.n[0][1]*rhs.n[1][0] + lhs.n[0][2]*rhs.n[2][0];
+  r.n[0][1] = lhs.n[0][0]*rhs.n[0][1] + lhs.n[0][1]*rhs.n[1][1] + lhs.n[0][2]*rhs.n[2][1];
+  r.n[0][2] = lhs.n[0][0]*rhs.n[0][2] + lhs.n[0][1]*rhs.n[1][2] + lhs.n[0][2]*rhs.n[2][2];
+  r.n[0][3] = lhs.n[0][0]*rhs.n[0][3] + lhs.n[0][1]*rhs.n[1][3] + lhs.n[0][2]*rhs.n[2][3] + lhs.n[0][3];
+
+  r.n[1][0] = lhs.n[1][0]*rhs.n[0][0] + lhs.n[1][1]*rhs.n[1][0] + lhs.n[1][2]*rhs.n[2][0];
+  r.n[1][1] = lhs.n[1][0]*rhs.n[0][1] + lhs.n[1][1]*rhs.n[1][1] + lhs.n[1][2]*rhs.n[2][1];
+  r.n[1][2] = lhs.n[1][0]*rhs.n[0][2] + lhs.n[1][1]*rhs.n[1][2] + lhs.n[1][2]*rhs.n[2][2];
+  r.n[1][3] = lhs.n[1][0]*rhs.n[0][3] + lhs.n[1][1]*rhs.n[1][3] + lhs.n[1][2]*rhs.n[2][3] + lhs.n[1][3];
+
+  r.n[2][0] = lhs.n[2][0]*rhs.n[0][0] + lhs.n[2][1]*rhs.n[1][0] + lhs.n[2][2]*rhs.n[2][0];
+  r.n[2][1] = lhs.n[2][0]*rhs.n[0][1] + lhs.n[2][1]*rhs.n[1][1] + lhs.n[2][2]*rhs.n[2][1];
+  r.n[2][2] = lhs.n[2][0]*rhs.n[0][2] + lhs.n[2][1]*rhs.n[1][2] + lhs.n[2][2]*rhs.n[2][2];
+  r.n[2][3] = lhs.n[2][0]*rhs.n[0][3] + lhs.n[2][1]*rhs.n[1][3] + lhs.n[2][2]*rhs.n[2][3] + lhs.n[2][3];
 
   return r;
 }
 
-/* Give an axis-aligned box that contains the given box transformed by `lhs' */
+// Give an axis-aligned box that contains the given box transformed by `lhs'
 dmnsn_bounding_box
 dmnsn_transform_bounding_box(dmnsn_matrix trans, dmnsn_bounding_box box)
 {
-  /* Infinite/zero bounding box support */
+  // Infinite/zero bounding box support
   if (isinf(box.min.x))
     return box;
 
diff --git a/libdimension/gl.c b/libdimension/gl.c
index c6a2da5..2800484 100644
--- a/libdimension/gl.c
+++ b/libdimension/gl.c
@@ -28,7 +28,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 
-/* Optimize canvas for GL drawing */
+// Optimize canvas for GL drawing
 int
 dmnsn_gl_optimize_canvas(dmnsn_canvas *canvas)
 {
@@ -36,14 +36,14 @@ dmnsn_gl_optimize_canvas(dmnsn_canvas *canvas)
   return 0;
 }
 
-/* Write canvas to GL framebuffer.  Returns 0 on success, nonzero on failure */
+// Write canvas to GL framebuffer.  Returns 0 on success, nonzero on failure
 int
 dmnsn_gl_write_canvas(const dmnsn_canvas *canvas)
 {
   size_t width = canvas->width;
   size_t height = canvas->height;
 
-  /* Check if we can optimize this */
+  // Check if we can optimize this
   dmnsn_canvas_optimizer *optimizer =
     dmnsn_canvas_find_optimizer(canvas, dmnsn_rgba8_optimizer_fn);
   if (optimizer) {
@@ -51,7 +51,7 @@ dmnsn_gl_write_canvas(const dmnsn_canvas *canvas)
     return glGetError() == GL_NO_ERROR ? 0 : 1;
   }
 
-  /* We couldn't, so transform the canvas to RGB now */
+  // We couldn't, so transform the canvas to RGB now
   GLubyte *pixels = dmnsn_malloc(4*width*height*sizeof(GLubyte));
 
   for (size_t y = 0; y < height; ++y) {
@@ -76,14 +76,14 @@ dmnsn_gl_write_canvas(const dmnsn_canvas *canvas)
   return glGetError() == GL_NO_ERROR ? 0 : 1;
 }
 
-/* Read a canvas from a GL framebuffer.  Returns NULL on failure. */
+// Read a canvas from a GL framebuffer.  Returns NULL on failure.
 int
 dmnsn_gl_read_canvas(dmnsn_canvas *canvas, size_t x0, size_t y0)
 {
   size_t width = canvas->width;
   size_t height = canvas->height;
 
-  /* Array of 16-bit ints in RGBA order */
+  // Array of 16-bit ints in RGBA order
   GLushort *pixels = dmnsn_malloc(4*width*height*sizeof(GLushort));
   glReadPixels(x0, y0, width, height, GL_RGBA, GL_UNSIGNED_SHORT, pixels);
   if (glGetError() != GL_NO_ERROR) {
diff --git a/libdimension/gradient.c b/libdimension/gradient.c
index 2e28974..74e8045 100644
--- a/libdimension/gradient.c
+++ b/libdimension/gradient.c
@@ -25,13 +25,13 @@
 
 #include "dimension.h"
 
-/** Gradient pattern type. */
+/// Gradient pattern type.
 typedef struct dmnns_gradient {
   dmnsn_pattern pattern;
   dmnsn_vector orientation;
 } dmnsn_gradient;
 
-/** Gradient pattern callback. */
+/// Gradient pattern callback.
 static double
 dmnsn_gradient_pattern_fn(const dmnsn_pattern *pattern, dmnsn_vector v)
 {
diff --git a/libdimension/inline.c b/libdimension/inline.c
index 6b8b29d..ae175e0 100644
--- a/libdimension/inline.c
+++ b/libdimension/inline.c
@@ -23,20 +23,20 @@
  * Emit definitions of inline functions, if necessary.
  */
 
-/* Set DMNSN_INLINE to produce definitions of inline functions, emitted here,
-   if needed */
+// Set DMNSN_INLINE to produce definitions of inline functions, emitted here,
+// if needed
 #ifdef __cplusplus
-  /* C++ inline semantics */
+  // C++ inline semantics
   #define DMNSN_INLINE inline
 #elif __STDC_VERSION__ >= 199901L
-  /* C99 inline semantics */
+  // C99 inline semantics
   #define DMNSN_INLINE
 #elif defined(__GNUC__)
-  /* GCC inline semantics */
+  // GCC inline semantics
   #define DMNSN_INLINE __inline__
 #else
-  /* Unknown C - mark functions static and hope the compiler is smart enough
-     to inline them */
+  // Unknown C - mark functions static and hope the compiler is smart enough to
+  // inline them
   #define DMNSN_INLINE static
 #endif
 
diff --git a/libdimension/interior.c b/libdimension/interior.c
index 7657461..d725b6f 100644
--- a/libdimension/interior.c
+++ b/libdimension/interior.c
@@ -26,7 +26,7 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
-/* Allocate an interior */
+// Allocate an interior
 dmnsn_interior *
 dmnsn_new_interior(dmnsn_pool *pool)
 {
@@ -35,7 +35,7 @@ dmnsn_new_interior(dmnsn_pool *pool)
   return interior;
 }
 
-/* Cascade a interior */
+// Cascade an interior
 void
 dmnsn_interior_cascade(dmnsn_interior *default_interior,
                        dmnsn_interior **interiorp)
diff --git a/libdimension/lambertian.c b/libdimension/lambertian.c
index 9360872..cced4a7 100644
--- a/libdimension/lambertian.c
+++ b/libdimension/lambertian.c
@@ -27,13 +27,13 @@
 #include <math.h>
 #include <stdlib.h>
 
-/** Lambertian diffuse type. */
+/// Lambertian diffuse type.
 typedef struct dmnsn_lambertian {
   dmnsn_diffuse diffuse;
   double coeff;
 } dmnsn_lambertian;
 
-/** Diffuse finish callback. */
+/// Diffuse finish callback.
 static dmnsn_color
 dmnsn_lambertian_diffuse_fn(const dmnsn_diffuse *diffuse,
                             dmnsn_color light, dmnsn_color color,
diff --git a/libdimension/leopard.c b/libdimension/leopard.c
index 110c69c..a4000d2 100644
--- a/libdimension/leopard.c
+++ b/libdimension/leopard.c
@@ -26,7 +26,7 @@
 #include "dimension-internal.h"
 #include <math.h>
 
-/** Leopard pattern callback. */
+/// Leopard pattern callback.
 static double
 dmnsn_leopard_pattern_fn(const dmnsn_pattern *leopard, dmnsn_vector v)
 {
@@ -34,7 +34,7 @@ dmnsn_leopard_pattern_fn(const dmnsn_pattern *leopard, dmnsn_vector v)
   return val*val;
 }
 
-/** The singleton instance. */
+/// The singleton instance.
 static dmnsn_pattern dmnsn_leopard_instance = {
   .pattern_fn = dmnsn_leopard_pattern_fn,
 };
diff --git a/libdimension/light.c b/libdimension/light.c
index b1d2108..14917de 100644
--- a/libdimension/light.c
+++ b/libdimension/light.c
@@ -26,7 +26,7 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
-/* Allocate a new dummy light */
+// Allocate a new dummy light
 dmnsn_light *
 dmnsn_new_light(dmnsn_pool *pool)
 {
@@ -35,7 +35,7 @@ dmnsn_new_light(dmnsn_pool *pool)
   return light;
 }
 
-/* Initialize a light */
+// Initialize a light
 void
 dmnsn_init_light(dmnsn_light *light)
 {
diff --git a/libdimension/map.c b/libdimension/map.c
index 9a85773..1ae2a10 100644
--- a/libdimension/map.c
+++ b/libdimension/map.c
@@ -25,13 +25,13 @@
 
 #include "dimension.h"
 
-/** dmnsn_map definition. */
+/// dmnsn_map definition.
 struct dmnsn_map {
-  size_t obj_size; /**< @internal The size of the mapped objects. */
-  dmnsn_array *array; /**< @internal The map entries. */
+  size_t obj_size; ///< @internal The size of the mapped objects.
+  dmnsn_array *array; ///< @internal The map entries.
 };
 
-/** An [index, object] pair. */
+/// An [index, object] pair.
 typedef struct dmnsn_map_entry {
   double n;
   char object[];
@@ -54,7 +54,7 @@ dmnsn_map_add_entry(dmnsn_map *map, double n, const void *obj)
   entry->n = n;
   memcpy(entry->object, obj, map->obj_size);
 
-  /* Sorted insertion */
+  // Sorted insertion
   size_t i;
   for (i = dmnsn_array_size(map->array); i-- > 0;) {
     dmnsn_map_entry *other = dmnsn_array_at(map->array, i);
diff --git a/libdimension/object.c b/libdimension/object.c
index 2521353..a67b8cb 100644
--- a/libdimension/object.c
+++ b/libdimension/object.c
@@ -26,7 +26,7 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
-/* Allocate a dummy object */
+// Allocate a dummy object
 dmnsn_object *
 dmnsn_new_object(dmnsn_pool *pool)
 {
@@ -35,7 +35,7 @@ dmnsn_new_object(dmnsn_pool *pool)
   return object;
 }
 
-/* Initialize a dmnsn_object field */
+// Initialize a dmnsn_object field
 void
 dmnsn_init_object(dmnsn_object *object)
 {
@@ -49,7 +49,7 @@ dmnsn_init_object(dmnsn_object *object)
   object->precomputed = false;
 }
 
-/** Recursively precompute objects. */
+/// Recursively precompute objects.
 static void
 dmnsn_object_precompute_recursive(dmnsn_object *object, dmnsn_matrix pigment_trans)
 {
@@ -61,14 +61,14 @@ dmnsn_object_precompute_recursive(dmnsn_object *object, dmnsn_matrix pigment_tra
   dmnsn_assert(vtable->inside_fn, "Missing inside function.");
   dmnsn_assert(vtable->bounding_fn || vtable->precompute_fn, "Missing bounding and precompute function.");
 
-  /* Initialize the texture */
+  // Initialize the texture
   if (!object->texture->initialized) {
     dmnsn_texture_initialize(object->texture);
   }
 
   dmnsn_matrix total_trans = dmnsn_matrix_mul(object->trans, object->intrinsic_trans);
 
-  /* Precompute the object's children */
+  // Precompute the object's children
   if (object->children) {
     DMNSN_ARRAY_FOREACH (dmnsn_object **, child, object->children) {
       dmnsn_matrix saved_trans = (*child)->trans;
@@ -76,7 +76,7 @@ dmnsn_object_precompute_recursive(dmnsn_object *object, dmnsn_matrix pigment_tra
 
       dmnsn_matrix child_pigment_trans;
       if ((*child)->texture == NULL || (*child)->texture->pigment == NULL) {
-        /* Don't transform cascaded pigments with the child object */
+        // Don't transform cascaded pigments with the child object
         child_pigment_trans = pigment_trans;
       } else {
         child_pigment_trans = dmnsn_matrix_inverse((*child)->trans);
@@ -89,7 +89,7 @@ dmnsn_object_precompute_recursive(dmnsn_object *object, dmnsn_matrix pigment_tra
     }
   }
 
-  /* Precalculate object values */
+  // Precalculate object values
   object->pigment_trans = pigment_trans;
   object->trans_inv = dmnsn_matrix_inverse(total_trans);
   if (vtable->bounding_fn) {
@@ -100,7 +100,7 @@ dmnsn_object_precompute_recursive(dmnsn_object *object, dmnsn_matrix pigment_tra
   }
 }
 
-/* Precompute object properties */
+// Precompute object properties
 void
 dmnsn_object_precompute(dmnsn_object *object)
 {
diff --git a/libdimension/perspective.c b/libdimension/perspective.c
index a87f673..518e52e 100644
--- a/libdimension/perspective.c
+++ b/libdimension/perspective.c
@@ -26,7 +26,7 @@
 #include "dimension.h"
 #include <stdlib.h>
 
-/** Perspective camera ray callback. */
+/// Perspective camera ray callback.
 static dmnsn_line
 dmnsn_perspective_camera_ray_fn(const dmnsn_camera *camera, double x, double y)
 {
@@ -37,7 +37,7 @@ dmnsn_perspective_camera_ray_fn(const dmnsn_camera *camera, double x, double y)
   return l;
 }
 
-/* Create a new perspective camera. */
+// Create a new perspective camera.
 dmnsn_camera *
 dmnsn_new_perspective_camera(dmnsn_pool *pool)
 {
diff --git a/libdimension/phong.c b/libdimension/phong.c
index 3536f45..10e5b1a 100644
--- a/libdimension/phong.c
+++ b/libdimension/phong.c
@@ -26,14 +26,14 @@
 #include "dimension.h"
 #include <stdlib.h>
 
-/** Phone specular type. */
+/// Phone specular type.
 typedef struct dmnsn_phong {
   dmnsn_specular specular;
   double coeff;
   double exp;
 } dmnsn_phong;
 
-/** Phong specular highlight callback. */
+/// Phong specular highlight callback.
 static dmnsn_color
 dmnsn_phong_specular_fn(const dmnsn_specular *specular,
                         dmnsn_color light, dmnsn_color color,
@@ -54,7 +54,7 @@ dmnsn_phong_specular_fn(const dmnsn_specular *specular,
   return dmnsn_color_mul(phong->coeff*specular_factor, light);
 }
 
-/* A phong finish */
+// A phong finish
 dmnsn_specular *
 dmnsn_new_phong(dmnsn_pool *pool, double coeff, double exp)
 {
diff --git a/libdimension/pigment.c b/libdimension/pigment.c
index 5756087..5fae4f6 100644
--- a/libdimension/pigment.c
+++ b/libdimension/pigment.c
@@ -25,7 +25,7 @@
 
 #include "dimension-internal.h"
 
-/* Allocate a dummy pigment */
+// Allocate a dummy pigment
 dmnsn_pigment *
 dmnsn_new_pigment(dmnsn_pool *pool)
 {
@@ -34,7 +34,7 @@ dmnsn_new_pigment(dmnsn_pool *pool)
   return pigment;
 }
 
-/* Initialize a pigment */
+// Initialize a pigment
 void
 dmnsn_init_pigment(dmnsn_pigment *pigment)
 {
@@ -45,7 +45,7 @@ dmnsn_init_pigment(dmnsn_pigment *pigment)
   pigment->initialized = false;
 }
 
-/* Precompute pigment properties */
+// Precompute pigment properties
 void
 dmnsn_pigment_initialize(dmnsn_pigment *pigment)
 {
@@ -59,7 +59,7 @@ dmnsn_pigment_initialize(dmnsn_pigment *pigment)
   pigment->trans_inv = dmnsn_matrix_inverse(pigment->trans);
 }
 
-/* Evaluate a pigment */
+// Evaluate a pigment
 dmnsn_tcolor
 dmnsn_pigment_evaluate(const dmnsn_pigment *pigment, dmnsn_vector v)
 {
diff --git a/libdimension/pigment_map.c b/libdimension/pigment_map.c
index a4240d2..71de4e0 100644
--- a/libdimension/pigment_map.c
+++ b/libdimension/pigment_map.c
@@ -25,7 +25,7 @@
 
 #include "dimension.h"
 
-/** Initialize a pigment in a pigment map. */
+/// Initialize a pigment in a pigment map.
 static void
 dmnsn_initialize_mapped_pigment(void *ptr)
 {
@@ -39,7 +39,7 @@ dmnsn_new_pigment_map(dmnsn_pool *pool)
   return dmnsn_new_map(pool, sizeof(dmnsn_pigment *));
 }
 
-/** Pigment map type. */
+/// Pigment map type.
 typedef struct dmnsn_pigment_map {
   dmnsn_pigment pigment;
   dmnsn_pattern *pattern;
@@ -47,7 +47,7 @@ typedef struct dmnsn_pigment_map {
   dmnsn_pigment_map_flags flags;
 } dmnsn_pigment_map;
 
-/** pigment_map pigment callback. */
+/// pigment_map pigment callback.
 static dmnsn_tcolor
 dmnsn_pigment_map_pigment_fn(const dmnsn_pigment *pigment, dmnsn_vector v)
 {
@@ -72,7 +72,7 @@ dmnsn_pigment_map_pigment_fn(const dmnsn_pigment *pigment, dmnsn_vector v)
   return ret;
 }
 
-/** pigment_map initialization callback. */
+/// pigment_map initialization callback.
 static void
 dmnsn_pigment_map_initialize_fn(dmnsn_pigment *pigment)
 {
diff --git a/libdimension/plane.c b/libdimension/plane.c
index c09dd70..5428485 100644
--- a/libdimension/plane.c
+++ b/libdimension/plane.c
@@ -27,13 +27,13 @@
 #include <math.h>
 #include <stdlib.h>
 
-/** Plane type. */
+/// Plane type.
 typedef struct {
   dmnsn_object object;
   dmnsn_vector normal;
 } dmnsn_plane;
 
-/** Returns the closest intersection of `line' with `plane'. */
+/// Returns the closest intersection of `line' with `plane'.
 static bool
 dmnsn_plane_intersection_fn(const dmnsn_object *object, dmnsn_line line,
                             dmnsn_intersection *intersection)
@@ -53,7 +53,7 @@ dmnsn_plane_intersection_fn(const dmnsn_object *object, dmnsn_line line,
   return false;
 }
 
-/** Return whether a point is inside a plane. */
+/// Return whether a point is inside a plane.
 static bool
 dmnsn_plane_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
@@ -61,14 +61,14 @@ dmnsn_plane_inside_fn(const dmnsn_object *object, dmnsn_vector point)
   return dmnsn_vector_dot(point, plane->normal) < 0.0;
 }
 
-/** Plane bounding callback. */
+/// Plane bounding callback.
 static dmnsn_bounding_box
 dmnsn_plane_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
 {
   return dmnsn_infinite_bounding_box();
 }
 
-/** Plane vtable. */
+/// Plane vtable.
 static const dmnsn_object_vtable dmnsn_plane_vtable = {
   .intersection_fn = dmnsn_plane_intersection_fn,
   .inside_fn = dmnsn_plane_inside_fn,
diff --git a/libdimension/platform.c b/libdimension/platform.c
index d9d0e98..e0de578 100644
--- a/libdimension/platform.c
+++ b/libdimension/platform.c
@@ -33,13 +33,13 @@
   #include <windows.h>
 #endif
 #if DMNSN_BACKTRACE
-  #include <execinfo.h>    /* For backtrace() etc. */
+  #include <execinfo.h>    // For backtrace() etc.
 #endif
 #if DMNSN_GETTID
-  #include <sys/syscall.h> /* For gettid() where supported */
+  #include <sys/syscall.h> // For gettid() where supported
 #endif
 #if DMNSN_SCHED_GETAFFINITY
-  #include <sched.h>       /* For sched_getaffinity() */
+  #include <sched.h>       // For sched_getaffinity()
 #endif
 #if DMNSN_TIMES
   #include <sys/times.h>
@@ -77,7 +77,7 @@ dmnsn_is_main_thread(void)
 bool
 dmnsn_is_little_endian(void)
 {
-  /* Undefined behaviour, but quite portable */
+  // Undefined behaviour, but quite portable
   union {
     unsigned int i;
     unsigned char c;
@@ -114,7 +114,7 @@ dmnsn_ncpus(void)
 }
 
 #if DMNSN_GETRUSAGE
-/** Convert a struct timeval to a double. */
+/// Convert a struct timeval to a double.
 static inline double
 dmnsn_timeval2double(struct timeval tv)
 {
@@ -141,7 +141,7 @@ dmnsn_get_times(dmnsn_timer *timer)
 #elif DMNSN_TIMES
   static long clk_tck = 0;
 
-  /* Figure out the clock ticks per second */
+  // Figure out the clock ticks per second
   if (!clk_tck) {
     clk_tck = sysconf(_SC_CLK_TCK);
     if (clk_tck == -1) {
diff --git a/libdimension/png.c b/libdimension/png.c
index 8348e5f..24f8afa 100644
--- a/libdimension/png.c
+++ b/libdimension/png.c
@@ -30,7 +30,6 @@
 #include <stdlib.h>
 #include <stdint.h>
 
-/* Optimize canvas for PNG exporting */
 int
 dmnsn_png_optimize_canvas(dmnsn_canvas *canvas)
 {
@@ -38,14 +37,14 @@ dmnsn_png_optimize_canvas(dmnsn_canvas *canvas)
   return 0;
 }
 
-/** Payload type for PNG write thread callback. */
+/// Payload type for PNG write thread callback.
 typedef struct {
   dmnsn_future *future;
   const dmnsn_canvas *canvas;
   FILE *file;
 } dmnsn_png_write_payload;
 
-/** Payload type for PNG read thread callback. */
+/// Payload type for PNG read thread callback.
 typedef struct {
   dmnsn_future *future;
   dmnsn_canvas **canvas;
@@ -53,13 +52,11 @@ typedef struct {
   FILE *file;
 } dmnsn_png_read_payload;
 
-/** PNG write thread callback. */
+/// PNG write thread callback.
 static int dmnsn_png_write_canvas_thread(void *ptr);
-/** PNG read thread callback. */
+/// PNG read thread callback.
 static int dmnsn_png_read_canvas_thread(void *ptr);
 
-/* Write a canvas to a png file, using libpng.  Return 0 on success, nonzero on
-   failure. */
 int
 dmnsn_png_write_canvas(const dmnsn_canvas *canvas, FILE *file)
 {
@@ -67,7 +64,6 @@ dmnsn_png_write_canvas(const dmnsn_canvas *canvas, FILE *file)
   return dmnsn_future_join(future);
 }
 
-/* Write a canvas to a png file in the background */
 dmnsn_future *
 dmnsn_png_write_canvas_async(const dmnsn_canvas *canvas, FILE *file)
 {
@@ -78,13 +74,13 @@ dmnsn_png_write_canvas_async(const dmnsn_canvas *canvas, FILE *file)
   payload->canvas = canvas;
   payload->file   = file;
 
-  /* Create the worker thread */
+  // Create the worker thread
   dmnsn_new_thread(future, dmnsn_png_write_canvas_thread, payload);
 
   return future;
 }
 
-/* Read a canvas from the PNG file `file'.  Return NULL on error. */
+// Read a canvas from the PNG file `file'.  Return NULL on error.
 dmnsn_canvas *
 dmnsn_png_read_canvas(dmnsn_pool *pool, FILE *file)
 {
@@ -94,7 +90,7 @@ dmnsn_png_read_canvas(dmnsn_pool *pool, FILE *file)
   return canvas;
 }
 
-/* Read a canvas from a png file in the background */
+// Read a canvas from a png file in the background
 dmnsn_future *
 dmnsn_png_read_canvas_async(dmnsn_canvas **canvas, dmnsn_pool *pool, FILE *file)
 {
@@ -107,17 +103,17 @@ dmnsn_png_read_canvas_async(dmnsn_canvas **canvas, dmnsn_pool *pool, FILE *file)
   payload->pool = pool;
   payload->file = file;
 
-  /* Create the worker thread */
+  // Create the worker thread
   dmnsn_new_thread(future, dmnsn_png_read_canvas_thread, payload);
 
   return future;
 }
 
-/*
- * Thread callbacks
- */
+//////////////////////
+// Thread callbacks //
+//////////////////////
 
-/* Write a PNG file */
+// Write a PNG file
 static int
 dmnsn_png_write_canvas_thread(void *ptr)
 {
@@ -131,74 +127,74 @@ dmnsn_png_write_canvas_thread(void *ptr)
   png_structp png_ptr
     = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
   if (!png_ptr) {
-    /* Couldn't create libpng write struct */
+    // Couldn't create libpng write struct
     dmnsn_free(payload);
     return -1;
   }
 
   png_infop info_ptr = png_create_info_struct(png_ptr);
   if (!info_ptr) {
-    /* Couldn't create libpng info struct */
+    // Couldn't create libpng info struct
     png_destroy_write_struct(&png_ptr, NULL);
     dmnsn_free(payload);
     return -1;
   }
 
-  /* libpng will longjmp here if it encounters an error from here on */
+  // libpng will longjmp here if it encounters an error from here on
   uint16_t *row = NULL;
   if (setjmp(png_jmpbuf(png_ptr))) {
-    /* libpng error */
+    // libpng error
     dmnsn_free(row);
     png_destroy_write_struct(&png_ptr, &info_ptr);
     dmnsn_free(payload);
     return -1;
   }
 
-  /* Associate file with the libpng write struct */
+  // Associate file with the libpng write struct
   png_init_io(png_ptr, payload->file);
 
-  /* Set header correctly for 16-bit sRGB image */
+  // Set header correctly for 16-bit sRGB image
   png_set_IHDR(png_ptr, info_ptr, width, height, 16,
                PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
                PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
   png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, PNG_sRGB_INTENT_ABSOLUTE);
 
-  /* We think of transparency in the opposite way that PNG does */
+  // We think of transparency in the opposite way that PNG does
   png_set_invert_alpha(png_ptr);
 
-  /* Write the info struct */
+  // Write the info struct
   png_write_info(png_ptr, info_ptr);
 
   if (dmnsn_is_little_endian()) {
-    /* We are little-endian; swap the byte order of the pixels */
+    // We are little-endian; swap the byte order of the pixels
     png_set_swap(png_ptr);
   }
 
-  /* Check if we can optimize this */
+  // Check if we can optimize this
   dmnsn_canvas_optimizer *optimizer =
     dmnsn_canvas_find_optimizer(payload->canvas, dmnsn_rgba16_optimizer_fn);
   if (optimizer) {
     for (size_t y = 0; y < height; ++y) {
-      /* Invert the rows.  PNG coordinates are fourth quadrant. */
+      // Invert the rows.  PNG coordinates are fourth quadrant.
       uint16_t *row_opt = (uint16_t *)optimizer->ptr + 4*(height - y - 1)*width;
       png_write_row(png_ptr, (png_bytep)row_opt);
       dmnsn_future_increment(payload->future);
     }
 
-    /* Finish the PNG file */
+    // Finish the PNG file
     png_write_end(png_ptr, info_ptr);
     png_destroy_write_struct(&png_ptr, &info_ptr);
     dmnsn_free(payload);
     return 0;
   }
 
-  /* Allocate the temporary row of RGBA values */
+  // Allocate the temporary row of RGBA values
   row = dmnsn_malloc(4*sizeof(uint16_t)*width);
 
-  /* Write the pixels */
+  // Write the pixels
   for (size_t y = 0; y < height; ++y) {
     for (size_t x = 0; x < width; ++x) {
-      /* Invert the rows.  PNG coordinates are fourth quadrant. */
+      // Invert the rows.  PNG coordinates are fourth quadrant.
       dmnsn_tcolor tcolor = dmnsn_canvas_get_pixel(payload->canvas,
                                                    x, height - y - 1);
       tcolor = dmnsn_tcolor_remove_filter(tcolor);
@@ -211,12 +207,12 @@ dmnsn_png_write_canvas_thread(void *ptr)
       row[4*x + 3] = lround(tcolor.T*UINT16_MAX);
     }
 
-    /* Write the row */
+    // Write the row
     png_write_row(png_ptr, (png_bytep)row);
     dmnsn_future_increment(payload->future);
   }
 
-  /* Finish the PNG file */
+  // Finish the PNG file
   png_write_end(png_ptr, info_ptr);
 
   dmnsn_free(row);
@@ -225,18 +221,18 @@ dmnsn_png_write_canvas_thread(void *ptr)
   return 0;
 }
 
-/** Thread-specific pointer to the appropriate dmnsn_future* for
-    dmnsn_png_read_row_callback. */
+/// Thread-specific pointer to the appropriate dmnsn_future* for
+/// dmnsn_png_read_row_callback.
 static __thread dmnsn_future *dmnsn_tl_png_read_future;
 
-/** Callback to increment the progress after a row has been read. */
+/// Callback to increment the progress after a row has been read.
 static void
 dmnsn_png_read_row_callback(png_structp png_ptr, png_uint_32 row, int pass)
 {
   dmnsn_future_increment(dmnsn_tl_png_read_future);
 }
 
-/* Read a PNG file */
+// Read a PNG file
 static int
 dmnsn_png_read_canvas_thread(void *ptr)
 {
@@ -249,13 +245,13 @@ dmnsn_png_read_canvas_thread(void *ptr)
     return -1;
   }
   if (png_sig_cmp(header, 0, 8)) {
-    /* payload->file is not a PNG file */
+    // payload->file is not a PNG file
     dmnsn_free(payload);
     errno = EINVAL;
     return -1;
   }
 
-  /* Create the libpng read struct */
+  // Create the libpng read struct
   png_structp png_ptr
     = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
   if (!png_ptr) {
@@ -263,7 +259,7 @@ dmnsn_png_read_canvas_thread(void *ptr)
     return -1;
   }
 
-  /* Create the libpng info struct */
+  // Create the libpng info struct
   png_infop info_ptr = png_create_info_struct(png_ptr);
   if (!info_ptr) {
     png_destroy_read_struct(&png_ptr, NULL, NULL);
@@ -271,11 +267,11 @@ dmnsn_png_read_canvas_thread(void *ptr)
     return -1;
   }
 
-  /* libpng will longjmp here if it encounters an error from here on */
+  // libpng will longjmp here if it encounters an error from here on
   png_bytep image = NULL;
   png_bytep *row_pointers = NULL;
   if (setjmp(png_jmpbuf(png_ptr))) {
-    /* libpng error */
+    // libpng error
     dmnsn_free(row_pointers);
     dmnsn_free(image);
     png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
@@ -283,15 +279,15 @@ dmnsn_png_read_canvas_thread(void *ptr)
     return -1;
   }
 
-  /* Associate the read struct with the file, and tell it we've already checked
-     8 bytes of signature */
+  // Associate the read struct with the file, and tell it we've already checked
+  // 8 bytes of signature
   png_init_io(png_ptr, payload->file);
   png_set_sig_bytes(png_ptr, 8);
 
-  /* Read the PNG header into info struct */
+  // Read the PNG header into info struct
   png_read_info(png_ptr, info_ptr);
 
-  /* Get useful information from the info struct */
+  // Get useful information from the info struct
   png_uint_32 width, height;
   int bit_depth, color_type, interlace_type, compression_type, filter_method;
   png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
@@ -301,12 +297,10 @@ dmnsn_png_read_canvas_thread(void *ptr)
   dmnsn_future_set_total(payload->future, (number_of_passes + 1)*height);
   png_set_read_status_fn(png_ptr, dmnsn_png_read_row_callback);
 
-  /*
-   * - Convert paletted images to RGB.
-   * - Convert a tRNS chunk to an alpha channel
-   * - Convert grayscale to RGB
-   * - Invert the alpha channel
-   */
+  // - Convert paletted images to RGB.
+  // - Convert a tRNS chunk to an alpha channel
+  // - Convert grayscale to RGB
+  // - Invert the alpha channel
   if (color_type == PNG_COLOR_TYPE_PALETTE) {
     png_set_palette_to_rgb(png_ptr);
   }
@@ -320,32 +314,32 @@ dmnsn_png_read_canvas_thread(void *ptr)
   }
   png_set_invert_alpha(png_ptr);
 
-  /* Update the info struct */
+  // Update the info struct
   png_read_update_info(png_ptr, info_ptr);
 
-  /* Get bytes/image row */
+  // Get bytes/image row
   png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
 
-  /* Allocate the temporary image buffer */
+  // Allocate the temporary image buffer
   image = dmnsn_malloc(rowbytes*height);
 
-  /* Allocate and set an array of pointers to rows in image */
+  // Allocate and set an array of pointers to rows in image
   row_pointers = dmnsn_malloc(sizeof(png_bytep)*height);
 
   for (size_t y = 0; y < height; ++y) {
     row_pointers[y] = image + y*rowbytes;
   }
 
-  /* Read the image to memory all at once.  At the expense of greater memory
-     use, this handles interlacing for us. */
+  // Read the image to memory all at once.  At the expense of greater memory
+  // use, this handles interlacing for us.
   png_read_image(png_ptr, row_pointers);
 
-  /* Allocate the canvas */
+  // Allocate the canvas
   *payload->canvas = dmnsn_new_canvas(payload->pool, width, height);
 
-  /* Now we convert the image to our canvas format.  This depends on the image
-     bit depth (which has been scaled up to at least 8 or 16), and the presence
-     of an alpha channel. */
+  // Now we convert the image to our canvas format.  This depends on the image
+  // bit depth (which has been scaled up to at least 8 or 16), and the presence
+  // of an alpha channel.
   for (size_t y = 0; y < height; ++y) {
     for (size_t x = 0; x < width; ++x) {
       dmnsn_tcolor tcolor;
diff --git a/libdimension/point_light.c b/libdimension/point_light.c
index 62857d8..b8c2cfb 100644
--- a/libdimension/point_light.c
+++ b/libdimension/point_light.c
@@ -26,14 +26,14 @@
 #include "dimension.h"
 #include <stdlib.h>
 
-/** Point light type. */
+/// Point light type.
 typedef struct dmnsn_point_light {
   dmnsn_light light;
   dmnsn_vector origin;
   dmnsn_color color;
 } dmnsn_point_light;
 
-/** Point light direction callback. */
+/// Point light direction callback.
 static dmnsn_vector
 dmnsn_point_light_direction_fn(const dmnsn_light *light, dmnsn_vector v)
 {
@@ -41,7 +41,7 @@ dmnsn_point_light_direction_fn(const dmnsn_light *light, dmnsn_vector v)
   return dmnsn_vector_sub(point_light->origin, v);
 }
 
-/** Point light illumination callback. */
+/// Point light illumination callback.
 static dmnsn_color
 dmnsn_point_light_illumination_fn(const dmnsn_light *light, dmnsn_vector v)
 {
@@ -49,7 +49,7 @@ dmnsn_point_light_illumination_fn(const dmnsn_light *light, dmnsn_vector v)
   return point_light->color;
 }
 
-/** Point light illumination callback. */
+/// Point light illumination callback.
 static bool
 dmnsn_point_light_shadow_fn(const dmnsn_light *light, double t)
 {
diff --git a/libdimension/polynomial.c b/libdimension/polynomial.c
index 3f64091..23b96d1 100644
--- a/libdimension/polynomial.c
+++ b/libdimension/polynomial.c
@@ -27,7 +27,7 @@
 #include "dimension-internal.h"
 #include <math.h>
 
-/** Get the real degree of a polynomial, ignoring leading zeros. */
+/// Get the real degree of a polynomial, ignoring leading zeros.
 static inline size_t
 dmnsn_real_degree(const double poly[], size_t degree)
 {
@@ -40,7 +40,7 @@ dmnsn_real_degree(const double poly[], size_t degree)
   return 0;
 }
 
-/** Divide each coefficient by the leading coefficient. */
+/// Divide each coefficient by the leading coefficient.
 static inline void
 dmnsn_polynomial_normalize(double poly[], size_t degree)
 {
@@ -50,7 +50,7 @@ dmnsn_polynomial_normalize(double poly[], size_t degree)
   poly[degree] = 1.0;
 }
 
-/** Eliminate trivial zero roots from \p poly[]. */
+/// Eliminate trivial zero roots from \p poly[].
 static inline void
 dmnsn_eliminate_zero_roots(double **poly, size_t *degree)
 {
@@ -65,7 +65,7 @@ dmnsn_eliminate_zero_roots(double **poly, size_t *degree)
   *degree -= i;
 }
 
-/** Calculate a finite upper bound on the roots of a normalized polynomial. */
+/// Calculate a finite upper bound on the roots of a normalized polynomial.
 static inline double
 dmnsn_root_bound(const double poly[], size_t degree)
 {
@@ -77,7 +77,7 @@ dmnsn_root_bound(const double poly[], size_t degree)
   return bound;
 }
 
-/** Copy a polynomial. */
+/// Copy a polynomial.
 static inline void
 dmnsn_polynomial_copy(double dest[], const double src[], size_t degree)
 {
@@ -86,7 +86,7 @@ dmnsn_polynomial_copy(double dest[], const double src[], size_t degree)
   }
 }
 
-/** Transform a polynomial by P'(x) = P(x + 1). */
+/// Transform a polynomial by P'(x) = P(x + 1).
 static inline void
 dmnsn_polynomial_translate(double poly[], size_t degree)
 {
@@ -97,7 +97,7 @@ dmnsn_polynomial_translate(double poly[], size_t degree)
   }
 }
 
-/** Transform a polynomial by P'(x) = P(c*x). */
+/// Transform a polynomial by P'(x) = P(c*x).
 static inline void
 dmnsn_polynomial_scale(double poly[], size_t degree, double c)
 {
@@ -108,22 +108,22 @@ dmnsn_polynomial_scale(double poly[], size_t degree, double c)
   }
 }
 
-/** Returns the result of Descartes' rule on x^degree * poly(1/(x + 1)). */
+/// Returns the result of Descartes' rule on x^degree * poly(1/(x + 1)).
 static size_t
 dmnsn_descartes_bound(const double poly[], size_t degree)
 {
-  /* Copy the polynomial so we can be destructive */
+  // Copy the polynomial so we can be destructive
   double p[degree + 1];
   dmnsn_polynomial_copy(p, poly, degree);
 
-  /* Calculate poly(1/(1/x + 1)) which avoids reversal */
+  // Calculate poly(1/(1/x + 1)) which avoids reversal
   for (size_t i = 1; i <= degree; ++i) {
     for (size_t j = i; j >= 1; --j) {
       p[j] += p[j - 1];
     }
   }
 
-  /* Find the number of sign changes in p[] */
+  // Find the number of sign changes in p[]
   size_t changes = 0;
   int lastsign = dmnsn_sign(p[0]);
   for (size_t i = 1; changes <= 1 && i <= degree; ++i) {
@@ -137,20 +137,20 @@ dmnsn_descartes_bound(const double poly[], size_t degree)
   return changes;
 }
 
-/** Depth-first search of possible isolating intervals. */
+/// Depth-first search of possible isolating intervals.
 static size_t
 dmnsn_root_bounds_recursive(double poly[], size_t degree, double *c, double *k,
                             double bounds[][2], size_t nbounds)
 {
   size_t s = dmnsn_descartes_bound(poly, degree);
   if (s >= 2) {
-    /* Get the left child */
+    // Get the left child
     dmnsn_polynomial_scale(poly, degree, 1.0/2.0);
     *c *= 2.0;
     *k /= 2.0;
     double currc = *c, currk = *k;
 
-    /* Test the left child */
+    // Test the left child
     size_t n = dmnsn_root_bounds_recursive(poly, degree, c, k, bounds, nbounds);
     if (nbounds == n) {
       return n;
@@ -158,13 +158,13 @@ dmnsn_root_bounds_recursive(double poly[], size_t degree, double *c, double *k,
     bounds += n;
     nbounds -= n;
 
-    /* Get the right child from the last tested polynomial */
+    // Get the right child from the last tested polynomial
     dmnsn_polynomial_translate(poly, degree);
     dmnsn_polynomial_scale(poly, degree, currk/(*k));
     *c = currc + 1.0;
     *k = currk;
 
-    /* Test the right child */
+    // Test the right child
     n += dmnsn_root_bounds_recursive(poly, degree, c, k, bounds, nbounds);
     return n;
   } else if (s == 1) {
@@ -176,26 +176,26 @@ dmnsn_root_bounds_recursive(double poly[], size_t degree, double *c, double *k,
   }
 }
 
-/** Find ranges that contain a single root. */
+/// Find ranges that contain a single root.
 static size_t
 dmnsn_root_bounds(const double poly[], size_t degree, double bounds[][2],
                   size_t nbounds)
 {
-  /* Copy the polynomial so we can be destructive */
+  // Copy the polynomial so we can be destructive
   double p[degree + 1];
   dmnsn_polynomial_copy(p, poly, degree);
 
-  /* Scale the roots to within (0, 1] */
+  // Scale the roots to within (0, 1]
   double bound = dmnsn_root_bound(p, degree);
   dmnsn_polynomial_scale(p, degree, bound);
 
-  /* Bounding intervals are of the form (c*k, (c + 1)*k) */
+  // Bounding intervals are of the form (c*k, (c + 1)*k)
   double c = 0.0, k = 1.0;
 
-  /* Isolate the roots */
+  // Isolate the roots
   size_t n = dmnsn_root_bounds_recursive(p, degree, &c, &k, bounds, nbounds);
 
-  /* Scale the roots back to within (0, bound] */
+  // Scale the roots back to within (0, bound]
   for (size_t i = 0; i < n; ++i) {
     bounds[i][0] *= bound;
     bounds[i][1] *= bound;
@@ -204,18 +204,18 @@ dmnsn_root_bounds(const double poly[], size_t degree, double bounds[][2],
   return n;
 }
 
-/** Maximum number of iterations in dmnsn_bisect_root() before bailout. */
+/// Maximum number of iterations in dmnsn_bisect_root() before bailout.
 #define DMNSN_BISECT_ITERATIONS 64
 
-/** Use the false position method to find a root in a range that contains
-    exactly one root. */
+/// Use the false position method to find a root in a range that contains
+/// exactly one root.
 static inline double
 dmnsn_bisect_root(const double poly[], size_t degree, double min, double max)
 {
   double evmin = dmnsn_polynomial_evaluate(poly, degree, min);
   double evmax = dmnsn_polynomial_evaluate(poly, degree, max);
 
-  /* Handle equal bounds, and equal values at the bounds. */
+  // Handle equal bounds, and equal values at the bounds.
   if (dmnsn_unlikely(fabs(evmax - evmin) < dmnsn_epsilon)) {
     return (min + max)/2.0;
   }
@@ -230,8 +230,8 @@ dmnsn_bisect_root(const double poly[], size_t degree, double min, double max)
     int sign = dmnsn_sign(evmid);
 
     if ((fabs(evmid) < fabs(mid)*dmnsn_epsilon
-         /* This condition improves stability when one of the bounds is
-            close to a different root than we are trying to find */
+         // This condition improves stability when one of the bounds is close to
+         // a different root than we are trying to find
          && fabs(evmid) <= evinitial)
         || max - min < fabs(mid)*dmnsn_epsilon)
     {
@@ -239,8 +239,8 @@ dmnsn_bisect_root(const double poly[], size_t degree, double min, double max)
     }
 
     if (mid < min) {
-      /* This can happen due to numerical instability in the root bounding
-         algorithm, so behave like the normal secant method */
+      // This can happen due to numerical instability in the root bounding
+      // algorithm, so behave like the normal secant method
       max = min;
       evmax = evmin;
       min = mid;
@@ -254,8 +254,8 @@ dmnsn_bisect_root(const double poly[], size_t degree, double min, double max)
       max = mid;
       evmax = evmid;
       if (sign == lastsign) {
-        /* Don't allow the algorithm to keep the same endpoint for three
-           iterations in a row; this ensures superlinear convergence */
+        // Don't allow the algorithm to keep the same endpoint for three
+        // iterations in a row; this ensures superlinear convergence
         evmin /= 2.0;
       }
     } else {
@@ -272,7 +272,7 @@ dmnsn_bisect_root(const double poly[], size_t degree, double min, double max)
   return mid;
 }
 
-/** Use synthetic division to eliminate the root \p r from \p poly[]. */
+/// Use synthetic division to eliminate the root \p r from \p poly[].
 static inline size_t
 dmnsn_eliminate_root(double poly[], size_t degree, double r)
 {
@@ -285,7 +285,7 @@ dmnsn_eliminate_root(double poly[], size_t degree, double r)
   return degree - 1;
 }
 
-/** Solve a normalized linear polynomial algebraically. */
+/// Solve a normalized linear polynomial algebraically.
 static inline size_t
 dmnsn_solve_linear(const double poly[2], double x[1])
 {
@@ -296,7 +296,7 @@ dmnsn_solve_linear(const double poly[2], double x[1])
     return 0;
 }
 
-/** Solve a normalized quadratic polynomial algebraically. */
+/// Solve a normalized quadratic polynomial algebraically.
 static inline size_t
 dmnsn_solve_quadratic(const double poly[3], double x[2])
 {
@@ -317,11 +317,11 @@ dmnsn_solve_quadratic(const double poly[3], double x[2])
   }
 }
 
-/** Solve a normalized cubic polynomial algebraically. */
+/// Solve a normalized cubic polynomial algebraically.
 static inline size_t
 dmnsn_solve_cubic(double poly[4], double x[3])
 {
-  /* Reduce to a monic trinomial (t^3 + p*t + q, t = x + b/3) */
+  // Reduce to a monic trinomial (t^3 + p*t + q, t = x + b/3)
   double b2 = poly[2]*poly[2];
   double p = poly[1] - b2/3.0;
   double q = poly[0] - poly[2]*(9.0*poly[1] - 2.0*b2)/27.0;
@@ -330,11 +330,11 @@ dmnsn_solve_cubic(double poly[4], double x[3])
   double bdiv3 = poly[2]/3.0;
 
   if (disc < 0.0) {
-    /* Three real roots -- this implies p < 0 */
+    // Three real roots -- this implies p < 0
     double msqrtp3 = -sqrt(-p/3.0);
     double theta = acos(3*q/(2*p*msqrtp3))/3.0;
 
-    /* Store the roots in order from largest to smallest */
+    // Store the roots in order from largest to smallest
     x[2] = 2.0*msqrtp3*cos(theta) - bdiv3;
     x[0] = -2.0*msqrtp3*cos(4.0*atan(1.0)/3.0 - theta) - bdiv3;
     x[1] = -(x[0] + x[2] + poly[2]);
@@ -344,7 +344,7 @@ dmnsn_solve_cubic(double poly[4], double x[3])
     else if (x[1] >= dmnsn_epsilon)
       return 2;
   } else if (disc > 0.0) {
-    /* One real root */
+    // One real root
     double cbrtdiscq = cbrt(sqrt(disc/108.0) + fabs(q)/2.0);
     double abst = cbrtdiscq - p/(3.0*cbrtdiscq);
 
@@ -354,10 +354,10 @@ dmnsn_solve_cubic(double poly[4], double x[3])
       x[0] = abst - bdiv3;
     }
   } else if (fabs(p) < dmnsn_epsilon) {
-    /* Equation is a perfect cube */
+    // Equation is a perfect cube
     x[0] = -bdiv3;
   } else {
-    /* Two real roots; one duplicate */
+    // Two real roots; one duplicate
     double t1 = -(3.0*q)/(2.0*p), t2 = -2.0*t1;
     x[0] = dmnsn_max(t1, t2) - bdiv3;
     x[1] = dmnsn_min(t1, t2) - bdiv3;
@@ -371,38 +371,38 @@ dmnsn_solve_cubic(double poly[4], double x[3])
     return 0;
 }
 
-/* Solve a polynomial */
+// Solve a polynomial
 DMNSN_HOT size_t
 dmnsn_polynomial_solve(const double poly[], size_t degree, double x[])
 {
-  /* Copy the polynomial so we can be destructive */
+  // Copy the polynomial so we can be destructive
   double copy[degree + 1], *p = copy;
   dmnsn_polynomial_copy(p, poly, degree);
 
-  /* Index into x[] */
+  // Index into x[]
   size_t i = 0;
 
-  /* Account for leading zero coefficients */
+  // Account for leading zero coefficients
   degree = dmnsn_real_degree(p, degree);
-  /* Normalize the leading coefficient to 1.0 */
+  // Normalize the leading coefficient to 1.0
   dmnsn_polynomial_normalize(p, degree);
-  /* Eliminate simple zero roots */
+  // Eliminate simple zero roots
   dmnsn_eliminate_zero_roots(&p, &degree);
 
   static const size_t max_algebraic = 3;
   if (degree > max_algebraic) {
-    /* Find isolating intervals for (degree - max_algebraic) roots of p[] */
+    // Find isolating intervals for (degree - max_algebraic) roots of p[]
     double ranges[degree - max_algebraic][2];
     size_t n = dmnsn_root_bounds(p, degree, ranges, degree - max_algebraic);
 
     for (size_t j = 0; j < n; ++j) {
-      /* Bisect within the found range */
+      // Bisect within the found range
       double r = dmnsn_bisect_root(p, degree, ranges[j][0], ranges[j][1]);
 
-      /* Use synthetic division to eliminate the root `r' */
+      // Use synthetic division to eliminate the root `r'
       degree = dmnsn_eliminate_root(p, degree, r);
 
-      /* Store the found root */
+      // Store the found root
       x[i] = r;
       ++i;
     }
@@ -423,7 +423,7 @@ dmnsn_polynomial_solve(const double poly[], size_t degree, double x[])
   return i;
 }
 
-/* Print a polynomial */
+// Print a polynomial
 void
 dmnsn_polynomial_print(FILE *file, const double poly[], size_t degree)
 {
diff --git a/libdimension/pool.c b/libdimension/pool.c
index 8973371..bd31677 100644
--- a/libdimension/pool.c
+++ b/libdimension/pool.c
@@ -26,30 +26,30 @@
 #include "dimension-internal.h"
 #include <stdatomic.h>
 
-/** A single allocation and associated destructor. */
+/// A single allocation and associated destructor.
 typedef struct dmnsn_allocation {
   void *ptr;
   dmnsn_callback_fn *cleanup_fn;
 } dmnsn_allocation;
 
-/** Number of pointers per block, we want a block to fit in a single page. */
+/// Number of pointers per block, we want a block to fit in a single page.
 #define DMNSN_POOL_BLOCK_SIZE ((4096 - 4*sizeof(void *))/sizeof(dmnsn_allocation))
 
-/** A single block in a thread pool. */
+/// A single block in a thread pool.
 typedef struct dmnsn_pool_block {
-  /** Current index into allocs[]. */
+  /// Current index into allocs[].
   size_t i;
-  /** All allocations in the current block. */
+  /// All allocations in the current block.
   dmnsn_allocation allocs[DMNSN_POOL_BLOCK_SIZE];
-  /** Tail pointer to the previous block in the global chain. */
+  /// Tail pointer to the previous block in the global chain.
   struct dmnsn_pool_block *prev;
 } dmnsn_pool_block;
 
-/** dmnsn_pool implementation. */
+/// dmnsn_pool implementation.
 struct dmnsn_pool {
-  /** Thread-local block. */
+  /// Thread-local block.
   pthread_key_t thread_block;
-  /** Global chain of pools. */
+  /// Global chain of pools.
   _Atomic(dmnsn_pool_block *) chain;
 };
 
@@ -87,7 +87,7 @@ dmnsn_palloc_tidy(dmnsn_pool *pool, size_t size, dmnsn_callback_fn *cleanup_fn)
   if (dmnsn_unlikely(new_block != old_block)) {
     dmnsn_setspecific(pool->thread_block, new_block);
 
-    /* Atomically update pool->chain */
+    // Atomically update pool->chain
     dmnsn_pool_block *chain;
     do {
       chain = atomic_load(&pool->chain);
@@ -107,7 +107,7 @@ dmnsn_delete_pool(dmnsn_pool *pool)
 
   dmnsn_pool_block *block = atomic_load_explicit(&pool->chain, memory_order_relaxed);
   while (block) {
-    /* Free all the allocations in reverse order */
+    // Free all the allocations in reverse order
     for (size_t i = block->i; i-- > 0;) {
       dmnsn_allocation *alloc = block->allocs + i;
       if (alloc->cleanup_fn) {
@@ -116,7 +116,7 @@ dmnsn_delete_pool(dmnsn_pool *pool)
       dmnsn_free(alloc->ptr);
     }
 
-    /* Free the block itself and go to the previous one */
+    // Free the block itself and go to the previous one
     dmnsn_pool_block *saved = block;
     block = block->prev;
     dmnsn_free(saved);
diff --git a/libdimension/profile.c b/libdimension/profile.c
index 308c8fb..164e002 100644
--- a/libdimension/profile.c
+++ b/libdimension/profile.c
@@ -28,23 +28,23 @@
 #include <stdio.h>
 #include <inttypes.h>
 
-/** Information on one predicted branch. */
+/// Information on one predicted branch.
 typedef struct {
   char *location;
   uint64_t predicted, branches;
 } dmnsn_branch;
 
-/** Count of mispredicted branches. */
+/// Count of mispredicted branches.
 static dmnsn_dictionary *dmnsn_profile = NULL;
-/** Mutex which protects \c dmnsn_profile. */
+/// Mutex which protects \c dmnsn_profile.
 static pthread_mutex_t dmnsn_profile_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-/** Thread-local count of mispredicted branches. */
+/// Thread-local count of mispredicted branches.
 static pthread_key_t dmnsn_thread_profile;
-/** Initialize the thread-specific pointer exactly once. */
+/// Initialize the thread-specific pointer exactly once.
 static pthread_once_t dmnsn_thread_profile_once = PTHREAD_ONCE_INIT;
 
-/** Add thread-specific profile data to the global counts. */
+/// Add thread-specific profile data to the global counts.
 static void
 dmnsn_profile_globalize(void *ptr)
 {
@@ -59,7 +59,7 @@ dmnsn_profile_globalize(void *ptr)
   }
 }
 
-/** Destructor function for thread-specific profile data. */
+/// Destructor function for thread-specific profile data.
 static void
 dmnsn_delete_thread_profile(void *ptr)
 {
@@ -72,7 +72,7 @@ dmnsn_delete_thread_profile(void *ptr)
   dmnsn_delete_dictionary(thread_profile);
 }
 
-/** Initialize the thread-specific pointer. */
+/// Initialize the thread-specific pointer.
 static void
 dmnsn_initialize_thread_profile(void)
 {
@@ -83,7 +83,7 @@ dmnsn_initialize_thread_profile(void)
   dmnsn_unlock_mutex(&dmnsn_profile_mutex);
 }
 
-/** Get the thread-specific profile data. */
+/// Get the thread-specific profile data.
 static dmnsn_dictionary *
 dmnsn_get_thread_profile(void)
 {
@@ -91,7 +91,7 @@ dmnsn_get_thread_profile(void)
   return pthread_getspecific(dmnsn_thread_profile);
 }
 
-/** Set the thread-specific profile data. */
+/// Set the thread-specific profile data.
 static void
 dmnsn_set_thread_profile(dmnsn_dictionary *thread_profile)
 {
diff --git a/libdimension/prtree.c b/libdimension/prtree.c
index b4b9e82..0d484ce 100644
--- a/libdimension/prtree.c
+++ b/libdimension/prtree.c
@@ -26,28 +26,28 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
-/** Number of children per PR-node. */
+/// Number of children per PR-node.
 #define DMNSN_PRTREE_B 8
-/** Number of priority leaves per pseudo-PR-node (must be 2*ndimensions). */
+/// Number of priority leaves per pseudo-PR-node (must be 2*ndimensions).
 #define DMNSN_PSEUDO_B 6
 
-/** The side of the split that a node ended up on. */
+/// The side of the split that a node ended up on.
 typedef enum dmnsn_prnode_location {
-  DMNSN_PRTREE_LEAF, /**< Priority leaf. */
-  DMNSN_PRTREE_LEFT, /**< Left child. */
-  DMNSN_PRTREE_RIGHT /**< Right child. */
+  DMNSN_PRTREE_LEAF, ///< Priority leaf.
+  DMNSN_PRTREE_LEFT, ///< Left child.
+  DMNSN_PRTREE_RIGHT ///< Right child.
 } dmnsn_prnode_location;
 
-/** Construct an empty PR-node. */
+/// Construct an empty PR-node.
 static inline dmnsn_bvh_node *
 dmnsn_new_prnode(void)
 {
   dmnsn_bvh_node *node = dmnsn_new_bvh_node(DMNSN_PRTREE_B);
-  node->data = DMNSN_PRTREE_LEFT; /* Mustn't be _LEAF */
+  node->data = DMNSN_PRTREE_LEFT; // Mustn't be _LEAF
   return node;
 }
 
-/** Comparator types. */
+/// Comparator types.
 enum {
   DMNSN_XMIN,
   DMNSN_YMIN,
@@ -57,7 +57,7 @@ enum {
   DMNSN_ZMAX
 };
 
-/* List sorting comparators */
+// List sorting comparators
 
 static int
 dmnsn_xmin_comp(const void *l, const void *r)
@@ -107,7 +107,7 @@ dmnsn_zmax_comp(const void *l, const void *r)
   return (lval < rval) - (lval > rval);
 }
 
-/** All comparators. */
+/// All comparators.
 static dmnsn_array_comparator_fn *const dmnsn_comparators[DMNSN_PSEUDO_B] = {
   [DMNSN_XMIN] = dmnsn_xmin_comp,
   [DMNSN_YMIN] = dmnsn_ymin_comp,
@@ -117,7 +117,7 @@ static dmnsn_array_comparator_fn *const dmnsn_comparators[DMNSN_PSEUDO_B] = {
   [DMNSN_ZMAX] = dmnsn_zmax_comp,
 };
 
-/** Add the priority leaves for this level. */
+/// Add the priority leaves for this level.
 static void
 dmnsn_add_priority_leaves(dmnsn_bvh_node **sorted_leaves[DMNSN_PSEUDO_B],
                           size_t nleaves,
@@ -130,7 +130,7 @@ dmnsn_add_priority_leaves(dmnsn_bvh_node **sorted_leaves[DMNSN_PSEUDO_B],
          j < nleaves && (!leaf || leaf->nchildren < DMNSN_PRTREE_B);
          ++j)
     {
-      /* Skip all the previously found extreme nodes */
+      // Skip all the previously found extreme nodes
       if (leaves[j]->data == DMNSN_PRTREE_LEAF) {
         continue;
       }
@@ -155,7 +155,7 @@ dmnsn_split_sorted_leaves_easy(dmnsn_bvh_node **leaves,
                                size_t *nleaves,
                                size_t *nright_leaves)
 {
-  /* Get rid of the extreme nodes */
+  // Get rid of the extreme nodes
   size_t i, skip, size = *nleaves;
   for (i = 0, skip = 0; i < size; ++i) {
     if (leaves[i]->data == DMNSN_PRTREE_LEAF) {
@@ -167,7 +167,7 @@ dmnsn_split_sorted_leaves_easy(dmnsn_bvh_node **leaves,
 
   size -= skip;
 
-  /* Split the leaves and mark the left and right child nodes */
+  // Split the leaves and mark the left and right child nodes
   size_t left_size = (size + 1)/2;
   for (i = 0; i < left_size; ++i) {
     leaves[i]->data = DMNSN_PRTREE_LEFT;
@@ -204,7 +204,7 @@ dmnsn_split_sorted_leaves_hard(dmnsn_bvh_node **leaves,
   }
 }
 
-/** Split the sorted lists into the left and right subtrees. */
+/// Split the sorted lists into the left and right subtrees.
 static void
 dmnsn_split_sorted_leaves(dmnsn_bvh_node **sorted_leaves[DMNSN_PSEUDO_B],
                           size_t *nleaves,
@@ -215,10 +215,10 @@ dmnsn_split_sorted_leaves(dmnsn_bvh_node **sorted_leaves[DMNSN_PSEUDO_B],
 {
   size_t original_size = *nleaves;
 
-  /* Split the ith list */
+  // Split the ith list
   dmnsn_split_sorted_leaves_easy(sorted_leaves[i], nleaves, nright_leaves);
 
-  /* Split the rest of the lists */
+  // Split the rest of the lists
   for (size_t j = 0; j < DMNSN_PSEUDO_B; ++j) {
     right_sorted_leaves[j] = sorted_leaves[j] + *nleaves;
     if (j == i) {
@@ -229,8 +229,8 @@ dmnsn_split_sorted_leaves(dmnsn_bvh_node **sorted_leaves[DMNSN_PSEUDO_B],
   }
 }
 
-/** Recursively constructs an implicit pseudo-PR-tree and collects the priority
-    leaves. */
+/// Recursively constructs an implicit pseudo-PR-tree and collects the priority
+/// leaves.
 static void
 dmnsn_priority_leaves_recursive(dmnsn_bvh_node **sorted_leaves[DMNSN_PSEUDO_B],
                                 size_t nleaves,
@@ -260,7 +260,7 @@ dmnsn_priority_leaves_recursive(dmnsn_bvh_node **sorted_leaves[DMNSN_PSEUDO_B],
   }
 }
 
-/** Sort each dimension in parallel with more than this many leaves. */
+/// Sort each dimension in parallel with more than this many leaves.
 #define DMNSN_PARALLEL_SORT_THRESHOLD 1024
 
 typedef struct {
@@ -293,7 +293,7 @@ dmnsn_sort_leaves(void *ptr, unsigned int thread, unsigned int nthreads)
   return 0;
 }
 
-/** Constructs an implicit pseudo-PR-tree and returns the priority leaves. */
+/// Constructs an implicit pseudo-PR-tree and returns the priority leaves.
 static dmnsn_array *
 dmnsn_priority_leaves(const dmnsn_array *leaves, unsigned int nthreads)
 {
@@ -337,11 +337,11 @@ dmnsn_new_prtree(const dmnsn_array *objects)
     return NULL;
   }
 
-  /* Make the initial array of leaves */
+  // Make the initial array of leaves
   dmnsn_array *leaves = DMNSN_NEW_ARRAY(dmnsn_bvh_node *);
   DMNSN_ARRAY_FOREACH (dmnsn_object **, object, objects) {
     dmnsn_bvh_node *node = dmnsn_new_bvh_leaf_node(*object);
-    node->data = DMNSN_PRTREE_LEFT; /* Mustn't be _LEAF */
+    node->data = DMNSN_PRTREE_LEFT; // Mustn't be _LEAF
     dmnsn_array_push(leaves, &node);
   }
 
diff --git a/libdimension/prtree.h b/libdimension/prtree.h
index 0a8224a..76a4051 100644
--- a/libdimension/prtree.h
+++ b/libdimension/prtree.h
@@ -26,5 +26,5 @@
  * from B-trees.
  */
 
-/** Create a PR-tree. */
+/// Create a PR-tree.
 DMNSN_INTERNAL dmnsn_bvh_node *dmnsn_new_prtree(const dmnsn_array *objects);
diff --git a/libdimension/ray_trace.c b/libdimension/ray_trace.c
index d7383e4..6f4ce33 100644
--- a/libdimension/ray_trace.c
+++ b/libdimension/ray_trace.c
@@ -26,18 +26,18 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
-/*
- * Boilerplate for multithreading
- */
+////////////////////////////////////
+// Boilerplate for multithreading //
+////////////////////////////////////
 
-/** Payload type for passing arguments to worker threads. */
+/// Payload type for passing arguments to worker threads.
 typedef struct {
   dmnsn_future *future;
   dmnsn_scene *scene;
   dmnsn_bvh *bvh;
 } dmnsn_ray_trace_payload;
 
-/* Ray-trace a scene */
+// Ray-trace a scene
 void
 dmnsn_ray_trace(dmnsn_scene *scene)
 {
@@ -47,10 +47,10 @@ dmnsn_ray_trace(dmnsn_scene *scene)
   }
 }
 
-/** Background thread callback. */
+/// Background thread callback.
 static int dmnsn_ray_trace_scene_thread(void *ptr);
 
-/* Ray-trace a scene in the background */
+// Ray-trace a scene in the background
 dmnsn_future *
 dmnsn_ray_trace_async(dmnsn_scene *scene)
 {
@@ -65,28 +65,28 @@ dmnsn_ray_trace_async(dmnsn_scene *scene)
   return future;
 }
 
-/** Worker thread callback. */
+/// Worker thread callback.
 static int dmnsn_ray_trace_scene_concurrent(void *ptr, unsigned int thread,
                                             unsigned int nthreads);
 
-/* Thread callback -- set up the multithreaded engine */
+// Thread callback -- set up the multithreaded engine
 static int
 dmnsn_ray_trace_scene_thread(void *ptr)
 {
   dmnsn_ray_trace_payload *payload = ptr;
 
-  /* Pre-calculate bounding box transformations, etc. */
+  // Pre-calculate bounding box transformations, etc.
   dmnsn_scene_initialize(payload->scene);
 
-  /* Time the bounding tree construction */
+  // Time the bounding tree construction
   dmnsn_timer_start(&payload->scene->bounding_timer);
     payload->bvh = dmnsn_new_bvh(payload->scene->objects, DMNSN_BVH_PRTREE);
   dmnsn_timer_stop(&payload->scene->bounding_timer);
 
-  /* Set up the future object */
+  // Set up the future object
   dmnsn_future_set_total(payload->future, payload->scene->canvas->height);
 
-  /* Time the render itself */
+  // Time the render itself
   dmnsn_timer_start(&payload->scene->render_timer);
     int ret = dmnsn_execute_concurrently(payload->future,
                                          dmnsn_ray_trace_scene_concurrent,
@@ -99,11 +99,11 @@ dmnsn_ray_trace_scene_thread(void *ptr)
   return ret;
 }
 
-/*
- * Ray-tracing algorithm
- */
+///////////////////////////
+// Ray-tracing algorithm //
+///////////////////////////
 
-/** The current state of the ray-tracing engine. */
+/// The current state of the ray-tracing engine.
 typedef struct dmnsn_rtstate {
   const struct dmnsn_rtstate *parent;
 
@@ -131,14 +131,14 @@ typedef struct dmnsn_rtstate {
   dmnsn_color adc_value;
 } dmnsn_rtstate;
 
-/** Compute a ray-tracing state from an intersection. */
+/// Compute a ray-tracing state from an intersection.
 static inline void
 dmnsn_rtstate_initialize(dmnsn_rtstate *state,
                          const dmnsn_intersection *intersection);
-/** Main helper for dmnsn_ray_trace_scene_concurrent - shoot a ray. */
+/// Main helper for dmnsn_ray_trace_scene_concurrent - shoot a ray.
 static dmnsn_tcolor dmnsn_ray_shoot(dmnsn_rtstate *state, dmnsn_line ray);
 
-/* Actually ray-trace a scene */
+// Actually ray-trace a scene
 static int
 dmnsn_ray_trace_scene_concurrent(void *ptr, unsigned int thread,
                                  unsigned int nthreads)
@@ -154,17 +154,17 @@ dmnsn_ray_trace_scene_concurrent(void *ptr, unsigned int thread,
     .bvh = bvh,
   };
 
-  /* Iterate through each pixel */
+  // Iterate through each pixel
   for (size_t y = thread; y < scene->canvas->height; y += nthreads) {
     for (size_t x = 0; x < scene->canvas->width; ++x) {
-      /* Get the ray corresponding to the (x,y)'th pixel */
+      // Get the ray corresponding to the (x,y)'th pixel
       dmnsn_line ray = dmnsn_camera_ray(
         scene->camera,
         ((double)(x + scene->region_x))/(scene->outer_width - 1),
         ((double)(y + scene->region_y))/(scene->outer_height - 1)
       );
 
-      /* Shoot a ray */
+      // Shoot a ray
       state.reclevel = scene->reclimit;
       state.ior = 1.0;
       state.adc_value = dmnsn_white;
@@ -178,7 +178,7 @@ dmnsn_ray_trace_scene_concurrent(void *ptr, unsigned int thread,
   return 0;
 }
 
-/* Compute rtstate fields */
+// Compute rtstate fields
 static inline void
 dmnsn_rtstate_initialize(dmnsn_rtstate *state,
                          const dmnsn_intersection *intersection)
@@ -205,18 +205,18 @@ dmnsn_rtstate_initialize(dmnsn_rtstate *state,
   state->is_shadow_ray = false;
 }
 
-/** Calculate the background color. */
+/// Calculate the background color.
 static void dmnsn_trace_background(dmnsn_rtstate *state, dmnsn_line ray);
-/** Calculate the base pigment at the intersection. */
+/// Calculate the base pigment at the intersection.
 static void dmnsn_trace_pigment(dmnsn_rtstate *state);
-/** Handle light, shadow, and shading. */
+/// Handle light, shadow, and shading.
 static void dmnsn_trace_lighting(dmnsn_rtstate *state);
-/** Trace a reflected ray. */
+/// Trace a reflected ray.
 static void dmnsn_trace_reflection(dmnsn_rtstate *state);
-/** Trace a transmitted ray. */
+/// Trace a transmitted ray.
 static void dmnsn_trace_transparency(dmnsn_rtstate *state);
 
-/* Shoot a ray, and calculate the color */
+// Shoot a ray, and calculate the color
 static dmnsn_tcolor
 dmnsn_ray_shoot(dmnsn_rtstate *state, dmnsn_line ray)
 {
@@ -232,7 +232,7 @@ dmnsn_ray_shoot(dmnsn_rtstate *state, dmnsn_line ray)
   bool reset = state->reclevel == state->scene->reclimit - 1;
   dmnsn_bvh_intersection(state->bvh, ray, &intersection, reset);
   if (dmnsn_bvh_intersection(state->bvh, ray, &intersection, reset)) {
-    /* Found an intersection */
+    // Found an intersection
     dmnsn_rtstate_initialize(state, &intersection);
 
     dmnsn_trace_pigment(state);
@@ -246,7 +246,7 @@ dmnsn_ray_shoot(dmnsn_rtstate *state, dmnsn_line ray)
       dmnsn_trace_transparency(state);
     }
   } else {
-    /* No intersection, return the background color */
+    // No intersection, return the background color
     dmnsn_trace_background(state, ray);
   }
 
@@ -277,7 +277,7 @@ dmnsn_trace_pigment(dmnsn_rtstate *state)
   state->color = state->pigment;
 }
 
-/** Determine the amount of specular highlight. */
+/// Determine the amount of specular highlight.
 static inline dmnsn_color
 dmnsn_evaluate_specular(const dmnsn_rtstate *state)
 {
@@ -292,7 +292,7 @@ dmnsn_evaluate_specular(const dmnsn_rtstate *state)
   }
 }
 
-/** Determine the amount of reflected light. */
+/// Determine the amount of reflected light.
 static inline dmnsn_color
 dmnsn_evaluate_reflection(const dmnsn_rtstate *state,
                           dmnsn_color light, dmnsn_vector direction)
@@ -308,7 +308,7 @@ dmnsn_evaluate_reflection(const dmnsn_rtstate *state,
   }
 }
 
-/** Determine the amount of transmitted light. */
+/// Determine the amount of transmitted light.
 static inline dmnsn_color
 dmnsn_evaluate_transparency(const dmnsn_rtstate *state, dmnsn_color light)
 {
@@ -321,7 +321,7 @@ dmnsn_evaluate_transparency(const dmnsn_rtstate *state, dmnsn_color light)
   }
 }
 
-/** Get a light's diffuse contribution to the object */
+/// Get a light's diffuse contribution to the object
 static inline dmnsn_color
 dmnsn_evaluate_diffuse(const dmnsn_rtstate *state)
 {
@@ -336,7 +336,7 @@ dmnsn_evaluate_diffuse(const dmnsn_rtstate *state)
   }
 }
 
-/** Get the color of a light ray at an intersection point. */
+/// Get the color of a light ray at an intersection point.
 static bool
 dmnsn_trace_light_ray(dmnsn_rtstate *state, const dmnsn_light *light)
 {
@@ -344,10 +344,10 @@ dmnsn_trace_light_ray(dmnsn_rtstate *state, const dmnsn_light *light)
     state->r,
     light->direction_fn(light, state->r)
   );
-  /* Add epsilon to avoid hitting ourselves with the shadow ray */
+  // Add epsilon to avoid hitting ourselves with the shadow ray
   shadow_ray = dmnsn_line_add_epsilon(shadow_ray);
 
-  /* Check if we're casting a shadow on ourself */
+  // Check if we're casting a shadow on ourself
   if ((dmnsn_vector_dot(shadow_ray.n, state->intersection->normal)
        * dmnsn_vector_dot(state->viewer, state->intersection->normal) < 0.0)
       && (!state->is_shadow_ray || state->pigment.T < dmnsn_epsilon))
@@ -358,7 +358,7 @@ dmnsn_trace_light_ray(dmnsn_rtstate *state, const dmnsn_light *light)
   state->light_ray = dmnsn_vector_normalized(shadow_ray.n);
   state->light_color = light->illumination_fn(light, state->r);
 
-  /* Test for shadow ray intersections */
+  // Test for shadow ray intersections
   dmnsn_intersection shadow_caster;
   bool in_shadow = dmnsn_bvh_intersection(state->bvh, shadow_ray,
                                           &shadow_caster, false);
@@ -382,13 +382,13 @@ dmnsn_trace_light_ray(dmnsn_rtstate *state, const dmnsn_light *light)
       if (dmnsn_trace_light_ray(&shadow_state, light)) {
         state->light_color = shadow_state.light_color;
 
-        /* Handle reflection */
+        // Handle reflection
         dmnsn_color reflected = dmnsn_evaluate_reflection(
           &shadow_state, state->light_color, state->light_ray
         );
         state->light_color = dmnsn_color_sub(state->light_color, reflected);
 
-        /* Handle transparency */
+        // Handle transparency
         state->light_color = dmnsn_evaluate_transparency(
           &shadow_state, state->light_color
         );
@@ -404,13 +404,13 @@ dmnsn_trace_light_ray(dmnsn_rtstate *state, const dmnsn_light *light)
 static void
 dmnsn_trace_lighting(dmnsn_rtstate *state)
 {
-  /* Calculate the ambient color */
+  // Calculate the ambient color
   state->color = DMNSN_TCOLOR(dmnsn_black);
   const dmnsn_finish *finish = &state->texture->finish;
   if (finish->ambient) {
     dmnsn_color ambient = finish->ambient->ambient;
 
-    /* Handle reflection and transmittance of the ambient light */
+    // Handle reflection and transmittance of the ambient light
     dmnsn_color reflected = dmnsn_evaluate_reflection(
       state, ambient, state->intersection->normal
     );
@@ -421,7 +421,7 @@ dmnsn_trace_lighting(dmnsn_rtstate *state)
     state->color.c = dmnsn_color_illuminate(ambient, state->pigment.c);
   }
 
-  /* Iterate over each light */
+  // Iterate over each light
   DMNSN_ARRAY_FOREACH (dmnsn_light **, light, state->scene->lights) {
     if (dmnsn_trace_light_ray(state, *light)) {
       if (state->scene->quality & DMNSN_RENDER_FINISH) {
@@ -460,12 +460,12 @@ dmnsn_trace_reflection(dmnsn_rtstate *state)
 
     dmnsn_rtstate recursive_state = *state;
 
-    /* Calculate ADC value */
+    // Calculate ADC value
     recursive_state.adc_value = dmnsn_evaluate_reflection(
       state, state->adc_value, state->reflected
     );
 
-    /* Shoot the reflected ray */
+    // Shoot the reflected ray
     dmnsn_color rec = dmnsn_ray_shoot(&recursive_state, refl_ray).c;
     dmnsn_color reflected = dmnsn_evaluate_reflection(
       state, rec, state->reflected
@@ -489,23 +489,23 @@ dmnsn_trace_transparency(dmnsn_rtstate *state)
 
     dmnsn_rtstate recursive_state = *state;
 
-    /* Calculate new refractive index */
+    // Calculate new refractive index
     if (dmnsn_vector_dot(r, n) < 0.0) {
-      /* We are entering an object */
+      // We are entering an object
       recursive_state.ior = interior->ior;
       recursive_state.parent = state;
     } else {
-      /* We are leaving an object */
+      // We are leaving an object
       recursive_state.ior = state->parent ? state->parent->ior : 1.0;
       recursive_state.parent = state->parent ? state->parent->parent : NULL;
     }
 
-    /* Calculate transmitted ray direction */
-    double iorr = state->ior/recursive_state.ior; /* ior ratio */
+    // Calculate transmitted ray direction
+    double iorr = state->ior/recursive_state.ior; // ior ratio
     double c1 = -dmnsn_vector_dot(r, n);
     double c2 = 1.0 - iorr*iorr*(1.0 - c1*c1);
     if (c2 <= 0.0) {
-      /* Total internal reflection */
+      // Total internal reflection
       return;
     }
     c2 = sqrt(c2);
@@ -521,7 +521,7 @@ dmnsn_trace_transparency(dmnsn_rtstate *state)
       );
     }
 
-    /* Calculate ADC value */
+    // Calculate ADC value
     recursive_state.adc_value = dmnsn_evaluate_transparency(
       state, state->adc_value
     );
@@ -532,11 +532,11 @@ dmnsn_trace_transparency(dmnsn_rtstate *state)
       recursive_state.adc_value, adc_reflected
     );
 
-    /* Shoot the transmitted ray */
+    // Shoot the transmitted ray
     dmnsn_color rec = dmnsn_ray_shoot(&recursive_state, trans_ray).c;
     dmnsn_color filtered = dmnsn_evaluate_transparency(state, rec);
 
-    /* Conserve energy */
+    // Conserve energy
     dmnsn_color reflected = dmnsn_evaluate_reflection(
       state, filtered, state->reflected
     );
diff --git a/libdimension/reflection.c b/libdimension/reflection.c
index 3b2aeeb..6765bef 100644
--- a/libdimension/reflection.c
+++ b/libdimension/reflection.c
@@ -27,14 +27,14 @@
 #include <math.h>
 #include <stdlib.h>
 
-/** Basic reflective finish type. */
+/// Basic reflective finish type.
 typedef struct dmnsn_basic_reflection {
   dmnsn_reflection reflection;
   dmnsn_color min, max;
   double falloff;
 } dmnsn_basic_reflection;
 
-/** Reflective finish callback. */
+/// Reflective finish callback.
 static dmnsn_color
 dmnsn_basic_reflection_fn(const dmnsn_reflection *reflection,
                           dmnsn_color reflect, dmnsn_color color,
diff --git a/libdimension/rgba.h b/libdimension/rgba.h
index 21d5044..a67caf2 100644
--- a/libdimension/rgba.h
+++ b/libdimension/rgba.h
@@ -23,16 +23,16 @@
  * RGBA canvas optimizer interface, used by image optimizers.
  */
 
-/** Apply the RGBA8 optimizer to a canvas. */
+/// Apply the RGBA8 optimizer to a canvas.
 DMNSN_INTERNAL void dmnsn_rgba8_optimize_canvas(dmnsn_canvas *canvas);
-/** Apply the RGBA16 optimizer to a canvas. */
+/// Apply the RGBA16 optimizer to a canvas.
 DMNSN_INTERNAL void dmnsn_rgba16_optimize_canvas(dmnsn_canvas *canvas);
 
-/** RGBA8 optimizer callback. */
+/// RGBA8 optimizer callback.
 DMNSN_INTERNAL void dmnsn_rgba8_optimizer_fn(const dmnsn_canvas *canvas,
                                              void *ptr,
                                              size_t x, size_t y);
-/** RGBA16 optimizer callback. */
+/// RGBA16 optimizer callback.
 DMNSN_INTERNAL void dmnsn_rgba16_optimizer_fn(const dmnsn_canvas *canvas,
                                               void *ptr,
                                               size_t x, size_t y);
diff --git a/libdimension/scene.c b/libdimension/scene.c
index 18cda80..6c9c495 100644
--- a/libdimension/scene.c
+++ b/libdimension/scene.c
@@ -26,7 +26,7 @@
 #include "dimension-internal.h"
 #include <stdlib.h>
 
-/* Allocate an empty scene */
+// Allocate an empty scene
 dmnsn_scene *
 dmnsn_new_scene(dmnsn_pool *pool)
 {
diff --git a/libdimension/solid_pigment.c b/libdimension/solid_pigment.c
index 1f6cf6f..8c94e1c 100644
--- a/libdimension/solid_pigment.c
+++ b/libdimension/solid_pigment.c
@@ -26,7 +26,7 @@
 #include "dimension.h"
 #include <stdlib.h>
 
-/* Create a solid color */
+// Create a solid color
 dmnsn_pigment *
 dmnsn_new_solid_pigment(dmnsn_pool *pool, dmnsn_tcolor color)
 {
diff --git a/libdimension/sphere.c b/libdimension/sphere.c
index cd791c3..5555499 100644
--- a/libdimension/sphere.c
+++ b/libdimension/sphere.c
@@ -25,12 +25,12 @@
 
 #include "dimension-internal.h"
 
-/** Sphere intersection callback. */
+/// Sphere intersection callback.
 static bool
 dmnsn_sphere_intersection_fn(const dmnsn_object *sphere, dmnsn_line l,
                              dmnsn_intersection *intersection)
 {
-  /* Solve (x0 + nx*t)^2 + (y0 + ny*t)^2 + (z0 + nz*t)^2 == 1 */
+  // Solve (x0 + nx*t)^2 + (y0 + ny*t)^2 + (z0 + nz*t)^2 == 1
   double poly[3], x[2];
   poly[2] = dmnsn_vector_dot(l.n, l.n);
   poly[1] = 2.0*dmnsn_vector_dot(l.n, l.x0);
@@ -42,7 +42,7 @@ dmnsn_sphere_intersection_fn(const dmnsn_object *sphere, dmnsn_line l,
   }
 
   double t = x[0];
-  /* Optimize for the case where we're outside the sphere */
+  // Optimize for the case where we're outside the sphere
   if (dmnsn_likely(n == 2)) {
     t = dmnsn_min(t, x[1]);
   }
@@ -52,23 +52,23 @@ dmnsn_sphere_intersection_fn(const dmnsn_object *sphere, dmnsn_line l,
   return true;
 }
 
-/** Sphere inside callback. */
+/// Sphere inside callback.
 static bool
 dmnsn_sphere_inside_fn(const dmnsn_object *sphere, dmnsn_vector point)
 {
   return point.x*point.x + point.y*point.y + point.z*point.z < 1.0;
 }
 
-/** Sphere bounding callback. */
+/// Sphere bounding callback.
 static dmnsn_bounding_box
 dmnsn_sphere_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
 {
-  /* TODO: tighter bound */
+  // TODO: tighter bound
   dmnsn_bounding_box box = dmnsn_symmetric_bounding_box(dmnsn_new_vector(1.0, 1.0, 1.0));
   return dmnsn_transform_bounding_box(trans, box);
 }
 
-/** Sphere vtable. */
+/// Sphere vtable.
 static const dmnsn_object_vtable dmnsn_sphere_vtable = {
   .intersection_fn = dmnsn_sphere_intersection_fn,
   .inside_fn = dmnsn_sphere_inside_fn,
diff --git a/libdimension/tests/custom-error-fn.c b/libdimension/tests/custom-error-fn.c
index 9e12457..49a0f9e 100644
--- a/libdimension/tests/custom-error-fn.c
+++ b/libdimension/tests/custom-error-fn.c
@@ -17,7 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  *************************************************************************/
 
-/* Make sure that custom fatal error handlers work. */
+// Make sure that custom fatal error handlers work.
 
 #include "dimension.h"
 #include <stdlib.h>
diff --git a/libdimension/tests/cxx.cpp b/libdimension/tests/cxx.cpp
index 7405502..104ee1b 100644
--- a/libdimension/tests/cxx.cpp
+++ b/libdimension/tests/cxx.cpp
@@ -26,10 +26,10 @@
 int
 main(void)
 {
-  /* Treat warnings as errors for tests */
+  // Treat warnings as errors for tests
   dmnsn_die_on_warnings(true);
 
-  /* Make sure we can to bit-ops on this enum type */
+  // Make sure we can to bit-ops on this enum type
   dmnsn_quality quality = DMNSN_RENDER_PIGMENT | DMNSN_RENDER_LIGHTS;
 
   return EXIT_SUCCESS;
diff --git a/libdimension/tests/dictionary.c b/libdimension/tests/dictionary.c
index ca0c6b0..117887a 100644
--- a/libdimension/tests/dictionary.c
+++ b/libdimension/tests/dictionary.c
@@ -86,12 +86,12 @@ DMNSN_TEST(dictionary, insert_overwrites)
   const int value1 = 123, value2 = 456;
   int value_out;
 
-  /* Insert and read back value1 */
+  // Insert and read back value1
   dmnsn_dictionary_insert(dict, "key", &value1);
   ck_assert(dmnsn_dictionary_get(dict, "key", &value_out));
   ck_assert_int_eq(value_out, value1);
 
-  /* Insert and read back value2 */
+  // Insert and read back value2
   dmnsn_dictionary_insert(dict, "key", &value2);
   ck_assert(dmnsn_dictionary_get(dict, "key", &value_out));
   ck_assert_int_eq(value_out, value2);
diff --git a/libdimension/tests/display.c b/libdimension/tests/display.c
index 133eb25..9cd71fe 100644
--- a/libdimension/tests/display.c
+++ b/libdimension/tests/display.c
@@ -31,7 +31,7 @@ struct dmnsn_display {
   XVisualInfo *vi;
 };
 
-/* XIfEvent callback */
+// XIfEvent callback
 static Bool
 WaitForNotify(Display *d, XEvent *e, char *arg)
 {
@@ -60,14 +60,14 @@ dmnsn_new_display(const dmnsn_canvas *canvas)
   display->cx   = NULL;
   display->vi   = NULL;
 
-  /* Get an X connection */
+  // Get an X connection
   display->dpy = XOpenDisplay(0);
   if (!display->dpy) {
     dmnsn_delete_display(display);
     return NULL;
   }
 
-  /* Get an appropriate visual */
+  // Get an appropriate visual
   display->vi = glXChooseVisual(display->dpy, DefaultScreen(display->dpy),
                                 attributeList);
   if (!display->vi) {
@@ -75,14 +75,14 @@ dmnsn_new_display(const dmnsn_canvas *canvas)
     return NULL;
   }
 
-  /* Create a GLX context */
+  // Create a GLX context
   display->cx = glXCreateContext(display->dpy, display->vi, 0, GL_TRUE);
   if (!display->cx) {
     dmnsn_delete_display(display);
     return NULL;
   }
 
-  /* Create a color map */
+  // Create a color map
   display->cmap = XCreateColormap(display->dpy,
                                   RootWindow(display->dpy, display->vi->screen),
                                   display->vi->visual, AllocNone);
@@ -91,7 +91,7 @@ dmnsn_new_display(const dmnsn_canvas *canvas)
     return NULL;
   }
 
-  /* Create a window */
+  // Create a window
   swa.colormap = display->cmap;
   swa.border_pixel = 0;
   swa.event_mask = StructureNotifyMask;
@@ -111,7 +111,7 @@ dmnsn_new_display(const dmnsn_canvas *canvas)
   XMapWindow(display->dpy, display->win);
   XIfEvent(display->dpy, &display->event, WaitForNotify, (char*)display->win);
 
-  /* Connect the context to the window */
+  // Connect the context to the window
   glXMakeCurrent(display->dpy, display->win, display->cx);
   glClearColor(0.0, 0.0, 0.0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT);
diff --git a/libdimension/tests/error.c b/libdimension/tests/error.c
index f4ffcee..58a5b43 100644
--- a/libdimension/tests/error.c
+++ b/libdimension/tests/error.c
@@ -17,7 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  *************************************************************************/
 
-/* Make sure that errors terminate us - this test should fail */
+// Make sure that errors terminate us - this test should fail
 
 #include "dimension.h"
 #include <stdlib.h>
diff --git a/libdimension/tests/gl.c b/libdimension/tests/gl.c
index c46eada..262fecf 100644
--- a/libdimension/tests/gl.c
+++ b/libdimension/tests/gl.c
@@ -23,17 +23,17 @@
 int
 main(void)
 {
-  /* Treat warnings as errors for tests */
+  // Treat warnings as errors for tests
   dmnsn_die_on_warnings(true);
 
-  /* Allocate our canvas */
+  // Allocate our canvas
   dmnsn_pool *pool = dmnsn_new_pool();
   dmnsn_canvas *canvas = dmnsn_new_canvas(pool, 768, 480);
 
-  /* Paint the test pattern */
+  // Paint the test pattern
   dmnsn_paint_test_canvas(canvas);
 
-  /* Create a new glX display */
+  // Create a new glX display
   dmnsn_display *display = dmnsn_new_display(canvas);
   if (!display) {
     fprintf(stderr, "--- WARNING: Couldn't initialize X or glX! ---\n");
@@ -41,7 +41,7 @@ main(void)
     return EXIT_SUCCESS;
   }
 
-  /* Draw to OpenGL */
+  // Draw to OpenGL
   printf("Drawing to OpenGL\n");
   if (dmnsn_gl_write_canvas(canvas) != 0) {
     dmnsn_delete_display(display);
@@ -55,14 +55,14 @@ main(void)
    * Now test GL import/export
    */
 
-  /* Optimize the canvas for GL drawing */
+  // Optimize the canvas for GL drawing
   if (dmnsn_gl_optimize_canvas(canvas) != 0) {
     dmnsn_delete_pool(pool);
     fprintf(stderr, "--- Couldn't optimize canvas for GL! ---\n");
     return EXIT_FAILURE;
   }
 
-  /* Read the image back from OpenGL */
+  // Read the image back from OpenGL
   printf("Reading from OpenGL\n");
   if (dmnsn_gl_read_canvas(canvas, 0, 0) != 0) {
     dmnsn_delete_display(display);
@@ -71,7 +71,7 @@ main(void)
     return EXIT_FAILURE;
   }
 
-  /* And draw it back */
+  // And draw it back
   printf("Drawing to OpenGL\n");
   if (dmnsn_gl_write_canvas(canvas) != 0) {
     dmnsn_delete_display(display);
diff --git a/libdimension/tests/png.c b/libdimension/tests/png.c
index ed64b39..1feff72 100644
--- a/libdimension/tests/png.c
+++ b/libdimension/tests/png.c
@@ -26,24 +26,24 @@ main(void)
 {
   int ret = EXIT_SUCCESS;
 
-  /* Treat warnings as errors for tests */
+  // Treat warnings as errors for tests
   dmnsn_die_on_warnings(true);
 
-  /* Allocate our canvas */
+  // Allocate our canvas
   dmnsn_pool *pool = dmnsn_new_pool();
   dmnsn_canvas *canvas = dmnsn_new_canvas(pool, 768, 480);
 
-  /* Optimize the canvas for PNG export */
+  // Optimize the canvas for PNG export
   if (dmnsn_png_optimize_canvas(canvas) != 0) {
     fprintf(stderr, "--- Couldn't optimize canvas for PNG! ---\n");
     ret = EXIT_FAILURE;
     goto exit;
   }
 
-  /* Paint the test pattern */
+  // Paint the test pattern
   dmnsn_paint_test_canvas(canvas);
 
-  /* Write the image to PNG */
+  // Write the image to PNG
 
   printf("Writing scene to PNG\n");
   FILE *ofile = fopen("png1.png", "wb");
@@ -66,7 +66,7 @@ main(void)
    * Now test PNG import/export
    */
 
-  /* Read the image back from PNG */
+  // Read the image back from PNG
 
   printf("Reading scene from PNG\n");
   FILE *ifile = fopen("png1.png", "rb");
@@ -86,7 +86,7 @@ main(void)
 
   fclose(ifile);
 
-  /* And write it back */
+  // And write it back
 
   printf("Writing scene to PNG\n");
   ofile = fopen("png2.png", "wb");
diff --git a/libdimension/tests/polynomial.c b/libdimension/tests/polynomial.c
index b734cc2..dc172d4 100644
--- a/libdimension/tests/polynomial.c
+++ b/libdimension/tests/polynomial.c
@@ -69,7 +69,7 @@ dmnsn_assert_roots(const double poly[], size_t degree, size_t nroots_ex, ...)
 
 DMNSN_TEST(linear, no_positive_roots)
 {
-  /* poly[] = x + 1 */
+  // poly[] = x + 1
   static const double poly[] = {
     [1] = 1.0,
     [0] = 1.0,
@@ -79,7 +79,7 @@ DMNSN_TEST(linear, no_positive_roots)
 
 DMNSN_TEST(linear, one_root)
 {
-  /* poly[] = x - 1 */
+  // poly[] = x - 1
   static const double poly[] = {
     [1] =  1.0,
     [0] = -1.0,
@@ -90,7 +90,7 @@ DMNSN_TEST(linear, one_root)
 
 DMNSN_TEST(quadratic, no_roots)
 {
-  /* poly[] = x^2 + 1 */
+  // poly[] = x^2 + 1
   static const double poly[] = {
     [2] = 1.0,
     [1] = 0.0,
@@ -101,7 +101,7 @@ DMNSN_TEST(quadratic, no_roots)
 
 DMNSN_TEST(quadratic, no_positive_roots)
 {
-  /* poly[] = (x + 1)^2 */
+  // poly[] = (x + 1)^2
   static const double poly[] = {
     [2] = 1.0,
     [1] = 2.0,
@@ -112,7 +112,7 @@ DMNSN_TEST(quadratic, no_positive_roots)
 
 DMNSN_TEST(quadratic, one_positive_root)
 {
-  /* poly[] = (x + 1)*(x - 1) */
+  // poly[] = (x + 1)*(x - 1)
   static const double poly[] = {
     [2] =  1.0,
     [1] =  0.0,
@@ -123,7 +123,7 @@ DMNSN_TEST(quadratic, one_positive_root)
 
 DMNSN_TEST(quadratic, two_roots)
 {
-  /* poly[] = (x - 1.2345)*(x - 2.3456) */
+  // poly[] = (x - 1.2345)*(x - 2.3456)
   static const double poly[] = {
     [2] =  1.0,
     [1] = -3.5801,
@@ -135,7 +135,7 @@ DMNSN_TEST(quadratic, two_roots)
 
 DMNSN_TEST(cubic, no_positive_roots)
 {
-  /* poly[] = x^3 + 1 */
+  // poly[] = x^3 + 1
   static const double poly[] = {
     [3] = 1.0,
     [2] = 0.0,
@@ -147,7 +147,7 @@ DMNSN_TEST(cubic, no_positive_roots)
 
 DMNSN_TEST(cubic, one_root)
 {
-  /* poly[] = x^3 - 1 */
+  // poly[] = x^3 - 1
   static const double poly[] = {
     [3] =  1.0,
     [2] =  0.0,
@@ -171,7 +171,7 @@ DMNSN_TEST(cubic, two_roots)
 
 DMNSN_TEST(cubic, three_roots)
 {
-  /* poly[] = (x - 1.2345)*(x - 2.3456)*(x - 100) */
+  // poly[] = (x - 1.2345)*(x - 2.3456)*(x - 100)
   static const double poly[] = {
     [3] =    1.0,
     [2] = -103.5801,
@@ -184,7 +184,7 @@ DMNSN_TEST(cubic, three_roots)
 
 DMNSN_TEST(quintic, four_roots)
 {
-  /* poly[] = 2*(x + 1)*(x - 1.2345)*(x - 2.3456)*(x - 5)*(x - 100) */
+  // poly[] = 2*(x + 1)*(x - 1.2345)*(x - 2.3456)*(x - 5)*(x - 100)
   static const double poly[] = {
     [5] =     2.0,
     [4] =  -215.1602,
@@ -196,7 +196,7 @@ DMNSN_TEST(quintic, four_roots)
   dmnsn_assert_roots(poly, 5, 4, 1.2345, 2.3456, 5.0, 100.0);
 }
 
-/* repeated_root[] = (x - 1)^6 */
+// repeated_root[] = (x - 1)^6
 static const double repeated_root[7] = {
   [6] =   1.0,
   [5] =  -6.0,
diff --git a/libdimension/tests/pool.c b/libdimension/tests/pool.c
index d12850d..83f25f7 100644
--- a/libdimension/tests/pool.c
+++ b/libdimension/tests/pool.c
@@ -46,7 +46,7 @@ DMNSN_TEST(pool, simple)
     *p = i;
   }
 
-  /* Leak checking will tell us if something bad happened */
+  // Leak checking will tell us if something bad happened
 }
 
 static int counter = 0;
diff --git a/libdimension/tests/prtree.c b/libdimension/tests/prtree.c
index fdc5878..3c2b7bf 100644
--- a/libdimension/tests/prtree.c
+++ b/libdimension/tests/prtree.c
@@ -75,7 +75,7 @@ dmnsn_new_fake_object(dmnsn_pool *pool)
 int
 main(void)
 {
-  /* Treat warnings as errors for tests */
+  // Treat warnings as errors for tests
   dmnsn_die_on_warnings(true);
 
   dmnsn_pool *pool = dmnsn_new_pool();
diff --git a/libdimension/tests/render.c b/libdimension/tests/render.c
index 9b830f6..2588937 100644
--- a/libdimension/tests/render.c
+++ b/libdimension/tests/render.c
@@ -25,7 +25,7 @@
 static void
 dmnsn_test_scene_set_defaults(dmnsn_pool *pool, dmnsn_scene *scene)
 {
-  /* Default texture */
+  // Default texture
   scene->default_texture->pigment = dmnsn_new_solid_pigment(pool, DMNSN_TCOLOR(dmnsn_black));
   dmnsn_finish *default_finish = &scene->default_texture->finish;
   default_finish->ambient = dmnsn_new_ambient(
@@ -43,7 +43,7 @@ dmnsn_test_scene_add_canvas(dmnsn_pool *pool, dmnsn_scene *scene)
 static void
 dmnsn_test_scene_add_camera(dmnsn_pool *pool, dmnsn_scene *scene)
 {
-  /* Set up the transformation matrix for the perspective camera */
+  // Set up the transformation matrix for the perspective camera
   dmnsn_matrix trans = dmnsn_scale_matrix(
     dmnsn_new_vector(
       ((double)scene->canvas->width)/scene->canvas->height, 1.0, 1.0
@@ -62,7 +62,7 @@ dmnsn_test_scene_add_camera(dmnsn_pool *pool, dmnsn_scene *scene)
     trans
   );
 
-  /* Create a perspective camera */
+  // Create a perspective camera
   scene->camera = dmnsn_new_perspective_camera(pool);
   scene->camera->trans = trans;
 }
@@ -86,7 +86,7 @@ dmnsn_test_scene_add_background(dmnsn_pool *pool, dmnsn_scene *scene)
       dmnsn_new_vector(0.0, dmnsn_radians(53.0), 0.0)
     );
   } else {
-    /* Loading png2.png failed, possibly compiled with --disable-png */
+    // Loading png2.png failed, possibly compiled with --disable-png
     fprintf(stderr, "--- WARNING: Couldn't open or read png2.png! ---\n");
     png_pigment = dmnsn_new_solid_pigment(pool, DMNSN_TCOLOR(dmnsn_orange));
   }
@@ -306,16 +306,16 @@ main(void)
 {
   int ret = EXIT_FAILURE;
 
-  /* Treat warnings as errors for tests */
+  // Treat warnings as errors for tests
   dmnsn_die_on_warnings(true);
 
   dmnsn_display *display = NULL;
 
-  /* Create the test scene */
+  // Create the test scene
   dmnsn_pool *pool = dmnsn_new_pool();
   dmnsn_scene *scene = dmnsn_new_test_scene(pool);
 
-  /* Optimize the canvas for PNG export */
+  // Optimize the canvas for PNG export
   bool have_png = true;
   errno = 0;
   if (dmnsn_png_optimize_canvas(scene->canvas) != 0) {
@@ -327,7 +327,7 @@ main(void)
     }
   }
 
-  /* Optimize the canvas for GL drawing */
+  // Optimize the canvas for GL drawing
   bool have_gl = true;
   errno = 0;
   if (dmnsn_gl_optimize_canvas(scene->canvas) != 0) {
@@ -341,7 +341,7 @@ main(void)
 
   dmnsn_canvas_clear(scene->canvas, DMNSN_TCOLOR(dmnsn_black));
 
-  /* Create a new glX display */
+  // Create a new glX display
   if (have_gl) {
     display = dmnsn_new_display(scene->canvas);
     if (!display) {
@@ -349,12 +349,12 @@ main(void)
     }
   }
 
-  /* Render the scene */
+  // Render the scene
 
   printf("Rendering scene\n");
   dmnsn_future *future = dmnsn_ray_trace_async(scene);
 
-  /* Display the scene as it's rendered */
+  // Display the scene as it's rendered
   if (display) {
     while (!dmnsn_future_is_done(future)) {
       dmnsn_future_pause(future);
@@ -373,7 +373,7 @@ main(void)
     goto exit;
   }
 
-  /* Make sure we show the completed rendering */
+  // Make sure we show the completed rendering
   if (display) {
     printf("Drawing to OpenGL\n");
     if (dmnsn_gl_write_canvas(scene->canvas) != 0) {
diff --git a/libdimension/tests/tests.h b/libdimension/tests/tests.h
index 0b8bfce..6e9ad21 100644
--- a/libdimension/tests/tests.h
+++ b/libdimension/tests/tests.h
@@ -24,19 +24,19 @@
 #include <check.h>
 
 #ifdef __cplusplus
-/* We've been included from a C++ file; mark everything here as extern "C" */
+// We've been included from a C++ file; mark everything here as extern "C"
 extern "C" {
 #endif
 
-/** @internal Map to known test cases from their names. */
+/// @internal Map to known test cases from their names.
 extern dmnsn_dictionary* dmnsn_test_cases;
 
-/** @internal Get the test case with the given name, possibly creating it. */
+/// @internal Get the test case with the given name, possibly creating it.
 TCase *dmnsn_get_test_case(const char* name);
 
-/** @internal Default test fixture. */
+/// @internal Default test fixture.
 void dmnsn_test_setup(void);
-/** @internal Default test fixture. */
+/// @internal Default test fixture.
 void dmnsn_test_teardown(void);
 
 /**
@@ -121,11 +121,11 @@ typedef struct dmnsn_display dmnsn_display;
 dmnsn_display *dmnsn_new_display(const dmnsn_canvas *canvas);
 void dmnsn_delete_display(dmnsn_display *display);
 
-/* Flush the GL buffers */
+// Flush the GL buffers
 void dmnsn_display_flush(dmnsn_display *display);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* TESTS_H */
+#endif // TESTS_H
diff --git a/libdimension/tests/unit-test.c b/libdimension/tests/unit-test.c
index 2ba3baf..5d3f699 100644
--- a/libdimension/tests/unit-test.c
+++ b/libdimension/tests/unit-test.c
@@ -47,7 +47,7 @@ dmnsn_get_test_case(const char* name)
 void
 dmnsn_test_setup(void)
 {
-  /* Treat warnings as errors for tests */
+  // Treat warnings as errors for tests
   dmnsn_die_on_warnings(true);
 }
 
@@ -89,21 +89,21 @@ dmnsn_test_suite(void)
 int
 main(void)
 {
-  /* Treat warnings as errors for tests */
+  // Treat warnings as errors for tests
   dmnsn_die_on_warnings(true);
 
-  /* Create the test suite */
+  // Create the test suite
   Suite *suite = dmnsn_test_suite();
   SRunner *sr = srunner_create(suite);
 
-  /* Run the tests */
+  // Run the tests
   srunner_run_all(sr, CK_VERBOSE);
   int nfailed = srunner_ntests_failed(sr);
 
-  /* Clean up */
+  // Clean up
   srunner_free(sr);
 
-  /* Return the right result code */
+  // Return the right result code
   if (nfailed == 0) {
     return EXIT_SUCCESS;
   } else {
diff --git a/libdimension/tests/warning-as-error.c b/libdimension/tests/warning-as-error.c
index dfc08d6..7d0fdb7 100644
--- a/libdimension/tests/warning-as-error.c
+++ b/libdimension/tests/warning-as-error.c
@@ -17,7 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  *************************************************************************/
 
-/* Make sure warnings kill us in strict mode - this test should fail */
+// Make sure warnings kill us in strict mode - this test should fail
 
 #include "dimension.h"
 #include <stdlib.h>
diff --git a/libdimension/tests/warning.c b/libdimension/tests/warning.c
index 4e5dd75..cc1aed1 100644
--- a/libdimension/tests/warning.c
+++ b/libdimension/tests/warning.c
@@ -17,7 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  *************************************************************************/
 
-/* Make sure warnings don't kill us - this test should pass */
+// Make sure warnings don't kill us - this test should pass
 
 #include "dimension.h"
 #include <stdlib.h>
diff --git a/libdimension/threads.c b/libdimension/threads.c
index 539a3f9..1fee01d 100644
--- a/libdimension/threads.c
+++ b/libdimension/threads.c
@@ -26,14 +26,14 @@
 #include "dimension-internal.h"
 #include <pthread.h>
 
-/** The payload to pass to the pthread callback. */
+/// The payload to pass to the pthread callback.
 typedef struct dmnsn_thread_payload {
   dmnsn_thread_fn *thread_fn;
   void *arg;
   dmnsn_future *future;
 } dmnsn_thread_payload;
 
-/** Clean up after a thread. */
+/// Clean up after a thread.
 static void
 dmnsn_thread_cleanup(void *arg)
 {
@@ -44,7 +44,7 @@ dmnsn_thread_cleanup(void *arg)
   dmnsn_future_finish(future);
 }
 
-/** pthread callback -- call the real thread callback. */
+/// pthread callback -- call the real thread callback.
 static void *
 dmnsn_thread(void *arg)
 {
@@ -71,7 +71,7 @@ dmnsn_new_thread(dmnsn_future *future, dmnsn_thread_fn *thread_fn, void *arg)
   }
 }
 
-/** Payload for threads executed by dmnsn_execute_concurrently(). */
+/// Payload for threads executed by dmnsn_execute_concurrently().
 typedef struct dmnsn_ccthread_payload {
   dmnsn_future *future;
   dmnsn_ccthread_fn *ccthread_fn;
@@ -177,7 +177,7 @@ dmnsn_execute_concurrently(dmnsn_future *future, dmnsn_ccthread_fn *ccthread_fn,
   return ret;
 }
 
-/* pthread wrappers */
+// pthread wrappers
 
 void
 dmnsn_initialize_mutex(pthread_mutex_t *mutex)
diff --git a/libdimension/threads.h b/libdimension/threads.h
index 57e52aa..839299e 100644
--- a/libdimension/threads.h
+++ b/libdimension/threads.h
@@ -70,9 +70,9 @@ DMNSN_INTERNAL int dmnsn_execute_concurrently(dmnsn_future *future,
  */
 DMNSN_INTERNAL void dmnsn_initialize_mutex(pthread_mutex_t *mutex);
 
-/** dmnsn_lock_mutex() implementation. */
+/// dmnsn_lock_mutex() implementation.
 DMNSN_INTERNAL void dmnsn_lock_mutex_impl(pthread_mutex_t *mutex);
-/** dmnsn_unlock_mutex() implementation. */
+/// dmnsn_unlock_mutex() implementation.
 DMNSN_INTERNAL void dmnsn_unlock_mutex_impl(void *mutex);
 
 /**
@@ -101,11 +101,11 @@ DMNSN_INTERNAL void dmnsn_destroy_mutex(pthread_mutex_t *mutex);
  */
 DMNSN_INTERNAL void dmnsn_initialize_rwlock(pthread_rwlock_t *rwlock);
 
-/** dmnsn_read_lock() implementation. */
+/// dmnsn_read_lock() implementation.
 DMNSN_INTERNAL void dmnsn_read_lock_impl(pthread_rwlock_t *rwlock);
-/** dmnsn_write_lock() implementation. */
+/// dmnsn_write_lock() implementation.
 DMNSN_INTERNAL void dmnsn_write_lock_impl(pthread_rwlock_t *rwlock);
-/** dmnsn_unlock_rwlock() implementation. */
+/// dmnsn_unlock_rwlock() implementation.
 DMNSN_INTERNAL void dmnsn_unlock_rwlock_impl(pthread_rwlock_t *rwlock);
 
 /**
diff --git a/libdimension/torus.c b/libdimension/torus.c
index 2b7a818..30acbd8 100644
--- a/libdimension/torus.c
+++ b/libdimension/torus.c
@@ -25,13 +25,13 @@
 
 #include "dimension.h"
 
-/** Torus type. */
+/// Torus type.
 typedef struct {
   dmnsn_object object;
   double major, minor;
 } dmnsn_torus;
 
-/** Bound the torus in a cylindrical shell. */
+/// Bound the torus in a cylindrical shell.
 static inline bool
 dmnsn_torus_bound_intersection(const dmnsn_torus *torus, dmnsn_line l)
 {
@@ -39,7 +39,7 @@ dmnsn_torus_bound_intersection(const dmnsn_torus *torus, dmnsn_line l)
   double rmax = R + r, rmin = R - r;
   double rmax2 = rmax*rmax, rmin2 = rmin*rmin;
 
-  /* Try the caps first */
+  // Try the caps first
   double tlower = (-r - l.x0.y)/l.n.y;
   double tupper = (+r - l.x0.y)/l.n.y;
   dmnsn_vector lower = dmnsn_line_point(l, tlower);
@@ -47,7 +47,7 @@ dmnsn_torus_bound_intersection(const dmnsn_torus *torus, dmnsn_line l)
   double ldist2 = lower.x*lower.x + lower.z*lower.z;
   double udist2 = upper.x*upper.x + upper.z*upper.z;
   if ((ldist2 < rmin2 || ldist2 > rmax2) && (udist2 < rmin2 || udist2 > rmax2)) {
-    /* No valid intersection with the caps, try the cylinder walls */
+    // No valid intersection with the caps, try the cylinder walls
     double dist2 = l.x0.x*l.x0.x + l.x0.z*l.x0.z;
     double bigcyl[3], smallcyl[3];
     bigcyl[2]   = smallcyl[2] = l.n.x*l.n.x + l.n.z*l.n.z;
@@ -67,7 +67,7 @@ dmnsn_torus_bound_intersection(const dmnsn_torus *torus, dmnsn_line l)
     }
 
     if (i == n) {
-      /* No valid intersection found */
+      // No valid intersection found
       return false;
     }
   }
@@ -75,7 +75,7 @@ dmnsn_torus_bound_intersection(const dmnsn_torus *torus, dmnsn_line l)
   return true;
 }
 
-/** Torus intersection callback. */
+/// Torus intersection callback.
 static bool
 dmnsn_torus_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                             dmnsn_intersection *intersection)
@@ -88,7 +88,7 @@ dmnsn_torus_intersection_fn(const dmnsn_object *object, dmnsn_line l,
     return false;
   }
 
-  /* This bit of algebra here is correct */
+  // This bit of algebra here is correct
   dmnsn_vector x0mod = dmnsn_new_vector(l.x0.x, -l.x0.y, l.x0.z);
   dmnsn_vector nmod  = dmnsn_new_vector(l.n.x,  -l.n.y,  l.n.z);
   double nn      = dmnsn_vector_dot(l.n, l.n);
@@ -131,7 +131,7 @@ dmnsn_torus_intersection_fn(const dmnsn_object *object, dmnsn_line l,
   return true;
 }
 
-/** Torus inside callback. */
+/// Torus inside callback.
 static bool
 dmnsn_torus_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
@@ -140,7 +140,7 @@ dmnsn_torus_inside_fn(const dmnsn_object *object, dmnsn_vector point)
   return dmajor*dmajor + point.y*point.y < torus->minor*torus->minor;
 }
 
-/** Torus bounding callback. */
+/// Torus bounding callback.
 static dmnsn_bounding_box
 dmnsn_torus_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
 {
@@ -151,7 +151,7 @@ dmnsn_torus_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
   return dmnsn_transform_bounding_box(trans, box);
 }
 
-/** Torus vtable. */
+/// Torus vtable.
 static const dmnsn_object_vtable dmnsn_torus_vtable = {
   .intersection_fn = dmnsn_torus_intersection_fn,
   .inside_fn = dmnsn_torus_inside_fn,
diff --git a/libdimension/triangle.c b/libdimension/triangle.c
index 6025caa..4a70c59 100644
--- a/libdimension/triangle.c
+++ b/libdimension/triangle.c
@@ -27,18 +27,18 @@
 
 #include "dimension.h"
 
-/** Optimized ray/triangle intersection test. */
+/// Optimized ray/triangle intersection test.
 static inline bool
 dmnsn_ray_triangle_intersection(dmnsn_line l, double *t, double *u, double *v)
 {
-  /* See the change of basis in dmnsn_triangle_basis() */
+  // See the change of basis in dmnsn_triangle_basis()
   *t = -l.x0.z/l.n.z;
   *u = l.x0.x + (*t)*l.n.x;
   *v = l.x0.y + (*t)*l.n.y;
   return *t >= 0.0 && *u >= 0.0 && *v >= 0.0 && *u + *v <= 1.0;
 }
 
-/** Triangle intersection callback. */
+/// Triangle intersection callback.
 static bool
 dmnsn_triangle_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                                dmnsn_intersection *intersection)
@@ -53,14 +53,14 @@ dmnsn_triangle_intersection_fn(const dmnsn_object *object, dmnsn_line l,
   return false;
 }
 
-/** Triangle inside callback. */
+/// Triangle inside callback.
 static bool
 dmnsn_triangle_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
   return false;
 }
 
-/** Triangle bounding callback. */
+/// Triangle bounding callback.
 static dmnsn_bounding_box
 dmnsn_triangle_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
 {
@@ -74,20 +74,20 @@ dmnsn_triangle_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
   return box;
 }
 
-/** Triangle vtable. */
+/// Triangle vtable.
 static const dmnsn_object_vtable dmnsn_triangle_vtable = {
   .intersection_fn = dmnsn_triangle_intersection_fn,
   .inside_fn = dmnsn_triangle_inside_fn,
   .bounding_fn = dmnsn_triangle_bounding_fn,
 };
 
-/** Smooth triangle type. */
+/// Smooth triangle type.
 typedef struct {
   dmnsn_object object;
   dmnsn_vector na, nab, nac;
 } dmnsn_smooth_triangle;
 
-/** Smooth triangle intersection callback. */
+/// Smooth triangle intersection callback.
 static bool
 dmnsn_smooth_triangle_intersection_fn(const dmnsn_object *object, dmnsn_line l,
                                       dmnsn_intersection *intersection)
@@ -110,21 +110,19 @@ dmnsn_smooth_triangle_intersection_fn(const dmnsn_object *object, dmnsn_line l,
   return false;
 }
 
-/** Smooth triangle vtable. */
+/// Smooth triangle vtable.
 static const dmnsn_object_vtable dmnsn_smooth_triangle_vtable = {
   .intersection_fn = dmnsn_smooth_triangle_intersection_fn,
   .inside_fn = dmnsn_triangle_inside_fn,
   .bounding_fn = dmnsn_triangle_bounding_fn,
 };
 
-/** Make a change-of-basis matrix. */
+/// Make a change-of-basis matrix.
 static inline dmnsn_matrix
 dmnsn_triangle_basis(dmnsn_vector vertices[3])
 {
-  /*
-   * The new vector space has corners at <1, 0, 0>, <0, 1, 0>, and 0,
-   * corresponding to the basis (ab, ac, ab X ac).
-   */
+  // The new vector space has corners at <1, 0, 0>, <0, 1, 0>, and 0,
+  // corresponding to the basis (ab, ac, ab X ac).
   dmnsn_vector ab = dmnsn_vector_sub(vertices[1], vertices[0]);
   dmnsn_vector ac = dmnsn_vector_sub(vertices[2], vertices[0]);
   dmnsn_vector normal = dmnsn_vector_cross(ab, ac);
@@ -145,7 +143,7 @@ dmnsn_new_smooth_triangle(dmnsn_pool *pool, dmnsn_vector vertices[3], dmnsn_vect
 {
   dmnsn_matrix P = dmnsn_triangle_basis(vertices);
 
-  /* Transform the given normals. */
+  // Transform the given normals.
   dmnsn_vector na = dmnsn_vector_normalized(dmnsn_transform_normal(P, normals[0]));
   dmnsn_vector nb = dmnsn_vector_normalized(dmnsn_transform_normal(P, normals[1]));
   dmnsn_vector nc = dmnsn_vector_normalized(dmnsn_transform_normal(P, normals[2]));
diff --git a/libdimension/triangle_fan.c b/libdimension/triangle_fan.c
index fe974df..0165a51 100644
--- a/libdimension/triangle_fan.c
+++ b/libdimension/triangle_fan.c
@@ -27,14 +27,14 @@
 
 #include "dimension.h"
 
-/** Triangle fan type. */
+/// Triangle fan type.
 typedef struct {
   dmnsn_object object;
   size_t ncoeffs;
   double coeffs[][6];
 } dmnsn_triangle_fan;
 
-/** Change basis from one triangle to the next. */
+/// Change basis from one triangle to the next.
 static inline dmnsn_vector
 dmnsn_change_basis(const double coeffs[6], dmnsn_vector v)
 {
@@ -45,7 +45,7 @@ dmnsn_change_basis(const double coeffs[6], dmnsn_vector v)
   );
 }
 
-/** Change basis from one triangle to the next for a normal vector. */
+/// Change basis from one triangle to the next for a normal vector.
 static inline dmnsn_vector
 dmnsn_change_normal_basis(const double coeffs[6], dmnsn_vector n)
 {
@@ -56,7 +56,7 @@ dmnsn_change_normal_basis(const double coeffs[6], dmnsn_vector n)
   );
 }
 
-/** Triangle intersection callback. */
+/// Triangle intersection callback.
 static bool
 dmnsn_triangle_fan_intersection_fn(const dmnsn_object *object, dmnsn_line l, dmnsn_intersection *intersection)
 {
@@ -98,14 +98,14 @@ dmnsn_triangle_fan_intersection_fn(const dmnsn_object *object, dmnsn_line l, dmn
   return false;
 }
 
-/** Triangle fan inside callback. */
+/// Triangle fan inside callback.
 static bool
 dmnsn_triangle_fan_inside_fn(const dmnsn_object *object, dmnsn_vector point)
 {
   return false;
 }
 
-/** Triangle fan bounding callback. */
+/// Triangle fan bounding callback.
 static dmnsn_bounding_box
 dmnsn_triangle_fan_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
 {
@@ -134,7 +134,7 @@ dmnsn_triangle_fan_bounding_fn(const dmnsn_object *object, dmnsn_matrix trans)
   return box;
 }
 
-/** Triangle fan vtable. */
+/// Triangle fan vtable.
 static dmnsn_object_vtable dmnsn_triangle_fan_vtable = {
   .intersection_fn = dmnsn_triangle_fan_intersection_fn,
   .inside_fn = dmnsn_triangle_fan_inside_fn,
@@ -154,7 +154,7 @@ dmnsn_new_triangle_fan(dmnsn_pool *pool, dmnsn_vector vertices[], size_t nvertic
   dmnsn_init_object(object);
   object->vtable = &dmnsn_triangle_fan_vtable;
 
-  /* Compute the initial matrix and the coefficients */
+  // Compute the initial matrix and the coefficients
   dmnsn_vector a = vertices[0];
   dmnsn_vector ab = dmnsn_vector_sub(vertices[1], a);
   dmnsn_vector ac = dmnsn_vector_sub(vertices[2], a);