diff --git a/astronomy/date_time.hpp b/astronomy/date_time.hpp
index bbea485560..bd924d1400 100644
--- a/astronomy/date_time.hpp
+++ b/astronomy/date_time.hpp
@@ -23,12 +23,12 @@ namespace internal {
 class Date final {
  public:
   // The calendar is Gregorian by default starting in 1583; before that,
-  // |calendar| is required.
+  // `calendar` is required.
   static constexpr Date YYYYMMDD(
       std::int64_t digits,
       std::optional<Calendar> calendar = std::nullopt);
   // The calendar is Gregorian by default starting in 1583; before that,
-  // |calendar| is required.
+  // `calendar` is required.
   static constexpr Date YYYYDDD(
       std::int64_t digits,
       std::optional<Calendar> calendar = std::nullopt);
@@ -37,12 +37,12 @@ class Date final {
   static constexpr Date YYYYwwD(std::int64_t digits);
 
   // The calendar is Gregorian by default starting in 1583; before that,
-  // |calendar| is required.
+  // `calendar` is required.
   static constexpr Date Calendar(
       int year, int month, int day,
       std::optional<Calendar> calendar = std::nullopt);
   // The calendar is Gregorian by default starting in 1583; before that,
-  // |calendar| is required.
+  // `calendar` is required.
   static constexpr Date Ordinal(
       int year, int day,
       std::optional<_date_time::Calendar> calendar = std::nullopt);
@@ -50,8 +50,8 @@ class Date final {
   // at least 1583, and the calendar is Gregorian.
   static constexpr Date Week(int year, int week, int day);
 
-  // The julian date |jd| must not be negative; its fractional part must be one
-  // half, corresponding to 00:00 on the resulting |Date|.
+  // The julian date `jd` must not be negative; its fractional part must be one
+  // half, corresponding to 00:00 on the resulting `Date`.
   static constexpr Date JD(double jd);
 
   constexpr int year() const;
@@ -61,7 +61,7 @@ class Date final {
 
   constexpr int ordinal() const;
 
-  // The fractional part of |jd()| is one half, corresponding to 00:00 on the
+  // The fractional part of `jd()` is one half, corresponding to 00:00 on the
   // day represented by this object.
   constexpr double jd() const;
   constexpr int mjd() const;
@@ -93,7 +93,7 @@ class TimeOfDay final {
   constexpr int millisecond() const;
 
   constexpr bool is_leap_second() const;
-  // Whether |*this| is 24:00:00.
+  // Whether `*this` is 24:00:00.
   constexpr bool is_end_of_day() const;
 
  private:
@@ -107,7 +107,7 @@ class TimeOfDay final {
 
 class DateTime final {
  public:
-  // Checks that |time| does not represent a leap second unless |date| is the
+  // Checks that `time` does not represent a leap second unless `date` is the
   // last day of the month.
   constexpr DateTime(Date date, TimeOfDay time);
 
@@ -116,8 +116,8 @@ class DateTime final {
   constexpr Date const& date() const;
   constexpr TimeOfDay const& time() const;
 
-  // If |time()| is 24:00:00, returns an equivalent DateTime where midnight is
-  // expressed as 00:00:00 on the next day; otherwise, returns |*this|.
+  // If `time()` is 24:00:00, returns an equivalent DateTime where midnight is
+  // expressed as 00:00:00 on the next day; otherwise, returns `*this`.
   constexpr DateTime normalized_end_of_day() const;
 
  private:
@@ -146,7 +146,7 @@ class JulianDate final {
                        std::int64_t fraction_numerator,
                        std::int64_t fraction_denominator);
 
-  // These numbers are relative to J2000.  |fraction_denominator| is a positive
+  // These numbers are relative to J2000.  `fraction_denominator` is a positive
   // power of 10.
   std::int64_t const day_;
   std::int64_t const fraction_numerator_;
diff --git a/astronomy/date_time_body.hpp b/astronomy/date_time_body.hpp
index e65658e308..e726c3c883 100644
--- a/astronomy/date_time_body.hpp
+++ b/astronomy/date_time_body.hpp
@@ -56,17 +56,17 @@ constexpr int number_of_iso_weeks_in_year(int const year) {
              : 52;
 }
 
-// Returns the ordinal in |year| of the first day of the first week of |year|.
+// Returns the ordinal in `year` of the first day of the first week of `year`.
 // The result is in [-2, 4], with values in [-2, 0] meaning that the first week
-// of |year| starts in |year - 1|.
-// A result in [-2, 1] means that the first day of |year| is in the first week
-// of |year|; otherwise, it is in the last week of |year - 1|.
+// of `year` starts in `year - 1`.
+// A result in [-2, 1] means that the first day of `year` is in the first week
+// of `year`; otherwise, it is in the last week of `year - 1`.
 constexpr int ordinal_of_w_01_1(int const year) {
   return mod(2 - day_of_week_on_january_1st(year), 7, -2);
 }
 
-// Returns the number formed by taking |end - begin| increasingly significant
-// digits, starting from the digit of the (10 ** |begin|)s.
+// Returns the number formed by taking `end - begin` increasingly significant
+// digits, starting from the digit of the (10 ** `begin`)s.
 constexpr std::int64_t digit_range(std::int64_t const digits,
                                    int const begin,
                                    int const end) {
@@ -94,7 +94,7 @@ constexpr std::int64_t shift_right(std::int64_t const x, int const count) {
   return count == 0 ? x : shift_right(x / 10, count - 1);
 }
 
-// Implementation of class |Date|.
+// Implementation of class `Date`.
 
 constexpr Date Date::YYYYMMDD(
     std::int64_t const digits,
@@ -466,12 +466,12 @@ constexpr CStringIterator::CStringIterator(char const* const str,
 
 // Date parsing.
 
-// A |DateParser| contains information about a string necessary to interpret it
+// A `DateParser` contains information about a string necessary to interpret it
 // as a date representation.
 class DateParser final {
  public:
-  // Returns a |Date| corresponding to the representation |str|.
-  // Fails unless |str| is a date representation of one of the following forms:
+  // Returns a `Date` corresponding to the representation `str`.
+  // Fails unless `str` is a date representation of one of the following forms:
   // [YYYY-MM-DD], [YYYYMMDD], [YYYY-Www-D], [YYYYWwwD], [YYYY-DDD], [YYYYDDD],
   // with an optional prefix [J] or [G] and an optional sign.
   static constexpr Date Parse(char const* str, std::size_t size);
@@ -485,7 +485,7 @@ class DateParser final {
                        bool has_w,
                        int w_index);
 
-  // Returns a |DateParser| describing the given string. Fails if the string
+  // Returns a `DateParser` describing the given string. Fails if the string
   // does not exclusively consist of:
   //   - any number of decimal digits;
   //   - at most two hyphens;
@@ -501,7 +501,7 @@ class DateParser final {
                                         bool has_w,
                                         int w_index);
 
-  // Returns a |Date| corresponding to the string that |*this| describes.
+  // Returns a `Date` corresponding to the string that `*this` describes.
   // Fails if the format is invalid or the string represents an invalid date.
   constexpr Date ToDate(std::optional<Calendar> calendar, bool negative) const;
 
@@ -661,12 +661,12 @@ constexpr Date DateParser::ToDate(std::optional<Calendar> const calendar,
 
 // TimeOfDay parsing.
 
-// A |TimeParser| contains information about a string necessary to interpret it
+// A `TimeParser` contains information about a string necessary to interpret it
 // as a time representation.
 class TimeParser final {
  public:
-  // Returns a |TimeOfDay| corresponding to the representation |str|.
-  // Fails unless |str| is a valid time representation of one of the following
+  // Returns a `TimeOfDay` corresponding to the representation `str`.
+  // Fails unless `str` is a valid time representation of one of the following
   // forms: [hh:mm:ss], [hhmmss], [hh:mm:ss.ss̲], [hh:mm:ss,ss̲], [hhmmss.ss̲],
   // [hhmmss,ss̲], with at most three digits after the decimal mark.
   static constexpr TimeOfDay Parse(char const* str, std::size_t size);
@@ -680,7 +680,7 @@ class TimeParser final {
                        bool has_decimal_mark,
                        int decimal_mark_index);
 
-  // Returns a |TimeParser| describing the given string. Fails if the string
+  // Returns a `TimeParser` describing the given string. Fails if the string
   // does not exclusively consist of:
   // Fails if the string does not exclusively consist of:
   //   - any number of decimal digits;
@@ -697,7 +697,7 @@ class TimeParser final {
                                         bool has_decimal_mark,
                                         int decimal_mark_index);
 
-  // Returns a |TimeOfDay| corresponding to the string that |*this| describes.
+  // Returns a `TimeOfDay` corresponding to the string that `*this` describes.
   // Fails if the format is invalid or the string represents an invalid time.
   constexpr TimeOfDay ToTime() const;
 
@@ -837,15 +837,15 @@ constexpr TimeOfDay TimeParser::ToTime() const {
 
 // Julian date parsing.
 
-// A |JulianDateParser| contains information about a string necessary to
+// A `JulianDateParser` contains information about a string necessary to
 // interpret it as a Julian date.
 class JulianDateParser final {
  public:
-  // Returns a |JulianDate| corresponding to the representation |str|.
-  // Fails unless |str| is a valid time representation of the form [ddd] or
+  // Returns a `JulianDate` corresponding to the representation `str`.
+  // Fails unless `str` is a valid time representation of the form [ddd] or
   // [ddd.fff].
 
-  // Returns a |JulianDate| object corresponding to the given string interpreted
+  // Returns a `JulianDate` object corresponding to the given string interpreted
   // a Julian Date or a Modified Julian Date, respectively.
   static constexpr JulianDate ParseJD(char const* str, std::size_t size);
   static constexpr JulianDate ParseMJD(char const* str, std::size_t size);
@@ -855,7 +855,7 @@ class JulianDateParser final {
                              int digit_count,
                              int decimal_mark_index);
 
-  // Returns a |JulianDateParser| describing the given string. Fails if the
+  // Returns a `JulianDateParser` describing the given string. Fails if the
   // string is not of the form [ddd] or [ddd.fff] or if it has too many digits
   // to fit in a std::int64_t.
   static constexpr JulianDateParser ReadToEnd(char const* str,
@@ -866,7 +866,7 @@ class JulianDateParser final {
                                               bool has_decimal_mark,
                                               int decimal_mark_index);
 
-  // Returns a |JulianDate| corresponding to the string that |*this| describes.
+  // Returns a `JulianDate` corresponding to the string that `*this` describes.
   // Fails if the format is invalid.
   constexpr JulianDate ToJD() const;
   constexpr JulianDate ToMJD() const;
diff --git a/astronomy/epoch.hpp b/astronomy/epoch.hpp
index f5421ac6ba..964776a6bb 100644
--- a/astronomy/epoch.hpp
+++ b/astronomy/epoch.hpp
@@ -2,7 +2,7 @@
 
 #include "geometry/instant.hpp"
 
-// |geometry::Instant| represents instants of Terrestrial Time (TT).  The
+// `geometry::Instant` represents instants of Terrestrial Time (TT).  The
 // utilities in this file provide its standard epoch and two ways of specifying
 // TT dates.
 
@@ -13,7 +13,7 @@ namespace internal {
 
 using namespace principia::geometry::_instant;
 
-// |J2000| represents to the standard epoch J2000.0.
+// `J2000` represents to the standard epoch J2000.0.
 // According to Resolution B1 (On the Use of Julian Dates) of the XXIIIrd IAU
 // general assembly, "it is recommended that JD be specified as SI seconds in
 // Terrestrial Time (TT)", see http://goo.gl/oPemRm. J2000.0 is by definition
diff --git a/astronomy/frames.hpp b/astronomy/frames.hpp
index 62ff05298a..4d079ccf3f 100644
--- a/astronomy/frames.hpp
+++ b/astronomy/frames.hpp
@@ -57,7 +57,7 @@ using ICRS = Frame<serialization::Frame::SolarSystemTag,
 // - The time coordinate of the BCRS is TCB, and the time coordinate of the GCRS
 //   is TCG; TT is a linear scaling of TCG, and TDB is a linear scaling of TCB;
 //   for practical purposes TT and TDB are within 2 ms of each other;
-//   Principia's |Instant| is TT.
+//   Principia's `Instant` is TT.
 using GCRS = Frame<serialization::Frame::SolarSystemTag,
                    NonRotating,
                    Handedness::Right,
@@ -71,7 +71,7 @@ using GCRS = Frame<serialization::Frame::SolarSystemTag,
 // - This is identical to WGS84 at 1 m level, and to recent realizations of WGS
 //   84 at 10 cm level; the xz plane is a bit over a hundred metres from the
 //   Royal Observatory in Greenwich.
-//   Caveat: using |SphericalCoordinates<Length>| on ITRS coordinates is
+//   Caveat: using `SphericalCoordinates<Length>` on ITRS coordinates is
 //   inconsistent with WGS 84 latitudes; the WGS 84 geoid should be used.
 // - The ITRS is related to the European Terrestrial Reference System (ETRS89)
 //   by a time-dependent rigid transformation.
diff --git a/astronomy/lunar_eclipse_test.cpp b/astronomy/lunar_eclipse_test.cpp
index d444924933..fa7c9fc79c 100644
--- a/astronomy/lunar_eclipse_test.cpp
+++ b/astronomy/lunar_eclipse_test.cpp
@@ -77,8 +77,8 @@ class LunarEclipseTest : public ::testing::Test {
     atmospheric_depth_ = (1.0 / 85.0 - 1.0 / 594.0) * r_earth_;
   }
 
-  // A positive |time_error| means that the actual contact happens after
-  // |current_time|.
+  // A positive `time_error` means that the actual contact happens after
+  // `current_time`.
   void CheckLunarUmbralEclipse(Instant const& current_time,
                                Sign const moon_offset_sign,
                                ApproximateQuantity<Angle> const& angular_error,
@@ -112,7 +112,7 @@ class LunarEclipseTest : public ::testing::Test {
               (r_earth_ + atmospheric_depth_ + moon_offset_sign * r_moon_) /
               Sin(umbral_half_aperture(t));
       // Angle between Earth and Moon as seen at
-      // |apex_of_moon_locus_at_umbral_contact|.
+      // `apex_of_moon_locus_at_umbral_contact`.
       return AngleBetween(apex_of_moon_locus_at_umbral_contact - q_earth,
                           apex_of_moon_locus_at_umbral_contact - q_moon);
     };
@@ -139,8 +139,8 @@ class LunarEclipseTest : public ::testing::Test {
               << " " << actual_contact_time - current_time;
   }
 
-  // A positive |time_error| means that the actual contact happens after
-  // |current_time|.
+  // A positive `time_error` means that the actual contact happens after
+  // `current_time`.
   void CheckLunarPenumbralEclipse(
       Instant const& current_time,
       Sign const moon_offset_sign,
diff --git a/astronomy/lunar_orbit_test.cpp b/astronomy/lunar_orbit_test.cpp
index 2af0917ec8..69234bf2c2 100644
--- a/astronomy/lunar_orbit_test.cpp
+++ b/astronomy/lunar_orbit_test.cpp
@@ -157,11 +157,11 @@ class LunarOrbitTest : public ::testing::TestWithParam<GeopotentialTruncation> {
   // This reference frame is non-rotating, with its origin at the selenocentre.
   // The axes are those of LunarSurface at J2000.
   // Note that this frame is not actually inertial, but we want to use it with
-  // |KeplerOrbit|.  Perhaps we should have a concept of non-rotating, and
-  // |KeplerOrbit| should check that; this is good enough for a test.
+  // `KeplerOrbit`.  Perhaps we should have a concept of non-rotating, and
+  // `KeplerOrbit` should check that; this is good enough for a test.
   using Selenocentric = Frame<struct SelenocentricTag, Inertial>;
 
-  // We do not use a |BodyCentredNonRotatingReferenceFrame| since that would use
+  // We do not use a `BodyCentredNonRotatingReferenceFrame` since that would use
   // ICRS axes.
   RigidMotion<ICRS, Selenocentric> ToSelenocentric(Instant const& t) {
     return RigidMotion<ICRS, Selenocentric>(
diff --git a/astronomy/orbit_analysis_test.cpp b/astronomy/orbit_analysis_test.cpp
index 7ad6bfa997..7a7542c23a 100644
--- a/astronomy/orbit_analysis_test.cpp
+++ b/astronomy/orbit_analysis_test.cpp
@@ -153,7 +153,7 @@ class OrbitAnalysisTest : public ::testing::Test {
         earth_(*earth_1957_.rotating_body(*ephemeris_, "Earth")) {}
 
   // Returns a GCRS trajectory obtained by stitching together the trajectories
-  // of |sp3_orbit.satellites| in |sp3_orbit.files|.
+  // of `sp3_orbit.satellites` in `sp3_orbit.files`.
   not_null<std::unique_ptr<DiscreteTrajectory<GCRS>>> EarthCentredTrajectory(
       SP3Orbit const& sp3_orbit) {
     BodyCentredNonRotatingReferenceFrame<ICRS, GCRS> gcrs{ephemeris_.get(),
diff --git a/astronomy/orbit_ground_track.hpp b/astronomy/orbit_ground_track.hpp
index b5d10e8446..db44e9dbd3 100644
--- a/astronomy/orbit_ground_track.hpp
+++ b/astronomy/orbit_ground_track.hpp
@@ -30,11 +30,11 @@ class OrbitGroundTrack {
   struct MeanSun {
     Instant epoch;
     // This mean longitude of the sun is with respect to the axes of
-    // |PrimaryCentred|.
+    // `PrimaryCentred`.
     Angle mean_longitude_at_epoch;
     // This year is the period of the above mean longitude; which kind of year
-    // it is depends on the definition of |PrimaryCentred|.  If |PrimaryCentred|
-    // has ICRS axes, it is the sidereal year; if |PrimaryCentred| is the
+    // it is depends on the definition of `PrimaryCentred`.  If `PrimaryCentred`
+    // has ICRS axes, it is the sidereal year; if `PrimaryCentred` is the
     // reference frame of the equator & equinox of the date, it is the tropical
     // year.
     Time year;
@@ -66,7 +66,7 @@ class OrbitGroundTrack {
   OrbitGroundTrack& operator=(OrbitGroundTrack&&) = default;
 
   // Returns an object that describes the properties of the ground track of
-  // |trajectory| as an orbit around |primary|; if |mean_sun| is provided,
+  // `trajectory` as an orbit around `primary`; if `mean_sun` is provided,
   // sun-synchronicity is analysed.
   template<typename PrimaryCentred, typename Inertial>
   static absl::StatusOr<OrbitGroundTrack> ForTrajectory(
@@ -76,7 +76,7 @@ class OrbitGroundTrack {
 
   // Given a nominal recurrence and the index of the first ascending pass east
   // of the equator (which must be odd and in [1, 2 Nᴛₒ - 1], where Nᴛₒ is
-  // |nominal_recurrence.number_of_revolutions()|), returns an object describing
+  // `nominal_recurrence.number_of_revolutions()`), returns an object describing
   // how the recurrence grid is aligned in longitude, and how well the actual
   // orbit follows that grid.
   EquatorCrossingLongitudes equator_crossing_longitudes(
@@ -97,9 +97,9 @@ class OrbitGroundTrack {
 
   std::vector<Angle> longitudes_of_equator_crossings_of_ascending_passes_;
   std::vector<Angle> longitudes_of_equator_crossings_of_descending_passes_;
-  // Whether |longitudes_of_equator_crossings_of_descending_passes_.front()| is
+  // Whether `longitudes_of_equator_crossings_of_descending_passes_.front()` is
   // the longitude of the pass preceding
-  // |longitudes_of_equator_crossings_of_ascending_passes_.front()|, rather than
+  // `longitudes_of_equator_crossings_of_ascending_passes_.front()`, rather than
   // the following one.
   bool first_descending_pass_before_first_ascending_pass_;
   std::optional<Interval<Angle>> mean_solar_times_of_ascending_nodes_;
diff --git a/astronomy/orbit_ground_track_body.hpp b/astronomy/orbit_ground_track_body.hpp
index 7ff96d23fc..1769b971de 100644
--- a/astronomy/orbit_ground_track_body.hpp
+++ b/astronomy/orbit_ground_track_body.hpp
@@ -25,12 +25,12 @@ using namespace principia::quantities::_elementary_functions;
 using namespace principia::quantities::_si;
 
 // Note that the origin of this celestial longitude is arbitrary: it is not the
-// node of the orbit around the sun (the equinox).  If |PrimaryCentred| is the
+// node of the orbit around the sun (the equinox).  If `PrimaryCentred` is the
 // GCRS, this is the right ascension (with respect to the mean equinox of
 // J2000).
 template<typename PrimaryCentred>
 Angle CelestialLongitude(Position<PrimaryCentred> const& q) {
-  // TODO(egg): |ToSpherical| is wasteful, as we discard the latitude.
+  // TODO(egg): `ToSpherical` is wasteful, as we discard the latitude.
   return (q - PrimaryCentred::origin).coordinates().ToSpherical().longitude;
 }
 
@@ -79,7 +79,7 @@ Interval<Angle> MeanSolarTimesOfNodes(
 
 // Returns the interval spanned by the unwound angles
 //   longitudes_of_equatorial_crossings[n] - initial_offset - n * Δλᴇ,
-// where Δλᴇ is |nominal_recurrence.equatorial_shift()|, and the first angle is
+// where Δλᴇ is `nominal_recurrence.equatorial_shift()`, and the first angle is
 // in [0, 2π].
 inline Interval<Angle> ReducedLongitudesOfEquatorialCrossings(
     std::vector<Angle> const& longitudes_of_equatorial_crossings,
@@ -102,8 +102,8 @@ inline Interval<Angle> ReducedLongitudesOfEquatorialCrossings(
 inline Interval<Angle>
 OrbitGroundTrack::EquatorCrossingLongitudes::longitudes_reduced_to_pass(
     int const pass_index) const {
-  // |shift| applies the number of equatorial shifts corresponding to the pass
-  // number; |reduction| puts the midpoint of the shifted interval in [0, 2π].
+  // `shift` applies the number of equatorial shifts corresponding to the pass
+  // number; `reduction` puts the midpoint of the shifted interval in [0, 2π].
   Angle shift;
   Interval<Angle> longitudes;
   if (pass_index % 2 == 1) {
@@ -180,7 +180,7 @@ OrbitGroundTrack::equator_crossing_longitudes(
           initial_offset);
   if (first_descending_pass_before_first_ascending_pass_) {
     // Since the first descending pass is before the first ascending pass, using
-    // the same offset in |ReducedLongitudesOfEquatorialCrossings| would compute
+    // the same offset in `ReducedLongitudesOfEquatorialCrossings` would compute
     // the longitude reduced to pass 0; adjust by one equatorial shift to get
     // pass 2.
     initial_offset -= Δλᴇ;
diff --git a/astronomy/orbit_recurrence.hpp b/astronomy/orbit_recurrence.hpp
index 3d5d521d43..ec6c254d05 100644
--- a/astronomy/orbit_recurrence.hpp
+++ b/astronomy/orbit_recurrence.hpp
@@ -47,7 +47,7 @@ class OrbitRecurrence final {
   // Returns the recurrence that mostly matches the given orbital
   // characteristics, limiting the value of |Cᴛₒ|.
   // The Nᴛₒ / Cᴛₒ of the result is the last convergent of the κ obtained from
-  // the given arguments whose denominator is less than |max_abs_Cᴛₒ|.
+  // the given arguments whose denominator is less than `max_abs_Cᴛₒ`.
   template<typename Frame>
   static OrbitRecurrence ClosestRecurrence(
       Time const& nodal_period,
diff --git a/astronomy/orbital_elements.hpp b/astronomy/orbital_elements.hpp
index 0d9a04a1f1..28236f3e46 100644
--- a/astronomy/orbital_elements.hpp
+++ b/astronomy/orbital_elements.hpp
@@ -151,9 +151,9 @@ class OrbitalElements {
  private:
   OrbitalElements() = default;
 
-  // For |t| between |t_min| and |t_max|,
-  // |relative_degrees_of_freedom_at_time(t)| should return
-  // |DegreesOfFreedom<Frame>|.
+  // For `t` between `t_min` and `t_max`,
+  // `relative_degrees_of_freedom_at_time(t)` should return
+  // `DegreesOfFreedom<Frame>`.
   template<typename Frame, typename RelativeDegreesOfFreedomComputation>
   static absl::StatusOr<OrbitalElements> ForRelativeDegreesOfFreedom(
       RelativeDegreesOfFreedomComputation const&
@@ -165,16 +165,16 @@ class OrbitalElements {
       bool fill_osculating_equinoctial_elements);
 
   // The functor EquinoctialElementsComputation must have the profile
-  // |EquinoctialElements(Instant const&)|.
+  // `EquinoctialElements(Instant const&)`.
   template<typename EquinoctialElementsComputation>
   static absl::StatusOr<Time> SiderealPeriod(
       EquinoctialElementsComputation const& equinoctial_elements,
       Instant const& t_min,
       Instant const& t_max);
 
-  // |osculating| must contain at least 2 elements.
+  // `osculating` must contain at least 2 elements.
   // The resulting elements are averaged over one period, centred on
-  // their |EquinoctialElements::t|.
+  // their `EquinoctialElements::t`.
   template<typename EquinoctialElementsComputation>
   static absl::StatusOr<std::vector<EquinoctialElements>>
   MeanEquinoctialElements(
@@ -186,14 +186,14 @@ class OrbitalElements {
   static absl::StatusOr<std::vector<ClassicalElements>> ToClassicalElements(
       std::vector<EquinoctialElements> const& equinoctial_elements);
 
-  // |mean_classical_elements_| must have been computed; sets
-  // |anomalistic_period_|, |nodal_period_|, and |nodal_precession_|
-  // accordingly. Note that this does not compute |sidereal_period_| (our mean
+  // `mean_classical_elements_` must have been computed; sets
+  // `anomalistic_period_`, `nodal_period_`, and `nodal_precession_`
+  // accordingly. Note that this does not compute `sidereal_period_` (our mean
   // element computation is based on it, so it gets computed earlier).
   absl::Status ComputePeriodsAndPrecession();
 
-  // The |mean_classical_elements_| must have been computed; sets
-  // |mean_*_interval_| accordingly.
+  // The `mean_classical_elements_` must have been computed; sets
+  // `mean_*_interval_` accordingly.
   absl::Status ComputeIntervals();
 
   std::vector<EquinoctialElements> osculating_equinoctial_elements_;
diff --git a/astronomy/orbital_elements_body.hpp b/astronomy/orbital_elements_body.hpp
index 23f07b8b06..885aa726ce 100644
--- a/astronomy/orbital_elements_body.hpp
+++ b/astronomy/orbital_elements_body.hpp
@@ -302,11 +302,11 @@ OrbitalElements::MeanEquinoctialElements(
     Instant const& t_min,
     Instant const& t_max,
     Time const& period) {
-  // This function averages the elements in |osculating| over |period|.  For
-  // each |mean_elements| in the result, for all э in the set of equinoctial
-  // elements {a, h, k, λ, p, q, pʹ, qʹ}, |mean_elements.э| is the integral of
-  // the osculating э from |mean_elements.t - period / 2| to
-  // |mean_elements.t + period / 2|, divided by |period|.
+  // This function averages the elements in `osculating` over `period`.  For
+  // each `mean_elements` in the result, for all э in the set of equinoctial
+  // elements {a, h, k, λ, p, q, pʹ, qʹ}, `mean_elements.э` is the integral of
+  // the osculating э from `mean_elements.t - period / 2` to
+  // `mean_elements.t + period / 2`, divided by `period`.
 
   // We integrate the function (э(t + period / 2) - э(t - period / 2)) / period
   // using as the initial value an integral obtained by Clenshaw-Curtis.
@@ -365,7 +365,7 @@ OrbitalElements::MeanEquinoctialElements(
     // sparse, to the point where it confuses unwinding (because we have more
     // than half a revolution between points).  To avoid this we reduce the
     // tolerance-to-error ratio exponentially above 1/3 of the period.  For a
-    // step of |period / 2|, the reduction is e^-3.
+    // step of `period / 2`, the reduction is e^-3.
     double braking_factor = 1.0;
     if (3 * step >= period) {
       braking_factor = std::exp(6 - 18 * step / period);
@@ -373,7 +373,7 @@ OrbitalElements::MeanEquinoctialElements(
 
     // The braking factor can be very small (even 0) for large steps.  In that
     // case we want to reject the step, but not drive it all the way to 0,
-    // hence the |std::max|.
+    // hence the `std::max`.
     auto const& [Δa, Δh, Δk, Δλ, Δp, Δq, Δpʹ, Δqʹ] = error;
     return std::max(0.5, braking_factor * eerk_a_tolerance / Abs(Δa));
   };
diff --git a/astronomy/orbital_elements_test.cpp b/astronomy/orbital_elements_test.cpp
index b5679a248f..6e835e6b7a 100644
--- a/astronomy/orbital_elements_test.cpp
+++ b/astronomy/orbital_elements_test.cpp
@@ -64,8 +64,8 @@ class OrbitalElementsTest : public ::testing::Test {
  protected:
   OrbitalElementsTest() {}
 
-  // Completes |initial_osculating_elements| and returns a GCRS trajectory
-  // obtained by flowing the corresponding initial conditions in |ephemeris|.
+  // Completes `initial_osculating_elements` and returns a GCRS trajectory
+  // obtained by flowing the corresponding initial conditions in `ephemeris`.
   static not_null<std::unique_ptr<DiscreteTrajectory<GCRS>>>
   EarthCentredTrajectory(
       KeplerianElements<GCRS>& initial_osculating_elements,
diff --git a/astronomy/solar_system_dynamics_test.cpp b/astronomy/solar_system_dynamics_test.cpp
index 8b0e356e9a..8308df776a 100644
--- a/astronomy/solar_system_dynamics_test.cpp
+++ b/astronomy/solar_system_dynamics_test.cpp
@@ -149,10 +149,10 @@ class SolarSystemDynamicsTest : public ::testing::Test {
     auto const expected_parent_dof =
         expected_system.degrees_of_freedom(parent_name);
 
-    // We transform to a frame in which |parent| has the z-axis as its rotation
-    // axis by rotating around the normal to Earth's and |parent|'s rotation
+    // We transform to a frame in which `parent` has the z-axis as its rotation
+    // axis by rotating around the normal to Earth's and `parent`'s rotation
     // axes.
-    // If |parent| is the Sun, we use the normal to the invariable plane instead
+    // If `parent` is the Sun, we use the normal to the invariable plane instead
     // of the Sun's axis.
     // TODO(egg): perhaps rotating bodies should export a rotation to their
     // celestial reference frame, we'll use that in the plugin too.
diff --git a/astronomy/stabilize_ksp.hpp b/astronomy/stabilize_ksp.hpp
index ada9d07a72..d3481849e8 100644
--- a/astronomy/stabilize_ksp.hpp
+++ b/astronomy/stabilize_ksp.hpp
@@ -9,7 +9,7 @@ namespace internal {
 
 using namespace principia::physics::_solar_system;
 
-// Patches the given |solar_system|, which is expected to be the stock KSP, to
+// Patches the given `solar_system`, which is expected to be the stock KSP, to
 // make the Jool system stable.
 template<typename Frame>
 void StabilizeKSP(SolarSystem<Frame>& solar_system);
diff --git a/astronomy/standard_product_3.cpp b/astronomy/standard_product_3.cpp
index 0cbaffbc4e..e567856a4f 100644
--- a/astronomy/standard_product_3.cpp
+++ b/astronomy/standard_product_3.cpp
@@ -50,7 +50,7 @@ not_null<std::unique_ptr<DiscreteTrajectory<ITRS>>> ComputeVelocities(
     positions[k] = it->degrees_of_freedom.position();
   }
   // We use a central difference formula wherever possible, so we keep
-  // |offset| at (n - 1) / 2 except at the beginning and end of the arc.
+  // `offset` at (n - 1) / 2 except at the beginning and end of the arc.
   int offset = 0;
   for (int i = 0; i < arc.size(); ++i) {
     CHECK_OK(result->Append(times[offset],
@@ -59,8 +59,8 @@ not_null<std::unique_ptr<DiscreteTrajectory<ITRS>>> ComputeVelocities(
                                  /*values=*/positions,
                                  /*step=*/(times[n - 1] - times[0]) / (n - 1),
                                  offset)}));
-    // At every iteration, either |offset| advances, or the |positions|
-    // window shifts and |it| advances.
+    // At every iteration, either `offset` advances, or the `positions`
+    // window shifts and `it` advances.
     if (offset < (n - 1) / 2 || it == arc.end()) {
       ++offset;
     } else {
@@ -71,7 +71,7 @@ not_null<std::unique_ptr<DiscreteTrajectory<ITRS>>> ComputeVelocities(
       ++it;
     }
   }
-  // Note that having the right number of calls to |Append| does not guarantee
+  // Note that having the right number of calls to `Append` does not guarantee
   // this, as appending at an existing time merely emits a warning.
   CHECK_EQ(result->size(), arc.size());
   return result;
diff --git a/astronomy/standard_product_3.hpp b/astronomy/standard_product_3.hpp
index ffc94e2e81..79169b14ce 100644
--- a/astronomy/standard_product_3.hpp
+++ b/astronomy/standard_product_3.hpp
@@ -132,9 +132,9 @@ class StandardProduct3 {
   std::map<SatelliteIdentifier,
            std::vector<not_null<std::unique_ptr<DiscreteTrajectory<ITRS>>>>>
       orbits_;
-  // |orbits_| is the same as |const_orbits_|, but with non-owning pointers to
+  // `orbits_` is the same as `const_orbits_`, but with non-owning pointers to
   // constant trajectories; this allows us to return references to these vectors
-  // from |StandardProduct3::orbit|.
+  // from `StandardProduct3::orbit`.
   std::map<SatelliteIdentifier,
            std::vector<not_null<DiscreteTrajectory<ITRS> const*>>>
       const_orbits_;
diff --git a/astronomy/standard_product_3_test.cpp b/astronomy/standard_product_3_test.cpp
index c107c8ae52..4255fc5312 100644
--- a/astronomy/standard_product_3_test.cpp
+++ b/astronomy/standard_product_3_test.cpp
@@ -291,7 +291,7 @@ class StandardProduct3DynamicsTest
   // This ephemeris has only one body, an oblate Earth.
   // The lack of third bodies makes it quick to prolong; it is suitable for
   // minimal sanity checking of Earth orbits.
-  // Its |t_min| is the time of the launch of Спутник-1, so it can be used for
+  // Its `t_min` is the time of the launch of Спутник-1, so it can be used for
   // any artificial satellite.
   SolarSystem<ICRS> const solar_system_;
   not_null<std::unique_ptr<Ephemeris<ICRS>>> const ephemeris_;
diff --git a/astronomy/time_scales.hpp b/astronomy/time_scales.hpp
index a807e85599..c1d7d0ccef 100644
--- a/astronomy/time_scales.hpp
+++ b/astronomy/time_scales.hpp
@@ -31,7 +31,7 @@ constexpr Angle EarthRotationAngle(Instant tt);
 // — Temps Terrestre;
 // — Coordinated Universal Time;
 // — Universal Time (UT1).
-// |Instant| represents TT; note that the conversion from TAI, UTC, and UT1
+// `Instant` represents TT; note that the conversion from TAI, UTC, and UT1
 // converts to TT(TAI), not TT(BIPM); this may cause issues where long-term
 // frequency stability and high frequency accuracy are needed, see
 // https://www.bipm.org/en/bipm-services/timescales/time-ftp/ttbipm.html.
diff --git a/astronomy/time_scales_body.hpp b/astronomy/time_scales_body.hpp
index beb8563f87..08d3a4e1a7 100644
--- a/astronomy/time_scales_body.hpp
+++ b/astronomy/time_scales_body.hpp
@@ -22,9 +22,9 @@ using namespace principia::numerics::_double_precision;
 using namespace principia::quantities::_elementary_functions;
 using namespace principia::quantities::_si;
 
-// Returns the duration between 2000-01-01T12:00:00 and |date_time| (of the same
+// Returns the duration between 2000-01-01T12:00:00 and `date_time` (of the same
 // timescale), not counting any leap seconds that may have occurred in the past.
-// |date_time| itself may be leap second.
+// `date_time` itself may be leap second.
 // Note that this may count non-SI seconds depending on the time scale according
 // to which it is interpreted.
 // On a time scale with leap seconds, this is not injective: a positive leap
@@ -122,7 +122,7 @@ constexpr std::array<int, (2023 - 1972) * 2> leap_seconds = {{
 }};
 
 // Returns +1 if a positive leap second was inserted at the end of the given
-// |month| of the given |year|, 0 otherwise.
+// `month` of the given `year`, 0 otherwise.
 constexpr int LeapSecond(int const year, int const month) {
   if (month == 6) {
     CONSTEXPR_CHECK((year - 1972) * 2 < leap_seconds.size());
@@ -197,8 +197,8 @@ constexpr Time TAIMinusStretchyUTC(DateTime const& utc) {
   return OffsetTAIMinusStretchyUTC(utc.date()) + RateTAIMinusStretchyUTC(utc);
 }
 
-// Returns |true| if |utc| is within a leap of the given number of
-// |milliseconds| inserted before |next_day|.
+// Returns `true` if `utc` is within a leap of the given number of
+// `milliseconds` inserted before `next_day`.
 constexpr bool IsValidPositiveStretchyUTCLeap(DateTime const& utc,
                                               Date const& next_day,
                                               double const& milliseconds) {
@@ -207,9 +207,9 @@ constexpr bool IsValidPositiveStretchyUTCLeap(DateTime const& utc,
          utc.time().millisecond() < milliseconds;
 }
 
-// If |utc| is on the day before |next_day|, returns true its time is consistent
-// with a negative leap of the given number of |milliseconds| before |next_day|.
-// If |utc| is not on the day before |next_day|, returns true.
+// If `utc` is on the day before `next_day`, returns true its time is consistent
+// with a negative leap of the given number of `milliseconds` before `next_day`.
+// If `utc` is not on the day before `next_day`, returns true.
 constexpr bool IsValidStretchyUTCIfOnDayOfNegativeLeap(DateTime const& utc,
                                                        Date const& next_day,
                                                        int const milliseconds) {
@@ -240,7 +240,7 @@ constexpr bool IsValidStretchyUTC(DateTime const& utc) {
 // Utilities for UT1.
 
 // An entry in the Experimental EOP C02 time series; represents UT1 - TAI at the
-// given |ut1_mjd|.
+// given `ut1_mjd`.
 struct ExperimentalEOPC02Entry final {
   constexpr ExperimentalEOPC02Entry(double ut1_mjd, Time ut1_minus_tai);
 
@@ -254,7 +254,7 @@ constexpr ExperimentalEOPC02Entry::ExperimentalEOPC02Entry(
     : ut1_mjd(ut1_mjd), ut1_minus_tai(ut1_minus_tai) {}
 
 // An entry in the EOP (IERS) 08 C04 time series; represents UT1 - UTC at
-// 00:00:00 on the given |utc_date|.  The date is given as an integer of the
+// 00:00:00 on the given `utc_date`.  The date is given as an integer of the
 // form YYYY'MM'DD, which is then interpreted on demand, in order to limit the
 // number of constexpr steps.
 struct EOPC04Entry final {
@@ -301,10 +301,10 @@ constexpr Instant EOPC04Entry::tt() const {
 #include "astronomy/eop_c04.generated.h"
 
 // Returns the last entry in [begin, begin + size[ whose UT1 is less than or
-// equal to the given |ut1|.  The range [begin, begin + size[ must be sorted by
+// equal to the given `ut1`.  The range [begin, begin + size[ must be sorted by
 // UT1.
-// We have to use |begin| and |size| rather than |begin| and |end| because
-// otherwise MSVC complains about undefinedness of |end - begin| (even though
+// We have to use `begin` and `size` rather than `begin` and `end` because
+// otherwise MSVC complains about undefinedness of `end - begin` (even though
 // Intellisense is fine with it).
 constexpr ExperimentalEOPC02Entry const* LookupUT1(
     Time const& ut1,
@@ -366,8 +366,8 @@ constexpr EOPC04Entry const* LookupInEOPC04(Instant const& tt) {
 constexpr Instant InterpolatedEOPC04(EOPC04Entry const* low,
                                      Time const& ut1) {
   // TODO(egg): figure out whether using the divided difference of the
-  // |p->ut1_minus_tai()|s leads to less catastrophic cancellation than using
-  // the divided difference of the |DateTimeAsUTC(p->utc())|s.
+  // `p->ut1_minus_tai()`s leads to less catastrophic cancellation than using
+  // the divided difference of the `DateTimeAsUTC(p->utc())`s.
   return FromTAI(ut1 -
                  (low->ut1_minus_tai() +
                   (ut1 - low->ut1()) *
@@ -375,17 +375,17 @@ constexpr Instant InterpolatedEOPC04(EOPC04Entry const* low,
                       ((low + 1)->ut1() - low->ut1())));
 }
 
-// UT1 Julian Day fraction in [-1/2 - ε, 1/2 + ε] where ε bounds |UT1-UTC|,
+// UT1 Julian Day fraction in [-1/2 - ε, 1/2 + ε] where ε bounds `UT1-UTC`,
 // obtained by linear interpolation of EOP C04 on the TT range
 // [low->tt(), (low + 1)->tt()].
-// |jd_minus_2451545| is set to the integer such that the Julian UT1 date is
+// `jd_minus_2451545` is set to the integer such that the Julian UT1 date is
 // jd_minus_2451545 + 2451545 + result.
 constexpr double InterpolatedEOPC04JulianDayFraction(EOPC04Entry const* low,
                                                      Instant const& tt,
                                                      int& jd_minus_2451545) {
   double const λ = (tt - low->tt()) / ((low + 1)->tt() - low->tt());
   // The UTC MJD number for the day of the interpolation interval is
-  //   |low->utc().date().mjd()|.
+  //   `low->utc().date().mjd()`.
   // Up to the second-sized UT1-UTC difference, this is also the UT1 MJD number.
   // MJD = JD - 2400000.5, so that, in the middle of the interval, where the
   // result is 0,
@@ -408,8 +408,8 @@ constexpr Instant InterpolatedExperimentalEOPC02(
                             ((low + 1)->ut1_mjd - low->ut1_mjd)));
 }
 
-// Linear interpolation in the segment between the UT1s |low.ut1_mjd| and
-// |high.ut1()|, used to get continuity when switching between the series.
+// Linear interpolation in the segment between the UT1s `low.ut1_mjd` and
+// `high.ut1()`, used to get continuity when switching between the series.
 constexpr Instant ExperimentalEOPC02ToEOPC04(ExperimentalEOPC02Entry const& low,
                                              EOPC04Entry const& high,
                                              Time const& ut1) {
@@ -451,7 +451,7 @@ constexpr Angle EarthRotationAngle(Instant const tt) {
           0.00273781191135448 * Tu);
 }
 
-// Conversions from |DateTime| and |JulianDate| to |Instant|.
+// Conversions from `DateTime` and `JulianDate` to `Instant`.
 
 constexpr Instant DateTimeAsTT(DateTime const& tt) {
   CONSTEXPR_CHECK(!tt.time().is_leap_second());
@@ -494,7 +494,7 @@ constexpr Instant DateTimeAsUT1(DateTime const& ut1) {
   return FromUT1(TimeSince20000101T120000Z(ut1));
 }
 
-// |Instant| date literals.
+// `Instant` date literals.
 
 constexpr Instant operator""_TAI(char const* str, std::size_t const size) {
   if (IsJulian(str, size)) {
diff --git a/astronomy/trappist_dynamics_test.cpp b/astronomy/trappist_dynamics_test.cpp
index 25ad45d69c..baef8e36e2 100644
--- a/astronomy/trappist_dynamics_test.cpp
+++ b/astronomy/trappist_dynamics_test.cpp
@@ -108,8 +108,8 @@ class Population {
  public:
   using ComputeFitness = std::function<double(Genome const&, std::string&)>;
 
-  // Constructs an initial population made of |size| mutated copies of |luca|.
-  // If |elitism| is true, the best individual is preserved unchanged in the
+  // Constructs an initial population made of `size` mutated copies of `luca`.
+  // If `elitism` is true, the best individual is preserved unchanged in the
   // next generation.
   Population(Genome const& luca,
              int size,
@@ -166,7 +166,7 @@ void Genome::Mutate(std::mt19937_64& engine,
   // algorithm: if it's too small we do not explore the genomic space
   // efficiently and it takes forever to find decent solutions; if it's too
   // large we explore the genomic space haphazardly and suffer from deleterious
-  // mutations.  The |multiplicator| is used to decay the perturbation over
+  // mutations.  The `multiplicator` is used to decay the perturbation over
   // time.
   double const multiplicator =
       generation == -1 ? 1 : std::exp2(-2 - std::min(generation, 800) / 120);
@@ -1358,7 +1358,7 @@ TEST_F(TrappistDynamicsTest, DISABLED_SECULAR_Optimization) {
   double great_old_one_fitness = 0.0;
   {
     // First, let's do some rounds of evolution with a population of individuals
-    // based on |luca|.  The best of all of them is the Great Old One.
+    // based on `luca`.  The best of all of them is the Great Old One.
     int const number_of_rounds = 40;
     genetics::Genome const luca(elements);
     Bundle bundle;
diff --git a/base/array.hpp b/base/array.hpp
index 975ce81ad2..1e383d08d8 100644
--- a/base/array.hpp
+++ b/base/array.hpp
@@ -10,7 +10,7 @@ namespace base {
 namespace _array {
 namespace internal {
 
-// A simple container for a pointer and size.  |data| is not owned.
+// A simple container for a pointer and size.  `data` is not owned.
 template<typename Element>
 struct Array final {
   // An object of size 0.
@@ -44,7 +44,7 @@ struct Array final {
               decltype(std ::declval<Container const>().size())>::value>>
   constexpr Array(Container const& container);  // NOLINT(runtime/explicit)
 
-  // Construction from a string literal if |Element| is a character type or some
+  // Construction from a string literal if `Element` is a character type or some
   // flavour of byte.
   template<std::size_t size_plus_1,
            typename Character,
@@ -64,12 +64,12 @@ struct Array final {
   std::int64_t size = 0;  // In number of elements.
 };
 
-// A simple container for a pointer and size.  |data| is owned.
+// A simple container for a pointer and size.  `data` is owned.
 template<typename Element>
 struct UniqueArray final {
   // An object of size 0.
   UniqueArray();
-  // Allocates memory for |size| elements.
+  // Allocates memory for `size` elements.
   template<typename Size,
            typename =
                typename std::enable_if<std::is_integral<Size>::value>::type>
diff --git a/base/array_body.hpp b/base/array_body.hpp
index a8443caa65..dc5d175465 100644
--- a/base/array_body.hpp
+++ b/base/array_body.hpp
@@ -39,8 +39,8 @@ template<std::size_t size_plus_1, typename Character, typename>
 constexpr Array<Element>::Array(Character (&characters)[size_plus_1])
     : data(reinterpret_cast<Element*>(characters)),
       size(size_plus_1 - 1) {
-  // The |enable_if|s should prevent this from failing, but we explicitly
-  // check that the cast is trivial or reinterprets a |char const*|.  The cast
+  // The `enable_if`s should prevent this from failing, but we explicitly
+  // check that the cast is trivial or reinterprets a `char const*`.  The cast
   // is C-style rather than a reinterpret so that this constructor is constexpr
   // in the trivial case.
   static_assert(std::is_same<Element, Character>::value ||
diff --git a/base/array_test.cpp b/base/array_test.cpp
index fd67cdb7b1..fef1777ed1 100644
--- a/base/array_test.cpp
+++ b/base/array_test.cpp
@@ -84,7 +84,7 @@ TEST(ArrayTest, Return) {
   };
 }
 
-// This test only compiles if the constructor correctly uses |std::forward|.
+// This test only compiles if the constructor correctly uses `std::forward`.
 TEST(ArrayTest, Move) {
   [[maybe_unused]] auto fn =
       [](std::unique_ptr<int> x,
diff --git a/base/base32768_body.hpp b/base/base32768_body.hpp
index 57144a8afc..8ef4123299 100644
--- a/base/base32768_body.hpp
+++ b/base/base32768_body.hpp
@@ -15,7 +15,7 @@
 #include "base/bits.hpp"
 #include "glog/logging.h"
 
-// Clang doesn't have a correct |std::array| yet, and we don't actually use this
+// Clang doesn't have a correct `std::array` yet, and we don't actually use this
 // code, so let's get rid of the entire body.
 #if PRINCIPIA_COMPILER_MSVC
 
@@ -245,7 +245,7 @@ void Base32768Encoder<null_terminated>::Encode(Array<std::uint8_t const> input,
     CHECK_LT(code_point, 1 << bits_per_code_point);
     output.data[0] = repertoire->Encode(code_point);
 
-    // The following computation may cause |input.data| to overshoot the end if
+    // The following computation may cause `input.data` to overshoot the end if
     // using the special encoding at the end.  This is safe as soon as the loop
     // condition uses <.
     input_bit_index += bits_per_code_point;
@@ -303,7 +303,7 @@ void Base32768Encoder<null_terminated>::Decode(Array<char16_t const> input,
       repertoire = &seven_bits;
     }
 
-    // Align |data| on the output bit index.
+    // Align `data` on the output bit index.
     data = repertoire->Decode(input.data[0]);
     data <<= shift;
 
diff --git a/base/base32768_test.cpp b/base/base32768_test.cpp
index 4741cd69ac..e652ca7473 100644
--- a/base/base32768_test.cpp
+++ b/base/base32768_test.cpp
@@ -14,7 +14,7 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-// Clang doesn't have a correct |std::array| yet, and we don't actually use this
+// Clang doesn't have a correct `std::array` yet, and we don't actually use this
 // code, so let's get rid of the entire test.
 #if PRINCIPIA_COMPILER_MSVC
 
diff --git a/base/bundle.cpp b/base/bundle.cpp
index 18770efc3a..8c67185db2 100644
--- a/base/bundle.cpp
+++ b/base/bundle.cpp
@@ -63,8 +63,8 @@ void Bundle::Toil(Task const& task) {
   }
 
   // No locking, so as to avoid contention during joining.  Note that if
-  // |joining_| is true we know that |number_of_active_workers_| cannot
-  // increase.  Reading |number_of_active_workers_| independently from the
+  // `joining_` is true we know that `number_of_active_workers_` cannot
+  // increase.  Reading `number_of_active_workers_` independently from the
   // decrement would be incorrect as we must ensure that exactly one thread sees
   // that counter dropping to zero.
   int const number_of_active_workers = --number_of_active_workers_;
diff --git a/base/bundle.hpp b/base/bundle.hpp
index 5ea0bf6acc..35ab961552 100644
--- a/base/bundle.hpp
+++ b/base/bundle.hpp
@@ -17,21 +17,21 @@ namespace _bundle {
 namespace internal {
 
 // A bundle manages a number of threads that execute independently.  A thread is
-// created for each call to |Add|.  When one of the |Join*| is called, no more
-// calls to |Add| are allowed, and |Join*| returns the first error status (if
+// created for each call to `Add`.  When one of the `Join*` is called, no more
+// calls to `Add` are allowed, and `Join*` returns the first error status (if
 // any) produced by the tasks.
 class Bundle final {
  public:
   using Task = std::function<absl::Status()>;
 
-  // If a |task| returns an erroneous |absl::Status|, |Join| returns that
+  // If a `task` returns an erroneous `absl::Status`, `Join` returns that
   // status.
   void Add(Task task) LOCKS_EXCLUDED(lock_);
 
   // Returns the first non-OK status encountered, or OK.  All worker threads are
   // joined; no calls to member functions may follow this call.
   absl::Status Join() LOCKS_EXCLUDED(lock_, status_lock_);
-  // Same as above, but returns a |kDeadlineExceeded| status if it fails to
+  // Same as above, but returns a `kDeadlineExceeded` status if it fails to
   // complete within the given interval.
   absl::Status JoinWithin(std::chrono::steady_clock::duration Δt)
       LOCKS_EXCLUDED(lock_, status_lock_);
@@ -50,13 +50,13 @@ class Bundle final {
 
   absl::Mutex lock_;
 
-  // Whether |Join| has been called.  When set to true, |Add| should not be
+  // Whether `Join` has been called.  When set to true, `Add` should not be
   // called.
   std::atomic_bool joining_ = false;
   absl::Notification all_done_;
 
   // The number of workers currently executing.  Can only be incremented when
-  // |joining_| is false.
+  // `joining_` is false.
   std::atomic_int number_of_active_workers_ = 0;
   std::list<std::thread> workers_ GUARDED_BY(lock_);
 
diff --git a/base/constant_function.hpp b/base/constant_function.hpp
index 6d901e2dcf..d9d5b5f349 100644
--- a/base/constant_function.hpp
+++ b/base/constant_function.hpp
@@ -6,7 +6,7 @@ namespace _constant_function {
 namespace internal {
 
 // A function object that can be called with arbitrary arguments, and always
-// returns the same |value|.
+// returns the same `value`.
 template<typename T>
 struct ConstantFunction {
   template<typename... Args>
diff --git a/base/disjoint_sets.hpp b/base/disjoint_sets.hpp
index 355268d1f1..9a6a859d38 100644
--- a/base/disjoint_sets.hpp
+++ b/base/disjoint_sets.hpp
@@ -12,29 +12,29 @@ namespace internal {
 
 using namespace principia::base::_not_null;
 
-// For the purposes of this class, |T| represents the set of its values, and
-// a single globally unique partition is being built.  If |MakeSingleton| is
-// called on an element |e| of type |T|, all properties of the subset previously
-// containing |e| are invalidated.
-// To use an union-find algorithm on elements of |T|, specialize
-// |Subset<T>::Node::Get|, run |Subset<T>::MakeSingleton| on all elements
-// involved, and proceed with calls to |Subset<T>::Unite| and |Subset<T>::Find|.
-
-// A subset of |T|.
+// For the purposes of this class, `T` represents the set of its values, and
+// a single globally unique partition is being built.  If `MakeSingleton` is
+// called on an element `e` of type `T`, all properties of the subset previously
+// containing `e` are invalidated.
+// To use an union-find algorithm on elements of `T`, specialize
+// `Subset<T>::Node::Get`, run `Subset<T>::MakeSingleton` on all elements
+// involved, and proceed with calls to `Subset<T>::Unite` and `Subset<T>::Find`.
+
+// A subset of `T`.
 template<typename T>
 class Subset final {
  public:
-  // Any properties about a subset of |T| that can be efficiently maintained
+  // Any properties about a subset of `T` that can be efficiently maintained
   // when merging (e.g. a list of elements) should be kept in
-  // |Subset<T>::Properties|; specialize it as needed.
+  // `Subset<T>::Properties`; specialize it as needed.
   class Properties final {
    public:
     void MergeWith(Properties& other) {}
   };
 
-  // The |SubsetPropertiesArgs| are forwarded to the constructor of
-  // |Properties|; the constructed |Properties| are owned by
-  // |*Node::Get(element)|, and thus by element.
+  // The `SubsetPropertiesArgs` are forwarded to the constructor of
+  // `Properties`; the constructed `Properties` are owned by
+  // `*Node::Get(element)`, and thus by element.
   template<typename... SubsetPropertiesArgs>
   static Subset MakeSingleton(
       T& element,
@@ -43,7 +43,7 @@ class Subset final {
   // The arguments are invalidated; the result may be used to get information
   // about the united subset.
   static Subset Unite(Subset left, Subset right);
-  // Returns the subset containing |element|.
+  // Returns the subset containing `element`.
   static Subset Find(T& element);
 
   Properties const& properties() const;
@@ -54,7 +54,7 @@ class Subset final {
     Node();
 
    private:
-    // Specialize to return a |Node| owned by |element| (in constant time).  The
+    // Specialize to return a `Node` owned by `element` (in constant time).  The
     // compiler will warn about returning from a non-void function if this is
     // not specialized.
     static not_null<typename Subset::Node*> Get(T& element) {}
@@ -64,17 +64,17 @@ class Subset final {
     not_null<Node*> parent_;
     int rank_ = 0;
 
-    // Do not require a default constructor for |Properties|.
+    // Do not require a default constructor for `Properties`.
     std::optional<Properties> properties_;
 
     friend class Subset<T>;
   };
 
   // These operators cannot be defaulted because that would force instantiation
-  // of |not_null<Node*>| which itself would force instantiation of
-  // |std::optional<Properties>| which itself would force instantiation of
-  // |Properties|, thereby preventing further specialization in
-  // |part_subsets.hpp|.
+  // of `not_null<Node*>` which itself would force instantiation of
+  // `std::optional<Properties>` which itself would force instantiation of
+  // `Properties`, thereby preventing further specialization in
+  // `part_subsets.hpp`.
   friend bool operator==(Subset left, Subset right) {
     return left.node_ == right.node_;
   }
diff --git a/base/encoder.hpp b/base/encoder.hpp
index 7c3f641f81..2e7b9cddda 100644
--- a/base/encoder.hpp
+++ b/base/encoder.hpp
@@ -12,7 +12,7 @@ namespace internal {
 using namespace principia::base::_array;
 
 // Encodes/decodes an array of bytes to/from an array of Char.  If
-// |null_terminated| is true a null Char is appended to the encoded form and
+// `null_terminated` is true a null Char is appended to the encoded form and
 // taken into account in the encoded length.
 template<typename Char_, bool null_terminated>
 class Encoder {
@@ -21,7 +21,7 @@ class Encoder {
 
   virtual ~Encoder() = default;
 
-  // Encodes |input| into |output|, which must be large enough to hold the
+  // Encodes `input` into `output`, which must be large enough to hold the
   // encoded form.
   virtual void Encode(Array<std::uint8_t const> input,
                       Array<Char> output) = 0;
@@ -32,7 +32,7 @@ class Encoder {
   // Length of the encoded form, in Char.
   virtual std::int64_t EncodedLength(Array<std::uint8_t const> input) = 0;
 
-  // Decodes |input| into |output|, which must be large enough to hold the
+  // Decodes `input` into `output`, which must be large enough to hold the
   // decoded form.  The input may or may not be null-terminated.
   virtual void Decode(Array<Char const> input,
                       Array<std::uint8_t> output) = 0;
diff --git a/base/file.hpp b/base/file.hpp
index 8a4ad4f4d5..be6a0c0e54 100644
--- a/base/file.hpp
+++ b/base/file.hpp
@@ -9,7 +9,7 @@ namespace base {
 namespace _file {
 namespace internal {
 
-// A RAII wrapper for a |std::ofstream|.
+// A RAII wrapper for a `std::ofstream`.
 class OFStream {
  public:
   OFStream() = default;
diff --git a/base/file_body.hpp b/base/file_body.hpp
index da8237615e..c45ebc0fc5 100644
--- a/base/file_body.hpp
+++ b/base/file_body.hpp
@@ -18,7 +18,7 @@ namespace internal {
 inline OFStream::OFStream(std::filesystem::path const& path) {
 #if PRINCIPIA_COMPILER_MSVC
   CHECK(path.has_filename()) << path;
-  // Don't use |remove_filename| here as it leaves a trailing \.  See
+  // Don't use `remove_filename` here as it leaves a trailing \.  See
   // https://developercommunity.visualstudio.com/content/problem/278829/stdfilesystemcreate-directories-returns-false-if-p.html
   // for a discussion of what happens in that case.
   std::filesystem::path const directory = path.parent_path();
diff --git a/base/flags.hpp b/base/flags.hpp
index 1ae43a4800..6700c355e9 100644
--- a/base/flags.hpp
+++ b/base/flags.hpp
@@ -19,17 +19,17 @@ class Flags {
   // Remove all the flags.
   static void Clear();
 
-  // Sets a flag with the given |name| and |value|.
+  // Sets a flag with the given `name` and `value`.
   static void Set(std::string_view name, std::string_view value);
 
-  // Returns true if a flag with the given |name| was set (with any value).
+  // Returns true if a flag with the given `name` was set (with any value).
   static bool IsPresent(std::string_view name);
 
-  // Returns true if a flag with the given |name| and |value| was set.
+  // Returns true if a flag with the given `name` and `value` was set.
   static bool IsPresent(std::string_view name, std::string_view value);
 
-  // Returns the values associated with the flag with a given |name|.  Returns
-  // an empty set if there is no flag with the |name|.
+  // Returns the values associated with the flag with a given `name`.  Returns
+  // an empty set if there is no flag with the `name`.
   static std::set<std::string> Values(std::string_view name);
 
  private:
diff --git a/base/for_all_of.hpp b/base/for_all_of.hpp
index 03377f1c1c..92f3f31b2f 100644
--- a/base/for_all_of.hpp
+++ b/base/for_all_of.hpp
@@ -26,7 +26,7 @@ class Iteration {
   std::tuple<Tuple&&...> all_the_tuples_;
 };
 
-// Iterates over all the tuples in parallel.  |F| must be a functor taking
+// Iterates over all the tuples in parallel.  `F` must be a functor taking
 // elements at corresponding positions in each of the tuples.
 // Example:
 //   std::tuple const t{"a", 2.5, 3};
diff --git a/base/hexadecimal.hpp b/base/hexadecimal.hpp
index f6e85a8a32..6d58fffa4c 100644
--- a/base/hexadecimal.hpp
+++ b/base/hexadecimal.hpp
@@ -16,10 +16,10 @@ using namespace principia::base::_encoder;
 template<bool null_terminated>
 class HexadecimalEncoder : public Encoder<char, null_terminated> {
  public:
-  // The result is upper-case.  Either |input.data <= &output.data[1]| or
-  // |&output.data[input.size << 1] <= input.data| must hold, in particular,
-  // |input.data == output.data| is valid.  |output.size| must be at least twice
-  // |input.size|.  The range
+  // The result is upper-case.  Either `input.data <= &output.data[1]` or
+  // `&output.data[input.size << 1] <= input.data` must hold, in particular,
+  // `input.data == output.data` is valid.  `output.size` must be at least twice
+  // `input.size`.  The range
   // [&output.data[input.size << 1], &output.data[output.size][ is left
   // unmodified.
   void Encode(Array<std::uint8_t const> input,
@@ -29,11 +29,11 @@ class HexadecimalEncoder : public Encoder<char, null_terminated> {
 
   std::int64_t EncodedLength(Array<std::uint8_t const> input) override;
 
-  // Invalid digits are read as 0.  If |input.size| is odd, the last character
-  // of the input is ignored.  Ignores case.  Either |output.data <=
-  // &input.data[1]| or |&input.data[input.size & ~1] <= output.data| must hold,
-  // in particular, |input.data == output.data| is valid.  |output.size| must be
-  // at least |input.size / 2|.  The range
+  // Invalid digits are read as 0.  If `input.size` is odd, the last character
+  // of the input is ignored.  Ignores case.  Either `output.data <=
+  // &input.data[1]` or `&input.data[input.size & ~1] <= output.data` must hold,
+  // in particular, `input.data == output.data` is valid.  `output.size` must be
+  // at least `input.size / 2`.  The range
   // [&output[input.size / 2], &output[output.size][ is left unmodified.
   void Decode(Array<char const> input,
               Array<std::uint8_t> output) override;
diff --git a/base/hexadecimal_body.hpp b/base/hexadecimal_body.hpp
index 8ad379bb6a..4200b99338 100644
--- a/base/hexadecimal_body.hpp
+++ b/base/hexadecimal_body.hpp
@@ -45,16 +45,16 @@ void HexadecimalEncoder<null_terminated>::Encode(
   CHECK_NOTNULL(input.data);
   CHECK_NOTNULL(output.data);
   // We iterate backward.
-  // |input <= &output[1]| is still valid because we write two bytes of output
+  // `input <= &output[1]` is still valid because we write two bytes of output
   // from reading one byte of input, so output[1] and output[0] are written
-  // after reading input[0].  Greater values of |output| would
+  // after reading input[0].  Greater values of `output` would
   // overwrite input data before it is read, unless there is no overlap, i.e.,
-  // |&output[input_size << 1] <= input|.
+  // `&output[input_size << 1] <= input`.
   CHECK(input.data <= static_cast<void*>(&output.data[1]) ||
         static_cast<void*>(&output.data[input.size << 1]) <= input.data)
       << "bad overlap";
   CHECK_GE(output.size, EncodedLength(input)) << "output too small";
-  // We want the result to start at |output.data[0]|.
+  // We want the result to start at `output.data[0]`.
   output.data += ((input.size - 1) << 1);
   if constexpr (null_terminated) {
     output.data[2] = 0;
@@ -93,11 +93,11 @@ void HexadecimalEncoder<null_terminated>::Decode(Array<char const> input,
   CHECK_NOTNULL(input.data);
   CHECK_NOTNULL(output.data);
   input.size &= ~1;
-  // |output <= &input[1]| is still valid because we write one byte of output
+  // `output <= &input[1]` is still valid because we write one byte of output
   // from reading two bytes of input, so output[0] is written after reading
-  // input[0] and input[1].  Greater values of |output| would overwrite input
+  // input[0] and input[1].  Greater values of `output` would overwrite input
   // data before it is read, unless there is no overlap, i.e.,
-  // |&input[input_size] <= output|.
+  // `&input[input_size] <= output`.
   CHECK(static_cast<void*>(output.data) <= &input.data[1] ||
         &input.data[input.size] <= static_cast<void*>(output.data))
       << "bad overlap";
diff --git a/base/jthread.hpp b/base/jthread.hpp
index 89f24808c9..820933cae4 100644
--- a/base/jthread.hpp
+++ b/base/jthread.hpp
@@ -112,7 +112,7 @@ class jthread {
   std::thread thread_;
 };
 
-// |f| *does not* take a stop_token as its first parameter.
+// `f` *does not* take a stop_token as its first parameter.
 template<typename Function, typename... Args>
 static jthread MakeStoppableThread(Function&& f, Args&&... args);
 
diff --git a/base/mappable.hpp b/base/mappable.hpp
index c3b6c0d4b9..629ba44cc5 100644
--- a/base/mappable.hpp
+++ b/base/mappable.hpp
@@ -11,14 +11,14 @@ using namespace principia::base::_not_constructible;
 
 // This struct helps in declaring that a type is "mappable", i.e., that the maps
 // declared in principia::geometry can be act on it through the operator().  To
-// use it, declare a specialization for the proper |Functor| (a class that must
-// have an operator()) and |T| (the class to be made mappable).  The third
+// use it, declare a specialization for the proper `Functor` (a class that must
+// have an operator()) and `T` (the class to be made mappable).  The third
 // parameter is an enabler and maybe used to restrict specializations with
 // SFINAE.
 // Any specialization must export two declarations in its public part:
-//   o A type named |type|, which is the result of applying |Functor| to |T|.
-//   o A static function named |Do|, which applies a functor to a value of |T|
-//     and returns a |type|.
+//   o A type named `type`, which is the result of applying `Functor` to `T`.
+//   o A static function named `Do`, which applies a functor to a value of `T`
+//     and returns a `type`.
 // See the comments below for example declarations.
 template<typename Functor, typename T, typename = void>
 struct Mappable : not_constructible {
diff --git a/base/mod.hpp b/base/mod.hpp
index 803d48ab78..5e96d10684 100644
--- a/base/mod.hpp
+++ b/base/mod.hpp
@@ -5,15 +5,15 @@ namespace base {
 namespace _mod {
 namespace internal {
 
-// The result of |mod| has the same sign as |divisor| (same convention as Ada,
-// ISO Prolog, Haskell, etc.), whereas the result of |dividend % divisor| has
-// the same sign as |dividend| (like |rem| in the aforementioned languages).
+// The result of `mod` has the same sign as `divisor` (same convention as Ada,
+// ISO Prolog, Haskell, etc.), whereas the result of `dividend % divisor` has
+// the same sign as `dividend` (like `rem` in the aforementioned languages).
 constexpr int mod(int const dividend, int const divisor) {
   return ((dividend % divisor) + divisor) % divisor;
 }
 
-// Similar to Mathematica's |Mod|: the result is congruent to |dividend| modulo
-// |divisor|, and lies in [offset, divisor + offset[ if divisor > 0, and in
+// Similar to Mathematica's `Mod`: the result is congruent to `dividend` modulo
+// `divisor`, and lies in [offset, divisor + offset[ if divisor > 0, and in
 // ]divisor + offset, offset] otherwise.
 constexpr int mod(int const dividend, int const divisor, int const offset) {
   return mod(dividend - offset, divisor) + offset;
diff --git a/base/monostable.hpp b/base/monostable.hpp
index 0cbbe86b3d..7ff8244456 100644
--- a/base/monostable.hpp
+++ b/base/monostable.hpp
@@ -5,7 +5,7 @@ namespace base {
 namespace _monostable {
 namespace internal {
 
-// A boolean which is constructed true and becomes false when |Flop| is called.
+// A boolean which is constructed true and becomes false when `Flop` is called.
 class Monostable final {
  public:
   Monostable() = default;
diff --git a/base/not_null.hpp b/base/not_null.hpp
index 133ee153f4..102c368c31 100644
--- a/base/not_null.hpp
+++ b/base/not_null.hpp
@@ -9,7 +9,7 @@
 #include "base/traits.hpp"
 #include "glog/logging.h"
 
-// This file defines a pointer wrapper |not_null| that statically ensures
+// This file defines a pointer wrapper `not_null` that statically ensures
 // non-nullness where possible, and performs runtime checks at the point of
 // conversion otherwise.
 // The point is to replace cases of undefined behaviour (dereferencing a null
@@ -18,20 +18,20 @@
 // will generally not occur when the pointer is dereferenced, but where the
 // reference is used instead, making it hard to track where an invariant was
 // violated.
-// The static typing of |not_null| also optimizes away some unneeded checks:
-// a function taking a |not_null| argument will not need to check its arguments,
-// the caller has to provide a |not_null| pointer instead.  If the object passed
-// is already a |not_null|, no check needs to be performed.
+// The static typing of `not_null` also optimizes away some unneeded checks:
+// a function taking a `not_null` argument will not need to check its arguments,
+// the caller has to provide a `not_null` pointer instead.  If the object passed
+// is already a `not_null`, no check needs to be performed.
 // The syntax is as follows:
-//   not_null<int*> p  // non-null pointer to an |int|.
-//   not_null<std::unique_ptr<int>> p // non-null unique pointer to an |int|.
-// |not_null| does not have a default constructor, since there is no non-null
-// default valid pointer.  The only ways to construct a |not_null| pointer,
-// other than from existing instances of |not_null|, are (implicit) conversion
-// from a nullable pointer, the factory |check_not_null|, and
-// |make_not_null_unique|.
+//   not_null<int*> p  // non-null pointer to an `int`.
+//   not_null<std::unique_ptr<int>> p // non-null unique pointer to an `int`.
+// `not_null` does not have a default constructor, since there is no non-null
+// default valid pointer.  The only ways to construct a `not_null` pointer,
+// other than from existing instances of `not_null`, are (implicit) conversion
+// from a nullable pointer, the factory `check_not_null`, and
+// `make_not_null_unique`.
 //
-// The following example shows uses of |not_null|:
+// The following example shows uses of `not_null`:
 //   void Accumulate(not_null<int*> const accumulator,
 //                   not_null<int const*> const term) {
 //     *accumulator += *term;  // This will not dereference a null pointer.
@@ -40,7 +40,7 @@
 //   void InterfaceAccumulator(int* const dubious_accumulator,
 //                             int const* const term_of_dubious_c_provenance) {
 //     // The call below performs two checks.  If either parameter is null, the
-//     // program will fail (through a glog |CHECK|) at the callsite.
+//     // program will fail (through a glog `CHECK`) at the callsite.
 //     Accumulate(dubious_accumulator, term_of_dubious_c_provenance);
 //   }
 //
@@ -53,8 +53,8 @@
 //     // ...
 //   }
 //
-// If implicit conversion from a nullable pointer to |not_null| does not work,
-// e.g. for template deduction, use the factory |check_not_null|.
+// If implicit conversion from a nullable pointer to `not_null` does not work,
+// e.g. for template deduction, use the factory `check_not_null`.
 //   template<typename T>
 //   void Foo(not_null<T*> not_null_ptr);
 //
@@ -66,8 +66,8 @@
 //   // It is more concise than the alternative:
 //   Foo(not_null<SomeType*>(ptr))
 //
-// The following optimization is made possible by the use of |not_null|:
-// |term == nullptr| can be expanded to false through inlining, so the branch
+// The following optimization is made possible by the use of `not_null`:
+// `term == nullptr` can be expanded to false through inlining, so the branch
 // will likely be optimized away.
 //   if (term == nullptr) // ...
 //   // Same as above.
@@ -86,9 +86,9 @@ class not_null;
 
 // Type traits.
 
-// |remove_not_null_t<not_null<T>>| is |remove_not_null_t<T>|.  The recurrence
-// ends when |T| is not an instance of |not_null|, in which case
-// |remove_not_null_t<T>| is |T|.
+// `remove_not_null_t<not_null<T>>` is `remove_not_null_t<T>`.  The recurrence
+// ends when `T` is not an instance of `not_null`, in which case
+// `remove_not_null_t<T>` is `T`.
 template<typename Pointer>
 struct remove_not_null : not_constructible {
   using type = Pointer;
@@ -135,33 +135,33 @@ struct NotNullStorage<
   P pointer;
 };
 
-// When |T| is not a reference, |_checked_not_null<T>| is |not_null<T>| if |T|
-// is not already an instance of |not_null|.  It fails otherwise.
-// |_checked_not_null| is invariant under application of reference or rvalue
+// When `T` is not a reference, `_checked_not_null<T>` is `not_null<T>` if `T`
+// is not already an instance of `not_null`.  It fails otherwise.
+// `_checked_not_null` is invariant under application of reference or rvalue
 // reference to its template argument.
 template<typename Pointer>
 using _checked_not_null = std::enable_if_t<
     !is_instance_of_v<not_null, std::remove_reference_t<Pointer>>,
     not_null<std::remove_reference_t<Pointer>>>;
 
-// We cannot refer to the template |not_null| inside of |not_null|.
+// We cannot refer to the template `not_null` inside of `not_null`.
 template<typename Pointer>
 inline constexpr bool is_instance_of_not_null_v =
     is_instance_of_v<not_null, Pointer>;
 
-// |not_null<Pointer>| is a wrapper for a non-null object of type |Pointer|.
-// |Pointer| should be a C-style pointer or a smart pointer.  |Pointer| must not
-// be a const, reference, rvalue reference, or |not_null|.  |not_null<Pointer>|
+// `not_null<Pointer>` is a wrapper for a non-null object of type `Pointer`.
+// `Pointer` should be a C-style pointer or a smart pointer.  `Pointer` must not
+// be a const, reference, rvalue reference, or `not_null`.  `not_null<Pointer>`
 // is movable and may be left in an invalid state when moved, i.e., its
-// |storage_.pointer| may become null.
-// |not_null<not_null<Pointer>>| and |not_null<Pointer>| are equivalent.
-// This is useful when a |template<typename T>| using a |not_null<T>| is
-// instanced with an instance of |not_null|.
+// `storage_.pointer` may become null.
+// `not_null<not_null<Pointer>>` and `not_null<Pointer>` are equivalent.
+// This is useful when a `template<typename T>` using a `not_null<T>` is
+// instanced with an instance of `not_null`.
 template<typename Pointer>
 class not_null final {
  public:
   // The type of the pointer being wrapped.
-  // This follows the naming convention from |std::unique_ptr|.
+  // This follows the naming convention from `std::unique_ptr`.
   using pointer = remove_not_null_t<Pointer>;
 
   // Smart pointers define this type.
@@ -169,7 +169,7 @@ class not_null final {
 
   not_null() = delete;
 
-  // Copy constructor from an other |not_null<Pointer>|.
+  // Copy constructor from an other `not_null<Pointer>`.
   constexpr not_null(not_null const&) = default;
   // Copy contructor for implicitly convertible pointers.
   template<typename OtherPointer,
@@ -190,7 +190,7 @@ class not_null final {
                                    std::declval<OtherPointer>()))>
   constexpr explicit not_null(not_null<OtherPointer> const& other);
 
-  // Move constructor from an other |not_null<Pointer>|.  This constructor may
+  // Move constructor from an other `not_null<Pointer>`.  This constructor may
   // invalidate its argument.
   constexpr not_null(not_null&&) = default;
   // Move contructor for implicitly convertible pointers. This constructor may
@@ -223,17 +223,17 @@ class not_null final {
                std::is_convertible_v<OtherPointer, pointer>>>
   constexpr not_null& operator=(not_null<OtherPointer>&& other);
 
-  // Returns |storage_.pointer|, by const reference to avoid a copy if |pointer|
-  // is |unique_ptr|.
-  // If this were to return by |const&|, ambiguities would arise where an rvalue
-  // of type |not_null<pointer>| is given as an argument to a function that has
-  // overloads for both |pointer const&| and |pointer&&|.
-  // Note that the preference for |T&&| over |T const&| for overload resolution
+  // Returns `storage_.pointer`, by const reference to avoid a copy if `pointer`
+  // is `unique_ptr`.
+  // If this were to return by `const&`, ambiguities would arise where an rvalue
+  // of type `not_null<pointer>` is given as an argument to a function that has
+  // overloads for both `pointer const&` and `pointer&&`.
+  // Note that the preference for `T&&` over `T const&` for overload resolution
   // is not relevant here since both go through a user-defined conversion,
   // see 13.3.3.2.
-  // GCC nevertheless incorrectly prefers |T&&| in that case, while clang and
+  // GCC nevertheless incorrectly prefers `T&&` in that case, while clang and
   // MSVC recognize the ambiguity.
-  // The |RValue| test gives two examples of this.
+  // The `RValue` test gives two examples of this.
   constexpr operator pointer const&&() const&;
 
   template<typename OtherPointer,
@@ -243,7 +243,7 @@ class not_null final {
                !is_instance_of_not_null_v<OtherPointer>>>
   constexpr operator OtherPointer() const&;
 
-  // Used to convert a |not_null<unique_ptr<>>| to |unique_ptr<>|.
+  // Used to convert a `not_null<unique_ptr<>>` to `unique_ptr<>`.
   constexpr operator pointer&&() &&;
 
   template<typename OtherPointer,
@@ -253,37 +253,37 @@ class not_null final {
                !is_instance_of_not_null_v<OtherPointer>>>
   constexpr operator OtherPointer() &&;  // NOLINT(whitespace/operators)
 
-  // Returns |*storage_.pointer|.
+  // Returns `*storage_.pointer`.
   constexpr std::add_lvalue_reference_t<element_type> operator*() const;
   constexpr std::add_pointer_t<element_type> operator->() const;
 
-  // When |pointer| has a |get()| member function, this returns
-  // |storage_.pointer.get()|.
+  // When `pointer` has a `get()` member function, this returns
+  // `storage_.pointer.get()`.
   template<typename P = pointer, typename = decltype(std::declval<P>().get())>
   constexpr not_null<decltype(std::declval<P>().get())> get() const;
 
-  // When |pointer| has a |release()| member function, this returns
-  // |storage_.pointer.release()|.  May invalidate its argument.
+  // When `pointer` has a `release()` member function, this returns
+  // `storage_.pointer.release()`.  May invalidate its argument.
   template<typename P = pointer,
            typename = decltype(std::declval<P>().release())>
   constexpr not_null<decltype(std::declval<P>().release())> release();
 
-  // When |pointer| has a |reset()| member function, this calls
-  // |storage_.pointer.reset()|.
+  // When `pointer` has a `reset()` member function, this calls
+  // `storage_.pointer.reset()`.
   template<typename Q,
            typename P = pointer,
            typename = decltype(std::declval<P>().reset())>
   constexpr void reset(not_null<Q> ptr);
 
-  // The following operators are redundant for valid |not_null<Pointer>|s with
-  // the implicit conversion to |pointer|, but they should allow some
+  // The following operators are redundant for valid `not_null<Pointer>`s with
+  // the implicit conversion to `pointer`, but they should allow some
   // optimization.
 
-  // Returns |false|.
+  // Returns `false`.
   constexpr bool operator==(std::nullptr_t other) const;
-  // Returns |true|.
+  // Returns `true`.
   constexpr bool operator!=(std::nullptr_t other) const;
-  // Returns |true|.
+  // Returns `true`.
   constexpr operator bool() const;
 
   // Equality.
@@ -301,8 +301,8 @@ class not_null final {
  private:
   struct unchecked_tag final {};
 
-  // Creates a |not_null<Pointer>| whose |storage_.pointer| equals the given
-  // |pointer|, dawg.  The constructor does *not* perform a null check.  Callers
+  // Creates a `not_null<Pointer>` whose `storage_.pointer` equals the given
+  // `pointer`, dawg.  The constructor does *not* perform a null check.  Callers
   // must perform one if needed before using it.
   constexpr explicit not_null(pointer other, unchecked_tag tag);
 
@@ -322,27 +322,27 @@ class not_null final {
 };
 
 // We want only one way of doing things, and we can't make
-// |not_null<Pointer> const| and |not_null<Pointer const>| etc. equivalent
+// `not_null<Pointer> const` and `not_null<Pointer const>` etc. equivalent
 // easily.
 
-// Use |not_null<Pointer> const| instead.
+// Use `not_null<Pointer> const` instead.
 template<typename Pointer>
 class not_null<Pointer const>;
-// Use |not_null<Pointer>&| instead.
+// Use `not_null<Pointer>&` instead.
 template<typename Pointer>
 class not_null<Pointer&>;
-// Use |not_null<Pointer>&&| instead.
+// Use `not_null<Pointer>&&` instead.
 template<typename Pointer>
 class not_null<Pointer&&>;
 
 // Factory taking advantage of template argument deduction.  Returns a
-// |not_null<Pointer>| to |*pointer|.  |CHECK|s that |pointer| is not null.
+// `not_null<Pointer>` to `*pointer`.  `CHECK`s that `pointer` is not null.
 template<typename Pointer>
 _checked_not_null<Pointer> check_not_null(Pointer pointer);
 
 #if 0
 // While the above factory would cover this case using the implicit
-// conversion, this results in a redundant |CHECK|.
+// conversion, this results in a redundant `CHECK`.
 // This function returns its argument.
 template<typename Pointer>
 not_null<Pointer> check_not_null(not_null<Pointer> pointer);
@@ -351,10 +351,10 @@ not_null<Pointer> check_not_null(not_null<Pointer> pointer);
 template<typename T, typename... Args>
 not_null<std::shared_ptr<T>> make_not_null_shared(Args&&... args);
 
-// Factory for a |not_null<std::unique_ptr<T>>|, forwards the arguments to the
-// constructor of T.  |make_not_null_unique<T>(args)| is interchangeable with
-// |check_not_null(make_unique<T>(args))|, but does not perform a |CHECK|, since
-// the result of |make_unique| is not null.
+// Factory for a `not_null<std::unique_ptr<T>>`, forwards the arguments to the
+// constructor of T.  `make_not_null_unique<T>(args)` is interchangeable with
+// `check_not_null(make_unique<T>(args))`, but does not perform a `CHECK`, since
+// the result of `make_unique` is not null.
 template<typename T, typename... Args>
 not_null<std::unique_ptr<T>> make_not_null_unique(Args&&... args);
 
diff --git a/base/not_null_body.hpp b/base/not_null_body.hpp
index f5c4ebd96f..3310ec0f77 100644
--- a/base/not_null_body.hpp
+++ b/base/not_null_body.hpp
@@ -67,8 +67,8 @@ constexpr not_null<Pointer>& not_null<Pointer>::operator=(
 
 template<typename Pointer>
 constexpr not_null<Pointer>::operator pointer const&&() const& {
-  // This |move| is deceptive: we are not actually moving anything (|*this| is
-  // |const&|), we are simply casting to an rvalue reference.
+  // This `move` is deceptive: we are not actually moving anything (`*this` is
+  // `const&`), we are simply casting to an rvalue reference.
   return std::move(storage_.pointer);
 }
 
@@ -105,7 +105,7 @@ template<typename Pointer>
 template<typename P, typename>
 constexpr not_null<decltype(std::declval<P>().get())>
 not_null<Pointer>::get() const {
-  // NOTE(egg): no |CHECK| is performed.
+  // NOTE(egg): no `CHECK` is performed.
   using type = decltype(std::declval<P>().get());
   return not_null<type>(storage_.pointer.get(), not_null<type>::unchecked_tag_);
 }
diff --git a/base/not_null_test.cpp b/base/not_null_test.cpp
index eac91ddd24..90460624d0 100644
--- a/base/not_null_test.cpp
+++ b/base/not_null_test.cpp
@@ -224,24 +224,24 @@ TEST_F(NotNullTest, RValue) {
   not_null<std::unique_ptr<int>> not_null_owner_int =
       make_not_null_unique<int>(4);
   std::vector<int*> v1;
-  // |v1.push_back| would be ambiguous here if |not_null<pointer>| had an
-  // |operator pointer const&() const&| instead of an
-  // |operator pointer const&&() const&|.
+  // `v1.push_back` would be ambiguous here if `not_null<pointer>` had an
+  // `operator pointer const&() const&` instead of an
+  // `operator pointer const&&() const&`.
   v1.push_back(not_null_owner_int.get());
-  // |emplace_back| is fine no matter what.
+  // `emplace_back` is fine no matter what.
   v1.emplace_back(not_null_owner_int.get());
   EXPECT_EQ(4, *v1[0]);
   EXPECT_EQ(4, *not_null_owner_int);
 
   std::vector<int*> v2;
   // NOTE(egg): The following fails using clang, I'm not sure where the bug is.
-  // More generally, if functions |foo(int*&&)| and |foo(int* const&)| exist,
-  // |foo(non_rvalue_not_null)| fails to compile with clang ("no viable
-  // conversion"), but without the |foo(int*&&)| overload it compiles.
+  // More generally, if functions `foo(int*&&)` and `foo(int* const&)` exist,
+  // `foo(non_rvalue_not_null)` fails to compile with clang ("no viable
+  // conversion"), but without the `foo(int*&&)` overload it compiles.
   // This is easily circumvented using a temporary (whereas the ambiguity that
-  // would result from having an |operator pointer const&() const&| would
-  // entirely prevent conversion of |not_null<unique_ptr<T>>| to
-  // |unique_ptr<T>|), so we ignore it.
+  // would result from having an `operator pointer const&() const&` would
+  // entirely prevent conversion of `not_null<unique_ptr<T>>` to
+  // `unique_ptr<T>`), so we ignore it.
 #if PRINCIPIA_COMPILER_MSVC
   v2.push_back(not_null_int);
 #else
@@ -251,10 +251,10 @@ TEST_F(NotNullTest, RValue) {
   EXPECT_EQ(2, *v2[0]);
   EXPECT_EQ(2, *not_null_int);
 
-  // |std::unique_ptr<int>::operator=| would be ambiguous here between the move
-  // and copy assignments if |not_null<pointer>| had an
-  // |operator pointer const&() const&| instead of an
-  // |operator pointer const&&() const&|.
+  // `std::unique_ptr<int>::operator=` would be ambiguous here between the move
+  // and copy assignments if `not_null<pointer>` had an
+  // `operator pointer const&() const&` instead of an
+  // `operator pointer const&&() const&`.
   // Note that one of the overloads (the implicit copy assignment operator) is
   // deleted, but this does not matter for overload resolution; however MSVC
   // compiles this even when it is ambiguous, while clang correctly fails.
@@ -264,21 +264,21 @@ TEST_F(NotNullTest, RValue) {
   [[maybe_unused]] int const* access_const_int = not_null_access_int;
 
   not_null<std::shared_ptr<int>> not_null_shared_int = std::make_shared<int>(3);
-  // This exercises |operator OtherPointer() const&|.  The conversion from
-  // |not_null<int*>| to |int const*| does not; instead it goes through the
-  // conversion |not_null<int*>| -> |int*| -> |int const*|, where the latter is
+  // This exercises `operator OtherPointer() const&`.  The conversion from
+  // `not_null<int*>` to `int const*` does not; instead it goes through the
+  // conversion `not_null<int*>` -> `int*` -> `int const*`, where the latter is
   // a qualification adjustment, part of a standard conversion sequence.
   std::shared_ptr<int const> shared_const_int = not_null_shared_int;
 
   // MSVC seems to be confused by templatized move-conversion operators.
 #if PRINCIPIA_COMPILER_MSVC
-  // Uses |not_null(not_null<OtherPointer>&& other)| followed by
-  // |operator pointer&&() &&|, so the first conversion has to be explicit.
+  // Uses `not_null(not_null<OtherPointer>&& other)` followed by
+  // `operator pointer&&() &&`, so the first conversion has to be explicit.
   std::unique_ptr<int const> owner_const_int =
       static_cast<not_null<std::unique_ptr<int const>>>(
           make_not_null_unique<int>(5));
 #else
-  // Uses |operator OtherPointer() &&|.
+  // Uses `operator OtherPointer() &&`.
   std::unique_ptr<int const> owner_const_int = make_not_null_unique<int>(5);
 #endif
   EXPECT_EQ(5, *owner_const_int);
diff --git a/base/optional_logging.hpp b/base/optional_logging.hpp
index e6afcdd372..5bb8f8b22e 100644
--- a/base/optional_logging.hpp
+++ b/base/optional_logging.hpp
@@ -2,7 +2,7 @@
 
 #include <optional>
 
-// We need to pollute the |::| namespace in order for lookup to work, like
+// We need to pollute the `::` namespace in order for lookup to work, like
 // glog/stl_logging.h.  The following caveat from glog/stl_logging.h applies
 // here too.
 
@@ -15,7 +15,7 @@
 //
 // to fix these errors.
 
-// If |optional|, logs |*optional|, otherwise, logs |"nullopt"|.
+// If `optional`, logs `*optional`, otherwise, logs `"nullopt"`.
 template<typename T>
 std::ostream& operator<<(std::ostream& out,
                          std::optional<T> const& optional);
diff --git a/base/pull_serializer.hpp b/base/pull_serializer.hpp
index ec733df3ff..08b4df8790 100644
--- a/base/pull_serializer.hpp
+++ b/base/pull_serializer.hpp
@@ -25,15 +25,15 @@ using namespace principia::base::_not_null;
 using ::google::compression::Compressor;
 
 // An output stream based on an array that delegates to a function the handling
-// of the case where one array is full.  It calls the |on_full| function passed
+// of the case where one array is full.  It calls the `on_full` function passed
 // at construction and proceeds with filling the array returned by that
 // function.
 class DelegatingArrayOutputStream
     : public google::protobuf::io::ZeroCopyOutputStream {
  public:
-  // The stream is supported by |bytes.data| which has size |bytes.size|.  Once
-  // that array has been filled, |on_full| is called to somehow consume the
-  // data.  |on_full| also returns another array where the stream may output
+  // The stream is supported by `bytes.data` which has size `bytes.size`.  Once
+  // that array has been filled, `on_full` is called to somehow consume the
+  // data.  `on_full` also returns another array where the stream may output
   // more data.
   DelegatingArrayOutputStream(
       Array<std::uint8_t> bytes,
@@ -55,49 +55,49 @@ class DelegatingArrayOutputStream
 };
 
 // This class support serialization which is "pulled" by the client.  That is,
-// the client creates a |PullSerializer| object, calls |Start| to start the
-// serialization process, repeatedly calls |Pull| to obtain a chunk of data, and
-// finally destroys the |PullSerializer|.  |PullSerializer| is intended for use
+// the client creates a `PullSerializer` object, calls `Start` to start the
+// serialization process, repeatedly calls `Pull` to obtain a chunk of data, and
+// finally destroys the `PullSerializer`.  `PullSerializer` is intended for use
 // in memory-critical contexts as it bounds the amount of memory used
 // irrespective of the size of the message to serialize.
 class PullSerializer final {
  public:
-  // The |size| of the data objects enqueued by |Push| is never greater than
-  // |chunk_size|.  At most |number_of_chunks| chunks are held in the internal
+  // The `size` of the data objects enqueued by `Push` is never greater than
+  // `chunk_size`.  At most `number_of_chunks` chunks are held in the internal
   // queue.  This class uses at most
-  // |number_of_chunks * (chunk_size + O(1)) + O(1)| bytes.  Note that in the
-  // presence of compression |chunk_size| is replaced by |compressed_chunk_size|
+  // `number_of_chunks * (chunk_size + O(1)) + O(1)` bytes.  Note that in the
+  // presence of compression `chunk_size` is replaced by `compressed_chunk_size`
   // in this formula.
   PullSerializer(int chunk_size,
                  int number_of_chunks,
                  std::unique_ptr<Compressor> compressor);
   ~PullSerializer();
 
-  // Starts the serializer, which will proceed to serialize |message|.  This
+  // Starts the serializer, which will proceed to serialize `message`.  This
   // method must be called at most once for each serializer object.
   void Start(
       not_null<std::unique_ptr<google::protobuf::Message const>> message);
   void Start(not_null<google::protobuf::Message const*> message);
 
   // Obtain the next chunk of data from the serializer.  Blocks if no data is
-  // available.  Returns a |Array<std::uint8_t>| object of |size| 0 at the end
+  // available.  Returns a `Array<std::uint8_t>` object of `size` 0 at the end
   // of the serialization.  The returned object may become invalid the next time
-  // |Pull| is called.
-  // In the absence of compression, the data produced by |Pull| constitute a
+  // `Pull` is called.
+  // In the absence of compression, the data produced by `Pull` constitute a
   // stream and the boundaries between chunks are irrelevant.  In the presence
-  // of compression however, the data producted by |Pull| are made of blocks and
+  // of compression however, the data producted by `Pull` are made of blocks and
   // the boundaries between chunks are relevant and must be preserved by the
   // clients and used when feeding data back to the deserializer.
   Array<std::uint8_t> Pull();
 
  private:
-  // Enqueues the chunk of data to be returned to |Pull| and returns a free
+  // Enqueues the chunk of data to be returned to `Pull` and returns a free
   // chunk.  Blocks if there are no free chunks.  Used as a callback for the
-  // underlying |DelegatingArrayOutputStream|.
+  // underlying `DelegatingArrayOutputStream`.
   Array<std::uint8_t> Push(Array<std::uint8_t> bytes);
 
-  // |owned_message_| is null if this object doesn't own the message.
-  // |message_| is non-null after Start.
+  // `owned_message_` is null if this object doesn't own the message.
+  // `message_` is non-null after Start.
   std::unique_ptr<google::protobuf::Message const> owned_message_;
   google::protobuf::Message const* message_ = nullptr;
 
@@ -107,15 +107,15 @@ class PullSerializer final {
   // size.
   int const chunk_size_;
 
-  // The maximum size of a chunk after compression.  Greater than |chunk_size_|
+  // The maximum size of a chunk after compression.  Greater than `chunk_size_`
   // because the compressor will occasionally expand data.  This is the size of
-  // the chunks in |data_|.
+  // the chunks in `data_`.
   int const compressed_chunk_size_;
 
-  // The number of chunks passed at construction, used to size |data_|.
+  // The number of chunks passed at construction, used to size `data_`.
   int const number_of_chunks_;
 
-  // How many of the |number_of_chunks_| chunks in |data_| are reserved for
+  // How many of the `number_of_chunks_` chunks in `data_` are reserved for
   // compression.
   int const number_of_compression_chunks_;
 
@@ -128,15 +128,15 @@ class PullSerializer final {
 
   absl::Mutex lock_;
 
-  // The |queue_| contains the |Array<std::uint8_t>| objects filled by |Push|
-  // and not yet consumed by |Pull|.  If a |Array<std::uint8_t>| object has been
-  // handed over to the caller by |Pull| it stays in the queue until the next
-  // call to |Pull|, to make sure that the pointer is not reused while the
+  // The `queue_` contains the `Array<std::uint8_t>` objects filled by `Push`
+  // and not yet consumed by `Pull`.  If a `Array<std::uint8_t>` object has been
+  // handed over to the caller by `Pull` it stays in the queue until the next
+  // call to `Pull`, to make sure that the pointer is not reused while the
   // caller processes it.
   std::queue<Array<std::uint8_t>> queue_ GUARDED_BY(lock_);
 
-  // The |free_| queue contains the start addresses of chunks that are not yet
-  // ready to be returned by |Pull|.  That includes the chunk currently being
+  // The `free_` queue contains the start addresses of chunks that are not yet
+  // ready to be returned by `Pull`.  That includes the chunk currently being
   // filled by the stream.
   std::queue<not_null<std::uint8_t*>> free_ GUARDED_BY(lock_);
 };
diff --git a/base/pull_serializer_body.hpp b/base/pull_serializer_body.hpp
index 5c434e7f79..59abe81b92 100644
--- a/base/pull_serializer_body.hpp
+++ b/base/pull_serializer_body.hpp
@@ -84,9 +84,9 @@ inline PullSerializer::PullSerializer(int const chunk_size,
   CHECK_GT(number_of_chunks_ - number_of_compression_chunks_ - 1, 1);
 
   // Mark all the chunks as free except the last one which is a sentinel for the
-  // |queue_|.  The 0th chunk has been passed to the stream, but it's still free
-  // until the first call to |on_full|.  Note that the last
-  // |compressed_chunk_size_ - chunk_size_| bytes of each chunk are not
+  // `queue_`.  The 0th chunk has been passed to the stream, but it's still free
+  // until the first call to `on_full`.  Note that the last
+  // `compressed_chunk_size_ - chunk_size_` bytes of each chunk are not
   // considered as free.
   for (int i = 0; i < number_of_chunks_ - 1; ++i) {
     free_.push(data_.get() + i * compressed_chunk_size_);
@@ -131,7 +131,7 @@ inline Array<std::uint8_t> PullSerializer::Pull() {
     absl::MutexLock l(&lock_);
 
     // The element at the front of the queue is the one that was last returned
-    // by |Pull| and must be dropped and freed.
+    // by `Pull` and must be dropped and freed.
     auto const queue_has_elements = [this]() { return queue_.size() > 1; };
     lock_.Await(absl::Condition(&queue_has_elements));
 
@@ -158,7 +158,7 @@ inline Array<std::uint8_t> PullSerializer::Push(Array<std::uint8_t> bytes) {
       free_.push(bytes.data);
     }
     // We maintain the invariant that the chunk being filled is at the front of
-    // the |free_| queue.
+    // the `free_` queue.
     ArraySource<std::uint8_t> source(bytes);
     ArraySink<std::uint8_t> sink(compressed_bytes);
     compressor_->CompressStream(&source, &sink);
@@ -172,8 +172,8 @@ inline Array<std::uint8_t> PullSerializer::Push(Array<std::uint8_t> bytes) {
 
     auto const queue_has_room = [this]() {
       // -1 here is because we want to ensure that there is an entry in the
-      // free list, in addition to |result| and to
-      // |number_of_compression_chunks_| (if present).
+      // free list, in addition to `result` and to
+      // `number_of_compression_chunks_` (if present).
       return queue_.size() < static_cast<std::size_t>(number_of_chunks_) -
                                  number_of_compression_chunks_ - 1;
     };
diff --git a/base/push_deserializer.hpp b/base/push_deserializer.hpp
index 9ef1afbeb5..f5f37fcd77 100644
--- a/base/push_deserializer.hpp
+++ b/base/push_deserializer.hpp
@@ -26,7 +26,7 @@ using namespace principia::base::_not_null;
 using ::google::compression::Compressor;
 
 // An input stream based on an array that delegates to a function the handling
-// of the case where the array is empty.  It calls the |on_empty| function
+// of the case where the array is empty.  It calls the `on_empty` function
 // passed at construction and proceeds with deserializing the array returned by
 // that function.
 class DelegatingArrayInputStream
@@ -58,27 +58,27 @@ std::ostream& operator<<(std::ostream& out,
                          DelegatingArrayInputStream const& stream);
 
 // This class support deserialization which is "pushed" by the client.  That is,
-// the client creates a |PushDeserializer| object, calls |Start| to start the
-// deserialization process, repeatedly calls |Push| to send chunks of data for
-// deserialization, and finally destroys the |PushDeserializer|.
-// |PushDeserializer| is intended for use in memory-critical contexts as it
+// the client creates a `PushDeserializer` object, calls `Start` to start the
+// deserialization process, repeatedly calls `Push` to send chunks of data for
+// deserialization, and finally destroys the `PushDeserializer`.
+// `PushDeserializer` is intended for use in memory-critical contexts as it
 // bounds the amount of memory used irrespective of the size of the message to
 // deserialize.
 class PushDeserializer final {
  public:
-  // The |size| of the data chunks sent to |Pull| are never greater than
-  // |chunk_size|.  The internal queue holds at most |number_of_chunks| chunks.
+  // The `size` of the data chunks sent to `Pull` are never greater than
+  // `chunk_size`.  The internal queue holds at most `number_of_chunks` chunks.
   // Therefore, this class uses at most
-  // |number_of_chunks * (chunk_size + O(1)) + O(1)| bytes.
+  // `number_of_chunks * (chunk_size + O(1)) + O(1)` bytes.
   PushDeserializer(int chunk_size,
                    int number_of_chunks,
                    std::unique_ptr<Compressor> compressor);
   ~PushDeserializer();
 
   // Starts the deserializer, which will proceed to deserialize data into
-  // |message|.  This method must be called at most once for each deserializer
-  // object.  The |done| callback is called once deserialization has completed
-  // (which only happens once the client has called |Push| with a chunk of size
+  // `message`.  This method must be called at most once for each deserializer
+  // object.  The `done` callback is called once deserialization has completed
+  // (which only happens once the client has called `Push` with a chunk of size
   // 0).
   void Start(not_null<std::unique_ptr<google::protobuf::Message>> message,
              std::function<void(google::protobuf::Message const&)> done);
@@ -86,12 +86,12 @@ class PushDeserializer final {
              std::function<void(google::protobuf::Message const&)> done);
 
   // Pushes in the internal queue chunks of data that will be extracted by
-  // |Pull|.  Splits |bytes| into chunks of at most |chunk_size|.  May block to
+  // `Pull`.  Splits `bytes` into chunks of at most `chunk_size`.  May block to
   // stay within the maximum size of the queue.  The caller must push an object
-  // of size 0 to signal the end of input.  |done| is called once the
-  // serialization of |bytes| is complete.  The client must ensure that |bytes|
-  // remains live until the call to |done|.  It may reclaim any memory
-  // associated with |bytes| in |done|.
+  // of size 0 to signal the end of input.  `done` is called once the
+  // serialization of `bytes` is complete.  The client must ensure that `bytes`
+  // remains live until the call to `done`.  It may reclaim any memory
+  // associated with `bytes` in `done`.
   void Push(Array<std::uint8_t> bytes, std::function<void()> done);
 
   // Same as above but ownership is taken.
@@ -100,11 +100,11 @@ class PushDeserializer final {
  private:
   // Obtains the next chunk of data from the internal queue.  Blocks if no data
   // is available.  Used as a callback for the underlying
-  // |DelegatingArrayOutputStream|.
+  // `DelegatingArrayOutputStream`.
   Array<std::uint8_t> Pull();
 
-  // |owned_message_| is null if this object doesn't own the message.
-  // |message_| is non-null after Start.
+  // `owned_message_` is null if this object doesn't own the message.
+  // `message_` is non-null after Start.
   std::unique_ptr<google::protobuf::Message> owned_message_;
   google::protobuf::Message* message_ = nullptr;
 
@@ -114,12 +114,12 @@ class PushDeserializer final {
   // size.
   int const chunk_size_;
 
-  // The maximum size of a chunk after compression.  Greater than |chunk_size_|
+  // The maximum size of a chunk after compression.  Greater than `chunk_size_`
   // because the compressor will occasionally expand data.  This is the
-  // maximum size of the chunks passed to |Push| by the client.
+  // maximum size of the chunks passed to `Push` by the client.
   int const compressed_chunk_size_;
 
-  // The number of chunks passed at construction, used to size |data_|.
+  // The number of chunks passed at construction, used to size `data_`.
   int const number_of_chunks_;
 
   UniqueArray<std::uint8_t> uncompressed_data_;
@@ -129,11 +129,11 @@ class PushDeserializer final {
 
   absl::Mutex lock_;
 
-  // The |queue_| contains the |Array<std::uint8_t>| object filled by |Push| and
-  // not yet consumed by |Pull|.  The |done_| queue contains the callbacks.  The
-  // two queues are out of step: an element is removed from |queue_| by |Pull|
+  // The `queue_` contains the `Array<std::uint8_t>` object filled by `Push` and
+  // not yet consumed by `Pull`.  The `done_` queue contains the callbacks.  The
+  // two queues are out of step: an element is removed from `queue_` by `Pull`
   // when it returns a chunk to the stream, but the corresponding callback is
-  // removed from |done_| (and executed) when |Pull| returns.
+  // removed from `done_` (and executed) when `Pull` returns.
   std::queue<Array<std::uint8_t>> queue_ GUARDED_BY(lock_);
   std::queue<std::function<void()>> done_ GUARDED_BY(lock_);
 };
diff --git a/base/push_deserializer_body.hpp b/base/push_deserializer_body.hpp
index f5727032af..bb963379ae 100644
--- a/base/push_deserializer_body.hpp
+++ b/base/push_deserializer_body.hpp
@@ -167,11 +167,11 @@ inline void PushDeserializer::Start(
 
 inline void PushDeserializer::Push(Array<std::uint8_t> const bytes,
                                    std::function<void()> done) {
-  // Slice the incoming data in chunks of size at most |chunk_size|.  Release
+  // Slice the incoming data in chunks of size at most `chunk_size`.  Release
   // the lock after each chunk to give the deserializer a chance to run.  This
-  // method should be called with |bytes| of size 0 to terminate the
+  // method should be called with `bytes` of size 0 to terminate the
   // deserialization, but it never generates a chunk of size 0 in other
-  // circumstances.  The |done| callback is attached to the last chunk.
+  // circumstances.  The `done` callback is attached to the last chunk.
   Array<std::uint8_t> current = bytes;
   CHECK_LE(0, bytes.size);
 
@@ -223,7 +223,7 @@ inline Array<std::uint8_t> PushDeserializer::Pull() {
     auto const queue_has_elements =  [this]() { return !queue_.empty(); };
     lock_.Await(absl::Condition(&queue_has_elements));
 
-    // The front of |done_| is the callback for the |Array<std::uint8_t>| object
+    // The front of `done_` is the callback for the `Array<std::uint8_t>` object
     // that was just processed.  Run it now.
     CHECK(!done_.empty());
     auto const done = done_.front();
@@ -231,8 +231,8 @@ inline Array<std::uint8_t> PushDeserializer::Pull() {
       done();
     }
     done_.pop();
-    // Get the next |Array<std::uint8_t>| object to process and remove it from
-    // |queue_|.  Uncompress it if needed.
+    // Get the next `Array<std::uint8_t>` object to process and remove it from
+    // `queue_`.  Uncompress it if needed.
     auto const& front = queue_.front();
     if (front.size == 0 || compressor_ == nullptr) {
       result = front;
diff --git a/base/push_deserializer_test.cpp b/base/push_deserializer_test.cpp
index 9b11b7b94e..c189ac9088 100644
--- a/base/push_deserializer_test.cpp
+++ b/base/push_deserializer_test.cpp
@@ -153,7 +153,7 @@ class PushDeserializerTest : public ::testing::Test {
       }
 
       // Destroying the deserializer waits until deserialization is done.  It is
-      // important that this happens before |storage| is destroyed.
+      // important that this happens before `storage` is destroyed.
       pull_serializer_.reset();
       push_deserializer_.reset();
     }
diff --git a/base/push_pull_callback.hpp b/base/push_pull_callback.hpp
index aad6d16053..300dfc3f63 100644
--- a/base/push_pull_callback.hpp
+++ b/base/push_pull_callback.hpp
@@ -22,13 +22,13 @@ namespace internal {
 // expect the managed code to pull the arguments and push the result of the
 // computations that it is executing.
 // Note that calling the managed and unmanaged APIs from the same thread will
-// inevitably cause deadlocks.  See |PushPullExecutor| below for a solution to
+// inevitably cause deadlocks.  See `PushPullExecutor` below for a solution to
 // this.
 template<typename Result, typename... Arguments>
 class PushPullCallback {
  public:
   // The managed API, called to extract the arguments for the unmanaged callback
-  // and return its result.  |Pull| returns false if there are no more arguments
+  // and return its result.  `Pull` returns false if there are no more arguments
   // to be processed and the managed code should stop its iteration.
   bool Pull(Arguments&... arguments);
   void Push(Result result);
@@ -38,16 +38,16 @@ class PushPullCallback {
   std::function<Result(Arguments...)> ToStdFunction();
 
   // Used on the unmanaged side to indicate that the computation has finished.
-  // After a call to this method, |Pull| always returns false.
+  // After a call to this method, `Pull` always returns false.
   void Shutdown();
 
  private:
-  // The unmanaged API, called by the function returned by |ToStdFunction|.
+  // The unmanaged API, called by the function returned by `ToStdFunction`.
   void Push(Arguments... arguments);
   Result Pull();
 
-  // These functions return a (held) |MutexLock| that the caller should use to
-  // ensure proper release of |lock_|.
+  // These functions return a (held) `MutexLock` that the caller should use to
+  // ensure proper release of `lock_`.
   std::unique_ptr<absl::MutexLock> WaitUntilHasArgumentsOrShuttingDownAndLock();
   std::unique_ptr<absl::MutexLock> WaitUntilHasResultAndLock();
 
@@ -58,8 +58,8 @@ class PushPullCallback {
 };
 
 // A helper class to execute a task that takes a callback from unmanaged code to
-// managed code and returns a value of type |T|.  The task is executed on a
-// separate thread, so calls to the|PushPullCallback| don't cause deadlocks.
+// managed code and returns a value of type `T`.  The task is executed on a
+// separate thread, so calls to the`PushPullCallback` don't cause deadlocks.
 template<typename T,
          typename Result, typename... Arguments>
 class PushPullExecutor {
@@ -69,13 +69,13 @@ class PushPullExecutor {
   explicit PushPullExecutor(Task task);
   ~PushPullExecutor();
 
-  // Returns the internal |PushPullCallback| object that is used by the managed
+  // Returns the internal `PushPullCallback` object that is used by the managed
   // code to pull arguments and push results.
   PushPullCallback<Result, Arguments...>& callback();
   PushPullCallback<Result, Arguments...> const& callback() const;
 
   // Returns the result of the task passed at construction.  Must only be called
-  // once |PushPullCallback::Pull| has indicated that the task has finished.
+  // once `PushPullCallback::Pull` has indicated that the task has finished.
   T get();
 
  private:
diff --git a/base/push_pull_callback_test.cpp b/base/push_pull_callback_test.cpp
index 9797c7e9bb..4218efd5b0 100644
--- a/base/push_pull_callback_test.cpp
+++ b/base/push_pull_callback_test.cpp
@@ -10,7 +10,7 @@ namespace base {
 using namespace principia::base::_push_pull_callback;
 
 TEST(PushPullCallback, Test) {
-  // A task that does some computation, including running its callback |f| with
+  // A task that does some computation, including running its callback `f` with
   // various arguments.
   auto task = [](std::function<int(int left, int right)> const& f) {
     double const a = f(2, 4);
diff --git a/base/recurring_thread.hpp b/base/recurring_thread.hpp
index 1c826a25e1..c7b71dc23a 100644
--- a/base/recurring_thread.hpp
+++ b/base/recurring_thread.hpp
@@ -19,7 +19,7 @@ using namespace principia::base::_jthread;
 
 // A stoppable thread that supports cyclical execution of an action.  It is
 // connected to two monodirectional channels that can (optionally) hold a value
-// of |Input| (for incoming data) or |Output| (for outgoing data), respectively.
+// of `Input` (for incoming data) or `Output` (for outgoing data), respectively.
 // The action is run to transform the input into the output.  This class and its
 // subclasses are thread-safe.  The base class is used to factor code common to
 // the various template specializations and should not be used directly.
@@ -37,7 +37,7 @@ class BaseRecurringThread {
 
  protected:
   // Constructs a stoppable thread that runs no more frequently than at the
-  // specified |period| (and less frequently if no input was provided).  At
+  // specified `period` (and less frequently if no input was provided).  At
   // construction the thread is in the stopped state.
   explicit BaseRecurringThread(std::chrono::milliseconds period);
 
@@ -61,15 +61,15 @@ class RecurringThread : public BaseRecurringThread {
   // If an action returns an error, no output in written to the output channel.
   using Action = std::function<absl::StatusOr<Output>(Input)>;
 
-  // Constructs a stoppable thread that executes the given |action| no more
-  // frequently than at the specified |period| (and less frequently if no input
+  // Constructs a stoppable thread that executes the given `action` no more
+  // frequently than at the specified `period` (and less frequently if no input
   // was provided).  At construction the thread is in the stopped state.
   RecurringThread(Action action,
                   std::chrono::milliseconds period);
 
-  // Overwrites the contents of the input channel.  The |input| data will be
-  // either picked by the next execution of |action|, or overwritten by the next
-  // call to |Put|.
+  // Overwrites the contents of the input channel.  The `input` data will be
+  // either picked by the next execution of `action`, or overwritten by the next
+  // call to `Put`.
   void Put(Input input);
 
   // Extracts data from the output channel, if there is any.
@@ -91,15 +91,15 @@ class RecurringThread<Input, void> : public BaseRecurringThread {
  public:
   using Action = std::function<absl::Status(Input)>;
 
-  // Constructs a stoppable thread that executes the given |action| no more
-  // frequently than at the specified |period| (and less frequently if no input
+  // Constructs a stoppable thread that executes the given `action` no more
+  // frequently than at the specified `period` (and less frequently if no input
   // was provided).  At construction the thread is in the stopped state.
   RecurringThread(Action action,
                   std::chrono::milliseconds period);
 
-  // Overwrites the contents of the input channel.  The |input| data will be
-  // either picked by the next execution of |action|, or overwritten by the next
-  // call to |Put|.
+  // Overwrites the contents of the input channel.  The `input` data will be
+  // either picked by the next execution of `action`, or overwritten by the next
+  // call to `Put`.
   void Put(Input input);
 
  private:
diff --git a/base/thread_pool.hpp b/base/thread_pool.hpp
index 518069b517..24ec9252c9 100644
--- a/base/thread_pool.hpp
+++ b/base/thread_pool.hpp
@@ -26,23 +26,23 @@ class ThreadPool final {
   ~ThreadPool();
 
   // Adds a call to the execution queue, and returns a future that the client
-  // may use to wait until execution of |function| has completed and to extract
+  // may use to wait until execution of `function` has completed and to extract
   // the result.
   std::future<T> Add(std::function<T()> function);
 
-  // Same as above, but only returns a future if the |function| can be
+  // Same as above, but only returns a future if the `function` can be
   // immediately executed.
   std::optional<std::future<T>> TryAdd(std::function<T()> function);
 
-  // Waits until the pool has at least one idle thread (that is, |TryAdd| would
-  // succeed at that point) or the specified |duration| is reached.  Returns
+  // Waits until the pool has at least one idle thread (that is, `TryAdd` would
+  // succeed at that point) or the specified `duration` is reached.  Returns
   // true iff there is an idle thread.  Note that there is no guarantee that a
-  // subsequent call to |TryAdd| will succeed.  This is mostly useful to avoid
-  // busy waiting on |TryAdd|.
+  // subsequent call to `TryAdd` will succeed.  This is mostly useful to avoid
+  // busy waiting on `TryAdd`.
   bool WaitUntilIdleFor(absl::Duration duration);
 
  private:
-  // The queue element contains a |function| to execute and a |promise| used to
+  // The queue element contains a `function` to execute and a `promise` used to
   // communicate the result to the caller.
   struct Call {
     std::function<T()> function;
diff --git a/base/thread_pool_body.hpp b/base/thread_pool_body.hpp
index a129880a2b..36415c8688 100644
--- a/base/thread_pool_body.hpp
+++ b/base/thread_pool_body.hpp
@@ -58,7 +58,7 @@ std::optional<std::future<T>>
 ThreadPool<T>::TryAdd(std::function<T()> function) {
   std::optional<std::future<T>> result;
 
-  // We use double locking to avoid contention when |TryAdd| fails.
+  // We use double locking to avoid contention when `TryAdd` fails.
   lock_.ReaderLock();
   std::int64_t const idle_threads = threads_.size() - busy_threads_;
   if (calls_.size() + 1 <= idle_threads) {
@@ -116,7 +116,7 @@ void ThreadPool<T>::DequeueCallAndExecute() {
       ++busy_threads_;
     }
 
-    // Execute the function without holding the |lock_| as it might take some
+    // Execute the function without holding the `lock_` as it might take some
     // time.
     ExecuteAndSetValue(this_call.function, this_call.promise);
 
diff --git a/base/thread_pool_test.cpp b/base/thread_pool_test.cpp
index 3bd721fa82..8fb71b1247 100644
--- a/base/thread_pool_test.cpp
+++ b/base/thread_pool_test.cpp
@@ -27,7 +27,7 @@ class ThreadPoolTest : public ::testing::Test {
 };
 
 // Check that execution occurs in parallel.  If things were sequential, the
-// integers in |numbers| would be monotonically increasing.
+// integers in `numbers` would be monotonically increasing.
 TEST_F(ThreadPoolTest, ParallelExecution) {
 #if defined(_DEBUG)
   constexpr int number_of_calls = 100'000;
@@ -73,7 +73,7 @@ TEST_F(ThreadPoolTest, TryAdd) {
   EXPECT_EQ(std::nullopt,
             pool.TryAdd([]() { LOG(FATAL) << "Should not run"; }));
 
-  // Release one of the executing threads.  Now |TryAdd| should work and the
+  // Release one of the executing threads.  Now `TryAdd` should work and the
   // function should run.
   proceed1.Notify();
   std::this_thread::sleep_for(100ms);
@@ -98,7 +98,7 @@ TEST_F(ThreadPoolTest, WaitUntilIdleFor) {
   // Wait until a thread becomes idle.  That doesn't happen, so we timeout.
   EXPECT_FALSE(pool.WaitUntilIdleFor(absl::Milliseconds(100)));
 
-  // Release one of the executing threads.  Now |WaitUntilIdleFor| should see
+  // Release one of the executing threads.  Now `WaitUntilIdleFor` should see
   // that there is an idle thread.
   proceed1.Notify();
   std::this_thread::sleep_for(100ms);
diff --git a/base/traits_test.cpp b/base/traits_test.cpp
index df4c4a32c4..18398d271a 100644
--- a/base/traits_test.cpp
+++ b/base/traits_test.cpp
@@ -17,7 +17,7 @@ using AliasT1 = T1<T>;
 static_assert(is_instance_of_v<T1, T1<int>>);
 static_assert(!is_instance_of_v<T2, T1<int>>);
 
-// Note that |is_instance_of| does not work on alias templates.
+// Note that `is_instance_of` does not work on alias templates.
 static_assert(!is_instance_of_v<AliasT1, T1<int>>);
 
 
diff --git a/base/unique_ptr_logging.hpp b/base/unique_ptr_logging.hpp
index 5a59834105..f62affb7f5 100644
--- a/base/unique_ptr_logging.hpp
+++ b/base/unique_ptr_logging.hpp
@@ -2,7 +2,7 @@
 
 #include <memory>
 
-// We need to pollute the |::| namespace in order for lookup to work, like
+// We need to pollute the `::` namespace in order for lookup to work, like
 // glog/stl_logging.h.  The following caveat from glog/stl_logging.h applies
 // here too.
 
diff --git a/base/zfp_compressor.hpp b/base/zfp_compressor.hpp
index aec7446fd3..67fca81f3f 100644
--- a/base/zfp_compressor.hpp
+++ b/base/zfp_compressor.hpp
@@ -36,8 +36,8 @@ class ZfpCompressor {
 
   // Serialization/deserialization of a vector of double into a message using an
   // D-dimensional encoding.  This encodes blocks of 4^D doubles and therefore
-  // takes advantage of any correlation across these doubles.  The vector |v|
-  // may be modified by padding it with zeroes.  When reading, the |message|
+  // takes advantage of any correlation across these doubles.  The vector `v`
+  // may be modified by padding it with zeroes.  When reading, the `message`
   // parameter is updated to reflect the data that was consumed.
   template<int D>
   void WriteToMessageMultidimensional(std::vector<double>& v,
@@ -48,7 +48,7 @@ class ZfpCompressor {
 
   // Low-level API: serialization/deserialization of a field (allocated and
   // owned by the caller) into a message (which is expected to by a bytes field
-  // of a proto).  When reading, the |message| parameter is updated to reflect
+  // of a proto).  When reading, the `message` parameter is updated to reflect
   // the data that was consumed.
   void WriteToMessage(const zfp_field* field,
                       not_null<std::string*> message) const;
diff --git a/benchmarks/discrete_trajectory_benchmark.cpp b/benchmarks/discrete_trajectory_benchmark.cpp
index 5bc050f986..23a9a5e6ff 100644
--- a/benchmarks/discrete_trajectory_benchmark.cpp
+++ b/benchmarks/discrete_trajectory_benchmark.cpp
@@ -35,8 +35,8 @@ using namespace principia::testing_utilities::_discrete_trajectory_factories;
 
 namespace {
 
-// Constructs a trajectory by assigning the points in |timeline| to segments
-// defined by |splits|, which must be doubles in [0, 1].
+// Constructs a trajectory by assigning the points in `timeline` to segments
+// defined by `splits`, which must be doubles in [0, 1].
 DiscreteTrajectory<World> MakeTrajectory(Timeline<World> const& timeline,
                                          std::vector<double> const& splits) {
   DiscreteTrajectory<World> trajectory;
@@ -45,7 +45,7 @@ DiscreteTrajectory<World> MakeTrajectory(Timeline<World> const& timeline,
   auto it_split = splits.begin();
   std::optional<Instant> t_split;
   for (auto const& [t, degrees_of_freedom] : timeline) {
-    // The computation of |t_split| is complicated enough that we want to do it
+    // The computation of `t_split` is complicated enough that we want to do it
     // at a single place.
     if (!t_split.has_value()) {
       if (it_split == splits.end()) {
diff --git a/benchmarks/elementary_functions_experiments_benchmark.cpp b/benchmarks/elementary_functions_experiments_benchmark.cpp
index 70b8c46110..c651072f26 100644
--- a/benchmarks/elementary_functions_experiments_benchmark.cpp
+++ b/benchmarks/elementary_functions_experiments_benchmark.cpp
@@ -126,7 +126,7 @@ class MultiTableImplementation {
 
   template<FMAPolicy fma_policy>
   static Value SinPolynomial(Argument x);
-  // |i| is the index of the binade in |cutoffs_|,
+  // `i` is the index of the binade in `cutoffs_`,
   template<FMAPolicy fma_policy>
   static Value CosPolynomial(std::int64_t i, Argument x);
 
@@ -238,7 +238,7 @@ class NearZeroImplementation {
       accurate_values_;
 };
 
-// Same as |NearZeroImplementation|, but evaluates the cost of the dynamic FMA
+// Same as `NearZeroImplementation`, but evaluates the cost of the dynamic FMA
 // determination.
 class FMAImplementation {
  public:
@@ -458,7 +458,7 @@ void MultiTableImplementation::SelectCutoff(Argument const x,
                                             Argument& cutoff) {
   // The details of this code have a measurable performance impact.  It does on
   // average 2.30 comparisons.  That's more than a naive loop starting at
-  // |k = 0| (which would do 2.28 comparisons) but it's faster in practice.
+  // `k = 0` (which would do 2.28 comparisons) but it's faster in practice.
   if (x <= cutoffs[1]) {
     // Because the intervals are unequal, this loop does on average 1.93
     // comparisons.
diff --git a/benchmarks/encoder_benchmark.cpp b/benchmarks/encoder_benchmark.cpp
index 52cac5d529..569f7b2589 100644
--- a/benchmarks/encoder_benchmark.cpp
+++ b/benchmarks/encoder_benchmark.cpp
@@ -10,7 +10,7 @@
 #include "base/macros.hpp"  // 🧙 For PRINCIPIA_COMPILER_MSVC.
 #include "benchmark/benchmark.h"
 
-// Clang doesn't have a correct |std::array| yet, and we don't actually use this
+// Clang doesn't have a correct `std::array` yet, and we don't actually use this
 // code, so let's get rid of the entire body.
 #if PRINCIPIA_COMPILER_MSVC
 
diff --git "a/benchmarks/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_benchmark.cpp" "b/benchmarks/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_benchmark.cpp"
index f34c61ae9f..17809f5fd4 100644
--- "a/benchmarks/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_benchmark.cpp"
+++ "b/benchmarks/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_benchmark.cpp"
@@ -54,7 +54,7 @@ void BM_EvaluatePolynomialInЧебышёвBasisDouble(benchmark::State& state) {
     }
   }
 
-  // This weird call to |SetLabel| has no effect except that it uses |result|
+  // This weird call to `SetLabel` has no effect except that it uses `result`
   // and therefore prevents the loop from being optimized away.
   state.SetLabel(std::to_string(result).substr(0, 0));
 }
@@ -83,7 +83,7 @@ void BM_EvaluatePolynomialInЧебышёвBasisQuantity(benchmark::State& state)
     }
   }
 
-  // This weird call to |SetLabel| has no effect except that it uses |result|
+  // This weird call to `SetLabel` has no effect except that it uses `result`
   // and therefore prevents the loop from being optimized away.
   std::stringstream ss;
   ss << result;
@@ -117,7 +117,7 @@ void BM_EvaluatePolynomialInЧебышёвBasisR3ElementDouble(
     }
   }
 
-  // This weird call to |SetLabel| has no effect except that it uses |result|
+  // This weird call to `SetLabel` has no effect except that it uses `result`
   // and therefore prevents the loop from being optimized away.
   std::stringstream ss;
   ss << result;
@@ -152,7 +152,7 @@ void BM_EvaluatePolynomialInЧебышёвBasisVectorDouble(
     }
   }
 
-  // This weird call to |SetLabel| has no effect except that it uses |result|
+  // This weird call to `SetLabel` has no effect except that it uses `result`
   // and therefore prevents the loop from being optimized away.
   std::stringstream ss;
   ss << result;
@@ -187,7 +187,7 @@ void BM_EvaluatePolynomialInЧебышёвBasisDisplacement(
     }
   }
 
-  // This weird call to |SetLabel| has no effect except that it uses |result|
+  // This weird call to `SetLabel` has no effect except that it uses `result`
   // and therefore prevents the loop from being optimized away.
   std::stringstream ss;
   ss << result;
diff --git a/benchmarks/rigid_reference_frame_benchmark.cpp b/benchmarks/rigid_reference_frame_benchmark.cpp
index c7079e81af..5df064cd15 100644
--- a/benchmarks/rigid_reference_frame_benchmark.cpp
+++ b/benchmarks/rigid_reference_frame_benchmark.cpp
@@ -89,7 +89,7 @@ ApplyReferenceFrame(
         reference_frame->ToThisFrameAtTime(time)(degrees_of_freedom)));
   }
 
-  // Render the trajectory at current time in |Rendering|.
+  // Render the trajectory at current time in `Rendering`.
   Instant const& current_time = intermediate_trajectory.back().time;
   DiscreteTrajectory<Rendering>::iterator initial_it =
       intermediate_trajectory.begin();
diff --git a/functions/accurate_table_generator.hpp b/functions/accurate_table_generator.hpp
index 71b4eb688a..48d203a0e4 100644
--- a/functions/accurate_table_generator.hpp
+++ b/functions/accurate_table_generator.hpp
@@ -33,9 +33,9 @@ std::vector<cpp_rational> GalExhaustiveMultisearch(
     std::vector<AccurateFunction> const& functions,
     std::vector<cpp_rational> const& starting_arguments);
 
-// Searches in an interval of radius |T / N| centered on |starting_argument|.
-// The |polynomials| must be the degree-2 Taylor approximations of the
-// |functions| and the |remainders| must be upper bounds on the remainder of the
+// Searches in an interval of radius `T / N` centered on `starting_argument`.
+// The `polynomials` must be the degree-2 Taylor approximations of the
+// `functions` and the `remainders` must be upper bounds on the remainder of the
 // Taylor series. The argument and function values must be within [1/2, 1[.
 template<std::int64_t zeroes>
 absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousSearch(
@@ -46,9 +46,9 @@ absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousSearch(
     std::int64_t N,
     std::int64_t T);
 
-// Performs a search around |starting_argument| to find a solution,
+// Performs a search around `starting_argument` to find a solution,
 // automatically adjusting the interval over which the search happens.  The
-// argument and function values must be nonzero.  If |search_pool| is not null,
+// argument and function values must be nonzero.  If `search_pool` is not null,
 // the search may use speculative execution.
 template<std::int64_t zeroes>
 absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousFullSearch(
@@ -59,7 +59,7 @@ absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousFullSearch(
     ThreadPool<void>* search_pool = nullptr);
 
 // Same as above, but performs searches in parallel using the corresponding
-// |polynomials|, |remainders|, and |starting_arguments|.  Returns the results
+// `polynomials`, `remainders`, and `starting_arguments`.  Returns the results
 // in the same order as the parameters.
 template<std::int64_t zeroes>
 std::vector<absl::StatusOr<cpp_rational>>
@@ -71,8 +71,8 @@ StehléZimmermannSimultaneousMultisearch(
     std::vector<cpp_rational> const& starting_arguments);
 
 // Same as above, but instead of accumulating all the results and returning them
-// in a vector, it runs |callback| each time a computation is complete.  The
-// |index| indicates to which parameters the result corresponds.
+// in a vector, it runs `callback` each time a computation is complete.  The
+// `index` indicates to which parameters the result corresponds.
 template<std::int64_t zeroes>
 void StehléZimmermannSimultaneousStreamingMultisearch(
     std::array<AccurateFunction, 2> const& functions,
diff --git a/functions/accurate_table_generator_body.hpp b/functions/accurate_table_generator_body.hpp
index 7481c82eb9..7e65eebd43 100644
--- a/functions/accurate_table_generator_body.hpp
+++ b/functions/accurate_table_generator_body.hpp
@@ -174,11 +174,11 @@ absl::StatusOr<std::int64_t> StehléZimmermannExhaustiveSearch(
   return absl::NotFoundError("Not enough zeroes");
 }
 
-// Searches in a "slice", which is a set of two intervals of measure |2 * T₀| on
-// either side of |scaled.argument|.  Consecutive values of |slice_index|
-// correspond to contiguous intervals farther away from |scaled.argument|.
+// Searches in a "slice", which is a set of two intervals of measure `2 * T₀` on
+// either side of `scaled.argument`.  Consecutive values of `slice_index`
+// correspond to contiguous intervals farther away from `scaled.argument`.
 // Slices may be processed independently of one another.
-// Returns a *scaled* argument, or |NotFound| if no solution was found in the
+// Returns a *scaled* argument, or `NotFound` if no solution was found in the
 // slice.
 template<std::int64_t zeroes>
 absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousSliceSearch(
@@ -197,7 +197,7 @@ absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousSliceSearch(
   std::int64_t const T₀ = static_cast<std::int64_t>(
       Cbrt(static_cast<double>(M) * static_cast<double>(N)) / 128.0);
 
-  // Construct intervals of measure |2 * T₀| above and below |scaled.argument|
+  // Construct intervals of measure `2 * T₀` above and below `scaled.argument`
   // and search for solutions on each side alternatively.
   Interval<cpp_rational> const initial_high_interval{
       .min = scaled.argument + cpp_rational(2 * slice_index * T₀, N),
@@ -215,7 +215,7 @@ absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousSliceSearch(
   std::int64_t low_T_to_cover = T₀;
 
   // When exiting this loop, we have completely processed
-  // |initial_high_interval| and |initial_low_interval|.
+  // `initial_high_interval` and `initial_low_interval`.
   for (;;) {
     bool const high_interval_empty = high_interval.empty();
     bool const low_interval_empty = low_interval.empty();
@@ -226,7 +226,7 @@ absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousSliceSearch(
 
     if (!high_interval_empty) {
       std::int64_t T = high_T_to_cover;
-      // This loop exits (breaks or returns) when |T <= T_max| because
+      // This loop exits (breaks or returns) when `T <= T_max` because
       // exhaustive search always gives an answer.
       for (;;) {
         VLOG(3) << "T = " << T << ", high_interval = " << high_interval;
@@ -259,7 +259,7 @@ absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousSliceSearch(
     }
     if (!low_interval_empty) {
       std::int64_t T = low_T_to_cover;
-      // This loop exits (breaks or returns) when |T <= T_max| because
+      // This loop exits (breaks or returns) when `T <= T_max` because
       // exhaustive search always gives an answer.
       for (;;) {
         VLOG(3) << "T = " << T << ", low_interval = " << low_interval;
@@ -306,9 +306,9 @@ cpp_rational GalExhaustiveSearch(std::vector<AccurateFunction> const& functions,
                                  cpp_rational const& starting_argument) {
   CHECK_LT(0, starting_argument);
 
-  // We will look for candidates both above and below |starting_argument|.
-  // Note that if |starting_argument| is a power of 2, the increments above
-  // and below |starting_argument| are not the same.
+  // We will look for candidates both above and below `starting_argument`.
+  // Note that if `starting_argument` is a power of 2, the increments above
+  // and below `starting_argument` are not the same.
   std::int64_t exponent;
   auto const starting_mantissa =
       frexp(static_cast<cpp_bin_float_50>(starting_argument), &exponent);
@@ -369,7 +369,7 @@ absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousSearch(
   std::array<std::optional<AccuratePolynomial<cpp_rational, 2>>, 2> P;
   for (std::int64_t i = 0; i < functions.size(); ++i) {
     F[i] = [&functions, i, N, &starting_argument](cpp_rational const& t) {
-      // Here |t| <= |T|.
+      // Here `t` <= `T`.
       return N * functions[i](starting_argument + t / N);
     };
   }
diff --git a/functions/accurate_table_generator_test.cpp b/functions/accurate_table_generator_test.cpp
index 2d484c4d15..67e46c20c5 100644
--- a/functions/accurate_table_generator_test.cpp
+++ b/functions/accurate_table_generator_test.cpp
@@ -56,7 +56,7 @@ TEST_F(AccurateTableGeneratorTest, GalSin5) {
               RelativeErrorFrom(5.0 / 128.0, IsNear(3.1e-14_(1))));
 
   // The stupid language doesn't allow printing a float in binary.  So to verify
-  // that the |Sin| has zeroes in the right place we fiddle with the Mathematica
+  // that the `Sin` has zeroes in the right place we fiddle with the Mathematica
   // output.  We check the 7 bits starting at the last bit of the mantissa
   // (i.e., the bits starting at index 52) and verify that they are made of 5
   // zeroes surrounded by ones.  This validates that we actually shoot zeroes at
diff --git a/geometry/affine_map_test.cpp b/geometry/affine_map_test.cpp
index e0b5d21463..57d298d357 100644
--- a/geometry/affine_map_test.cpp
+++ b/geometry/affine_map_test.cpp
@@ -103,12 +103,12 @@ TEST_F(AffineMapTest, Cube) {
               Eq(front_right_bottom_ - origin_));
   EXPECT_THAT(map(front_left_top_) - origin_,
               AlmostEquals(back_left_top_ - origin_, 1));
-  // Check that |map| is an isometry of the cube whose vertices are |vertices_|.
+  // Check that `map` is an isometry of the cube whose vertices are `vertices_`.
   for (auto const& point : vertices_) {
     EXPECT_THAT(originated_vertices_,
                 Contains(AlmostEquals(map(point) - origin_, 0, 1)));
   }
-  // Test that |map.Inverse() * map| acts as the identity on that cube.
+  // Test that `map.Inverse() * map` acts as the identity on that cube.
   for (std::size_t i = 0; i < vertices_.size(); ++i) {
     EXPECT_THAT(originated_vertices_[i],
                 AlmostEquals((map.Inverse() * map)
diff --git a/geometry/cartesian_product_body.hpp b/geometry/cartesian_product_body.hpp
index 1dd6fee290..db7b4becaa 100644
--- a/geometry/cartesian_product_body.hpp
+++ b/geometry/cartesian_product_body.hpp
@@ -213,8 +213,8 @@ Tail(Tuple const& tuple) -> Type {
   return std::make_tuple(std::get<tail_indices>(tuple)...);
 }
 
-// Technically, this is only a ring if |CartesianProductMultiplicativeSpace| is
-// the bona fide |CartesianProductVectorSpace|.  If it is not, this implements a
+// Technically, this is only a ring if `CartesianProductMultiplicativeSpace` is
+// the bona fide `CartesianProductVectorSpace`.  If it is not, this implements a
 // multiplication-like operation which has the expected properties with respect
 // to the cartesian product additive group.
 // NOTE(phl): The need for the third, defaulted, parameter to the template
diff --git a/geometry/frame.hpp b/geometry/frame.hpp
index 09f3db95a9..d69cac9785 100644
--- a/geometry/frame.hpp
+++ b/geometry/frame.hpp
@@ -20,7 +20,7 @@ using namespace principia::base::_not_null;
 using namespace principia::geometry::_instant;
 using namespace principia::geometry::_space;
 
-// The enumerators of |FrameMotion| are ordered from most restrictive to least
+// The enumerators of `FrameMotion` are ordered from most restrictive to least
 // restrictive; m1 <= m2 means that m1 satisfies the requirements of m2.
 enum FrameMotion {
   Inertial,
@@ -74,14 +74,14 @@ struct Frame : not_constructible {
 
   static void WriteToMessage(not_null<serialization::Frame*> message);
 
-  // Checks that the |message| matches the current type.
+  // Checks that the `message` matches the current type.
   template<
       typename T = FrameTag,
       typename = std::enable_if_t<google::protobuf::is_proto_enum<T>::value>>
   static void ReadFromMessage(serialization::Frame const& message);
 };
 
-// Extracts enough information from the |message| to contruct a |Frame| type.
+// Extracts enough information from the `message` to contruct a `Frame` type.
 void ReadFrameFromMessage(
     serialization::Frame const& message,
     google::protobuf::EnumValueDescriptor const*& enum_value_descriptor,
diff --git a/geometry/grassmann.hpp b/geometry/grassmann.hpp
index df04768e80..201eecd74d 100644
--- a/geometry/grassmann.hpp
+++ b/geometry/grassmann.hpp
@@ -24,11 +24,11 @@ using namespace principia::quantities::_concepts;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// A multivector of rank |rank| on a three-dimensional real inner product
-// space bearing the dimensionality of |Scalar|, i.e., an element of
-// ⋀ⁿ Scalar³. Do not use this type for |rank == 0| (scalars), use the |Scalar|
+// A multivector of rank `rank` on a three-dimensional real inner product
+// space bearing the dimensionality of `Scalar`, i.e., an element of
+// ⋀ⁿ Scalar³. Do not use this type for `rank == 0` (scalars), use the `Scalar`
 // type directly instead.
-// |Frame| represents a reference frame together with an orthonormal basis.
+// `Frame` represents a reference frame together with an orthonormal basis.
 template<quantity Scalar, typename Frame, int rank>
 class Multivector;
 
@@ -206,14 +206,14 @@ Angle AngleBetween(Bivector<LScalar, Frame> const& v,
                    Bivector<RScalar, Frame> const& w);
 
 // The result is in [-π, π]; the function is anticommutative, the result is in
-// [0, π] if |InnerProduct(Wedge(v, w), positive) >= 0|.
+// [0, π] if `InnerProduct(Wedge(v, w), positive) >= 0`.
 template<typename LScalar, typename RScalar, typename PScalar, typename Frame>
 Angle OrientedAngleBetween(Vector<LScalar, Frame> const& v,
                            Vector<RScalar, Frame> const& w,
                            Bivector<PScalar, Frame> const& positive);
 
 // The result is in [-π, π]; the function is anticommutative, the result is in
-// [0, π] if |InnerProduct(Commutator(v, w), positive) >= 0|.
+// [0, π] if `InnerProduct(Commutator(v, w), positive) >= 0`.
 template<typename LScalar, typename RScalar, typename PScalar, typename Frame>
 Angle OrientedAngleBetween(Bivector<LScalar, Frame> const& v,
                            Bivector<RScalar, Frame> const& w,
diff --git a/geometry/grassmann_body.hpp b/geometry/grassmann_body.hpp
index 11ae64c1ce..77ce77f0fa 100644
--- a/geometry/grassmann_body.hpp
+++ b/geometry/grassmann_body.hpp
@@ -140,7 +140,7 @@ Scalar Multivector<Scalar, Frame, 2>::Norm() const {
 
 template<quantity Scalar, typename Frame>
 Scalar Multivector<Scalar, Frame, 3>::Norm() const {
-  // When |Scalar| is double, ADL will not find |Abs|.
+  // When `Scalar` is double, ADL will not find `Abs`.
   return Abs(coordinates_);
 }
 
@@ -552,8 +552,8 @@ FusedNegatedMultiplySubtract(
 
 template<typename Scalar, typename Frame, int rank>
 std::string DebugString(Multivector<Scalar, Frame, rank> const& multivector) {
-  // This |using| is required for the |Trivector|, whose |DebugString(Scalar)|
-  // will not be found by ADL if |Scalar| is |double|.
+  // This `using` is required for the `Trivector`, whose `DebugString(Scalar)`
+  // will not be found by ADL if `Scalar` is `double`.
   using quantities::_quantities::DebugString;
   return DebugString(multivector.coordinates());
 }
diff --git a/geometry/instant.cpp b/geometry/instant.cpp
index bd08d672b9..994de17d48 100644
--- a/geometry/instant.cpp
+++ b/geometry/instant.cpp
@@ -36,12 +36,12 @@ std::ostream& operator<<(std::ostream& os, Instant const& t) {
     Instant const start_of_second = DateTimeAsTT(tt_second);
     // This subtraction is exact by Sterbenz’s lemma.
     Time const remainder = t - start_of_second;
-    // |remainder| being the result of a subtraction of numbers greater than or
+    // `remainder` being the result of a subtraction of numbers greater than or
     // equal to 1, it is a multiple of 2u ≈ 2×10⁻¹⁶; 16 fractional decimal
     // digits suffice to unambiguously represent it (alternatively, as shown by
     // the static_assert, 17 decimal places are necessary, of which 16 are
     // fractional for numbers in [1, 10[; the integer part is taken care of by
-    // |tt_second|).
+    // `tt_second`).
     static_assert(std::numeric_limits<double>::max_digits10 - 1 == 16);
     return os << tt_second << ","
               << std::string_view(absl::StrFormat("%.16f", remainder / Second))
diff --git a/geometry/instant.hpp b/geometry/instant.hpp
index 2af9455671..77d60b3b2f 100644
--- a/geometry/instant.hpp
+++ b/geometry/instant.hpp
@@ -22,7 +22,7 @@ constexpr Instant InfiniteFuture = Instant() + Infinity<Time>;
 // IEEE 754:2008 nextUp and nextDown for Instants.
 // We would like to avoid the terms “up” and “down” when referring to the
 // passage of time.  We avoid the term “next” in one direction because of the
-// confusability with |std::nextafter|, which has different semantics, and in
+// confusability with `std::nextafter`, which has different semantics, and in
 // the other because of the awkwardness of the phrase “next before”.
 // Defined inline for want of a way to alias functions in C++.
 constexpr Instant JustAfter(Instant const& t) { return NextUp(t); }
diff --git a/geometry/instant_test.cpp b/geometry/instant_test.cpp
index a5deef810a..e4508ddba0 100644
--- a/geometry/instant_test.cpp
+++ b/geometry/instant_test.cpp
@@ -42,8 +42,8 @@ TEST_F(InstantOutputTest, UniversalTime) {
   EXPECT_THAT(
       (std::stringstream() << JustAfter("2000-01-01T11:58:56,816"_UTC)).str(),
       Eq("2000-01-01T12:00:01,0000000000000002 (TT)"));
-  // TODO(egg): This is horribly misrounded because of the 32.184 in |FromTAI|;
-  // we should be doing that in |DateTime| arithmetic.
+  // TODO(egg): This is horribly misrounded because of the 32.184 in `FromTAI`;
+  // we should be doing that in `DateTime` arithmetic.
   EXPECT_THAT((std::stringstream() << "2000-01-01T11:58:56,817"_UTC).str(),
               Eq("2000-01-01T12:00:01,0009999999999977 (TT)"));
 
diff --git a/geometry/interval.hpp b/geometry/interval.hpp
index 24b8991230..14653c2064 100644
--- a/geometry/interval.hpp
+++ b/geometry/interval.hpp
@@ -23,7 +23,7 @@ struct Interval {
   // The Lebesgue measure of this interval.
   Difference<T> measure() const;
 
-  // Returns true iff |measure| would return zero, but more efficiently.
+  // Returns true iff `measure` would return zero, but more efficiently.
   bool empty() const;
 
   // The midpoint of this interval; NaN if the interval is empty (min > max).
diff --git a/geometry/orthogonal_map.hpp b/geometry/orthogonal_map.hpp
index fcf15d8ebb..4985ec0708 100644
--- a/geometry/orthogonal_map.hpp
+++ b/geometry/orthogonal_map.hpp
@@ -57,8 +57,8 @@ using namespace principia::geometry::_linear_map;
 using namespace principia::geometry::_quaternion;
 using namespace principia::geometry::_sign;
 
-// An orthogonal map between the inner product spaces |FromFrame| and
-// |ToFrame|, as well as the induced maps on the exterior algebra.
+// An orthogonal map between the inner product spaces `FromFrame` and
+// `ToFrame`, as well as the induced maps on the exterior algebra.
 // The orthogonal map is modeled as a rotoinversion.
 template<typename FromFrame, typename ToFrame>
 class OrthogonalMap : public LinearMap<OrthogonalMap<FromFrame, ToFrame>,
diff --git a/geometry/orthogonal_map_body.hpp b/geometry/orthogonal_map_body.hpp
index 8e5fb3a954..ddb8491c3d 100644
--- a/geometry/orthogonal_map_body.hpp
+++ b/geometry/orthogonal_map_body.hpp
@@ -28,7 +28,7 @@ OrthogonalMap<FromFrame, ToFrame>::AsRotation() const {
 template<typename FromFrame, typename ToFrame>
 OrthogonalMap<ToFrame, FromFrame>
 OrthogonalMap<FromFrame, ToFrame>::Inverse() const {
-  // Because |quaternion_| has norm 1, its inverse is just its conjugate.
+  // Because `quaternion_` has norm 1, its inverse is just its conjugate.
   return OrthogonalMap<ToFrame, FromFrame>(quaternion_.Conjugate());
 }
 
diff --git a/geometry/pair.hpp b/geometry/pair.hpp
index 6f09720cdd..87e016586a 100644
--- a/geometry/pair.hpp
+++ b/geometry/pair.hpp
@@ -151,7 +151,7 @@ class Pair final {
   template<typename Functor, typename T, typename>
   friend struct base::_mappable::internal::Mappable;
 
-  // This is needed to implement matchers for |Pair|.
+  // This is needed to implement matchers for `Pair`.
   template<typename PairType>
   friend class testing_utilities::_componentwise::internal::
       ComponentwiseMatcher2Impl;
diff --git a/geometry/perspective.hpp b/geometry/perspective.hpp
index 13772ff8ad..8bee5cb7d8 100644
--- a/geometry/perspective.hpp
+++ b/geometry/perspective.hpp
@@ -32,7 +32,7 @@ template<typename Frame>
 using Segments = std::vector<Segment<Frame>>;
 
 // A perspective using the pinhole camera model.  It project a point of
-// |FromFrame| to an element of ℝP².  |ToFrame| is the frame of the camera.  In
+// `FromFrame` to an element of ℝP².  `ToFrame` is the frame of the camera.  In
 // that frame the camera is located at the origin and looking at the positive
 // z-axis.  The x- and y- axis of the camera correspond to those of ℝP².
 template<typename FromFrame, typename ToFrame>
@@ -45,12 +45,12 @@ class Perspective final {
 
   Length const& focal() const;
 
-  // Returns the ℝP² element resulting from the projection of |point|.  This
+  // Returns the ℝP² element resulting from the projection of `point`.  This
   // is properly defined for all points other than the camera origin.
   RP2Point<Length, ToFrame> operator()(Position<FromFrame> const& point) const;
 
-  // Returns the part of |segment| that is behind the focal plane as seen from
-  // the camera.  Returns nullopt if |segment| is entirely in front of the focal
+  // Returns the part of `segment` that is behind the focal plane as seen from
+  // the camera.  Returns nullopt if `segment` is entirely in front of the focal
   // plane.
   std::optional<Segment<FromFrame>>
   SegmentBehindFocalPlane(Segment<FromFrame> const& segment) const;
@@ -62,15 +62,15 @@ class Perspective final {
 
   Square<Length> SquaredDistanceFromCamera(Position<FromFrame> const& p) const;
 
-  // Returns true iff the |point| is hidden by the |sphere| in this perspective.
+  // Returns true iff the `point` is hidden by the `sphere` in this perspective.
   bool IsHiddenBySphere(Position<FromFrame> const& point,
                         Sphere<FromFrame> const& sphere) const;
 
-  // Returns sin² α where α is the half angle under which the |sphere| is seen.
+  // Returns sin² α where α is the half angle under which the `sphere` is seen.
   double SphereSin²HalfAngle(Sphere<FromFrame> const& sphere) const;
 
-  // Returns the (sub)segments of |segment| that are visible in this perspective
-  // after taking into account the hiding by |sphere|.  The returned vector has
+  // Returns the (sub)segments of `segment` that are visible in this perspective
+  // after taking into account the hiding by `sphere`.  The returned vector has
   // 0, 1, or 2 elements.
   BoundedArray<Segment<FromFrame>, 2> VisibleSegments(
       Segment<FromFrame> const& segment,
diff --git a/geometry/quaternion.hpp b/geometry/quaternion.hpp
index 6d16e279dc..71ca2c77bc 100644
--- a/geometry/quaternion.hpp
+++ b/geometry/quaternion.hpp
@@ -13,7 +13,7 @@ using namespace principia::base::_not_null;
 using namespace principia::geometry::_r3_element;
 
 // An element of the skew field of quaternions ℍ (where ℝ is modeled by
-// |double|).
+// `double`).
 class Quaternion final {
  public:
   constexpr Quaternion() = default;
diff --git a/geometry/r3_element.hpp b/geometry/r3_element.hpp
index 7d8836a762..5768411008 100644
--- a/geometry/r3_element.hpp
+++ b/geometry/r3_element.hpp
@@ -26,9 +26,9 @@ using namespace principia::quantities::_quantities;
 template<typename Scalar>
 struct SphericalCoordinates;
 
-// An |R3Element<Scalar>| is an element of Scalar³. |Scalar| should be a vector
-// space over ℝ, represented by |double|. |R3Element| is the underlying data
-// type for more advanced strongly typed structures suchas |Multivector|.
+// An `R3Element<Scalar>` is an element of Scalar³. `Scalar` should be a vector
+// space over ℝ, represented by `double`. `R3Element` is the underlying data
+// type for more advanced strongly typed structures suchas `Multivector`.
 template<typename Scalar>
 struct alignas(16) R3Element final {
  public:
@@ -52,9 +52,9 @@ struct alignas(16) R3Element final {
   // the equator, and the z-axis as the north pole.
   SphericalCoordinates<Scalar> ToSpherical() const;
 
-  // Returns a vector coplanar to |*this| and |r3_element|, orthogonal to
-  // |r3_element|, and on the same side of |r3_element| as |*this|.
-  // Uses the modified Gram-Schmidt algorithm.  Fails if |r3_element| is zero.
+  // Returns a vector coplanar to `*this` and `r3_element`, orthogonal to
+  // `r3_element`, and on the same side of `r3_element` as `*this`.
+  // Uses the modified Gram-Schmidt algorithm.  Fails if `r3_element` is zero.
   template<typename S>
   R3Element OrthogonalizationAgainst(R3Element<S> const& r3_element) const;
 
@@ -76,8 +76,8 @@ struct alignas(16) R3Element final {
 
 template<typename Scalar>
 struct SphericalCoordinates final {
-  // Default, but prevents aggregate initialization of |SphericalCoordinates| to
-  // obviate confusion over the order of |latitude| and |longitude|.
+  // Default, but prevents aggregate initialization of `SphericalCoordinates` to
+  // obviate confusion over the order of `latitude` and `longitude`.
   SphericalCoordinates();
 
   // Uses the x-y plane as the equator, the x-axis as the reference direction on
@@ -111,7 +111,7 @@ template<typename Scalar>
 R3Element<Scalar> operator-(R3Element<Scalar> const& left,
                             R3Element<Scalar> const& right);
 
-// Dimensionful multiplication |LScalar * R3Element<RScalar>| is the tensor
+// Dimensionful multiplication `LScalar * R3Element<RScalar>` is the tensor
 // product LScalar ⊗ Scalar³. Since LScalar ⊗ Scalar³ ≅ (LScalar ⊗ Scalar)³,
 // the result is an R3Element<Product<LScalar, RScalar>>.
 template<typename LScalar, typename RScalar>
@@ -210,8 +210,8 @@ template<typename LScalar, typename RScalar>
 Product<LScalar, RScalar> Dot(R3Element<LScalar> const& left,
                               R3Element<RScalar> const& right);
 
-// Returns the |i|th basis vector, whose |i|th coordinate is 1, and whose
-// other coordinates are 0.  |i| must be in [0, 2].
+// Returns the `i`th basis vector, whose `i`th coordinate is 1, and whose
+// other coordinates are 0.  `i` must be in [0, 2].
 R3Element<double> BasisVector(int i);
 
 }  // namespace internal
diff --git a/geometry/r3x3_matrix.hpp b/geometry/r3x3_matrix.hpp
index 5abc7f7660..d20149ce68 100644
--- a/geometry/r3x3_matrix.hpp
+++ b/geometry/r3x3_matrix.hpp
@@ -24,9 +24,9 @@ using namespace principia::geometry::_r3_element;
 using namespace principia::quantities::_concepts;
 using namespace principia::quantities::_named_quantities;
 
-// An |R3x3Matrix| is an element of the associative algebra of 3-by-3 matrices
-// over |Scalar|.  |Scalar| should be a vector space over ℝ, represented by
-// |double|.
+// An `R3x3Matrix` is an element of the associative algebra of 3-by-3 matrices
+// over `Scalar`.  `Scalar` should be a vector space over ℝ, represented by
+// `double`.
 template<typename Scalar>
 class R3x3Matrix final {
  public:
diff --git a/geometry/rotation.hpp b/geometry/rotation.hpp
index 7a6184f87a..50fb142997 100644
--- a/geometry/rotation.hpp
+++ b/geometry/rotation.hpp
@@ -39,10 +39,10 @@ using namespace principia::geometry::_r3_element;
 using namespace principia::geometry::_sign;
 using namespace principia::quantities::_quantities;
 
-// |EulerAngles| and |CardanoAngles| have values in binary-coded ternary
+// `EulerAngles` and `CardanoAngles` have values in binary-coded ternary
 // representing the sequence of rotation axes.
 
-// |AxisConvention| concatenates ternary digits.  Implementation here so it is
+// `AxisConvention` concatenates ternary digits.  Implementation here so it is
 // defined by the time we use it as a constant expression.
 constexpr int AxisConvention(int const first_axis,
                              int const second_axis,
@@ -55,7 +55,7 @@ constexpr int Y = 1;
 constexpr int Z = 2;
 
 enum class EulerAngles {
-  // |ZXZ| is The most common convention, e.g. orbital elements (Ω, i, ω),
+  // `ZXZ` is The most common convention, e.g. orbital elements (Ω, i, ω),
   // rotational elements (90˚ + α₀, 90˚ - δ₀, W).
   ZXZ = AxisConvention(Z, X, Z),
   XYX = AxisConvention(X, Y, X),
@@ -78,7 +78,7 @@ template<typename Frame>
 struct DefinesFrame final {};
 
 // An orientation-preserving orthogonal map between the inner product spaces
-// |FromFrame| and |ToFrame|, as well as the induced maps on the exterior
+// `FromFrame` and `ToFrame`, as well as the induced maps on the exterior
 // algebra.
 template<typename FromFrame, typename ToFrame>
 class Rotation : public LinearMap<Rotation<FromFrame, ToFrame>,
@@ -92,7 +92,7 @@ class Rotation : public LinearMap<Rotation<FromFrame, ToFrame>,
   friend bool operator==(Rotation const& left, Rotation const& right) = default;
   friend bool operator!=(Rotation const& left, Rotation const& right) = default;
 
-  // A rotation of |angle| around |axis|; no coordinate change is involved, this
+  // A rotation of `angle` around `axis`; no coordinate change is involved, this
   // is an active rotation.
   template<typename Scalar,
            typename F = FromFrame,
@@ -102,10 +102,10 @@ class Rotation : public LinearMap<Rotation<FromFrame, ToFrame>,
 
   // The constructors below define passive rotations (changes of coordinates
   // between orthonormal bases sharing the same orientation, rather than
-  // physical rotations).  As a consequence, they require that |FromFrame| be
-  // distinct from |ToFrame|.
+  // physical rotations).  As a consequence, they require that `FromFrame` be
+  // distinct from `ToFrame`.
 
-  // Construct a rotation from the axes of |ToFrame|, expressed in |FromFrame|.
+  // Construct a rotation from the axes of `ToFrame`, expressed in `FromFrame`.
   template<int rank_x, int rank_y, int rank_z,
            typename F = FromFrame,
            typename T = ToFrame,
@@ -113,11 +113,11 @@ class Rotation : public LinearMap<Rotation<FromFrame, ToFrame>,
   Rotation(Multivector<double, FromFrame, rank_x> x_to_frame,
            Multivector<double, FromFrame, rank_y> y_to_frame,
            Multivector<double, FromFrame, rank_z> z_to_frame);
-  // Construct a rotation from the axes of |FromFrame|, expressed in |ToFrame|.
-  // The |typename = void| template parameter gives it a different signature
-  // from the above when |FromFrame| and |ToFrame| are the same (otherwise this
+  // Construct a rotation from the axes of `FromFrame`, expressed in `ToFrame`.
+  // The `typename = void` template parameter gives it a different signature
+  // from the above when `FromFrame` and `ToFrame` are the same (otherwise this
   // is a problem when instantiating the class, even though they are both
-  // disabled by |enable_if|).
+  // disabled by `enable_if`).
   template<int rank_x, int rank_y, int rank_z,
            typename F = FromFrame,
            typename T = ToFrame,
@@ -134,7 +134,7 @@ class Rotation : public LinearMap<Rotation<FromFrame, ToFrame>,
   // axis.
   // These constructors come in pairs (with either value of DefinesFrame), like
   // the matrix constructors above.  For each pair, one of the constructors has
-  // an additional |typename = void|, see above.
+  // an additional `typename = void`, see above.
 
   template<typename Scalar,
            typename F = FromFrame,
@@ -154,15 +154,15 @@ class Rotation : public LinearMap<Rotation<FromFrame, ToFrame>,
            DefinesFrame<FromFrame> tag);
 
   // Constructors from Euler angles.
-  // Example: if |Orbit| is the frame of an orbit (x towards the periapsis,
+  // Example: if `Orbit` is the frame of an orbit (x towards the periapsis,
   // z the positive normal to the orbit plane), and Ω, i, and ω are the elements
-  // in some |Reference| frame,
+  // in some `Reference` frame,
   //   Rotation<Reference, Orbit>(Ω, i, ω, EulerAngles::ZXZ,
   //                              DefinesFrame<Orbit>{})
   // and
   //   Rotation<Orbit, Reference>(Ω, i, ω, EulerAngles::ZXZ,
   //                              DefinesFrame<Orbit>{})
-  // are the transformations between |Reference| and |Orbit|.
+  // are the transformations between `Reference` and `Orbit`.
 
   template<typename F = FromFrame,
            typename T = ToFrame,
@@ -184,15 +184,15 @@ class Rotation : public LinearMap<Rotation<FromFrame, ToFrame>,
            DefinesFrame<FromFrame> tag);
 
   // Constructors from Cardano angles.
-  // Example: if |Aircraft| is the frame of an aircraft (x forward, y right,
-  // z down), and |Ground| is a local-vertical, local-horizontal frame (x North,
-  // y East, z Down), given the |heading|, |pitch|, and |roll| of the aircraft,
+  // Example: if `Aircraft` is the frame of an aircraft (x forward, y right,
+  // z down), and `Ground` is a local-vertical, local-horizontal frame (x North,
+  // y East, z Down), given the `heading`, `pitch`, and `roll` of the aircraft,
   //   Rotation<Ground, Aircraft>(heading, pitch, roll, CardanoAngles::ZYX,
   //                              DefinesFrame<Aircraft>{})
   // and
   //   Rotation<Aircraft, Ground>(heading, pitch, roll, CardanoAngles::ZYX,
   //                              DefinesFrame<Aircraft>{})
-  // are the transformations between |Aircraft| and |Ground|.
+  // are the transformations between `Aircraft` and `Ground`.
 
   template<typename F = FromFrame,
            typename T = ToFrame,
diff --git a/geometry/rotation_body.hpp b/geometry/rotation_body.hpp
index 3ead5fc2f5..f2b9901498 100644
--- a/geometry/rotation_body.hpp
+++ b/geometry/rotation_body.hpp
@@ -23,7 +23,7 @@ using namespace principia::quantities::_elementary_functions;
 // http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion and
 // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/.
 FORCE_INLINE(inline) Quaternion ToQuaternion(R3x3Matrix<double> const& matrix) {
-  // TODO(egg): this should probably contain some checks that |matrix| has
+  // TODO(egg): this should probably contain some checks that `matrix` has
   // positive determinant...
   double const t = matrix.Trace();
   double real_part;
@@ -63,14 +63,14 @@ FORCE_INLINE(inline) Quaternion ToQuaternion(R3x3Matrix<double> const& matrix) {
   return Quaternion(real_part, imaginary_part);
 }
 
-// Returns a rotation of |angle| around |axis|.  |axis| must be normalized.
+// Returns a rotation of `angle` around `axis`.  `axis` must be normalized.
 inline Quaternion AngleAxis(Angle const& angle, R3Element<double> const& axis) {
   Angle const half_angle = 0.5 * angle;
   return Quaternion(Cos(half_angle), Sin(half_angle) * axis);
 }
 
-// Returns the digits of the 3ⁿs from the given |BinaryCodedTernary number|.
-// Note that this does not check that |number| is valid binary-coded ternary,
+// Returns the digits of the 3ⁿs from the given `BinaryCodedTernary number`.
+// Note that this does not check that `number` is valid binary-coded ternary,
 // nor that the result is between 1 and 2.
 template<typename BinaryCodedTernary>
 int BinaryCodedTernaryDigit(int const n, BinaryCodedTernary const number) {
@@ -182,7 +182,7 @@ Sign Rotation<FromFrame, ToFrame>::Determinant() const {
 
 template<typename FromFrame, typename ToFrame>
 Rotation<ToFrame, FromFrame> Rotation<FromFrame, ToFrame>::Inverse() const {
-  // Because |quaternion_| has norm 1, its inverse is just its conjugate.
+  // Because `quaternion_` has norm 1, its inverse is just its conjugate.
   return Rotation<ToFrame, FromFrame>(quaternion_.Conjugate());
 }
 
diff --git a/geometry/rotation_test.cpp b/geometry/rotation_test.cpp
index ee69301f3a..75daad9170 100644
--- a/geometry/rotation_test.cpp
+++ b/geometry/rotation_test.cpp
@@ -333,8 +333,8 @@ TEST_F(RotationTest, Enums) {
                                           EulerAngles::ZXZ,
                                           DefinesFrame<World1>{});
 
-  // Checks that using the convention |axes| for Euler angles, conjugated by the
-  // given |permutation|, and with appropriate sign changes, is equivalent to
+  // Checks that using the convention `axes` for Euler angles, conjugated by the
+  // given `permutation`, and with appropriate sign changes, is equivalent to
   // the ZXZ convention.
   auto const check_euler_angles = [this, &α, &β, &γ, &zxz_euler](
       EulerAngles axes, auto permutation) {
@@ -373,8 +373,8 @@ TEST_F(RotationTest, Enums) {
                                             CardanoAngles::XYZ,
                                             DefinesFrame<World1>{});
 
-  // Checks that using the convention |axes| for Cardano angles, conjugated by
-  // the given |permutation|, and with appropriate sign changes, is equivalent
+  // Checks that using the convention `axes` for Cardano angles, conjugated by
+  // the given `permutation`, and with appropriate sign changes, is equivalent
   // to the XYZ convention.
   auto const check_cardano_angles = [this, &α, &β, &γ, &xyz_cardano](
                                         CardanoAngles axes, auto permutation) {
@@ -418,14 +418,14 @@ TEST_F(RotationTest, EulerAngles) {
 
   // The frame in which the above elements are given.
   using Reference = Frame<struct ReferenceTag>;
-  // |Nodes| shares its z axis with |Reference|, and has the ascending node of
+  // `Nodes` shares its z axis with `Reference`, and has the ascending node of
   // the orbit as its positive x direction.
   using Nodes = Frame<struct NodesTag>;
-  // |Plane| also has the ascending node of the orbit as its positive x
+  // `Plane` also has the ascending node of the orbit as its positive x
   // direction, and has the orbital plane as its xy plane (with z being the
   // positive orbit normal).
   using Plane = Frame<struct PlaneTag>;
-  // |Orbit| has its x axis towards the periapsis, and its z axis towards the
+  // `Orbit` has its x axis towards the periapsis, and its z axis towards the
   // positive orbit normal.
   using Orbit = Frame<struct OrbitTag>;
 
diff --git a/geometry/rp2_point.hpp b/geometry/rp2_point.hpp
index d944814415..aaa5dbd6d9 100644
--- a/geometry/rp2_point.hpp
+++ b/geometry/rp2_point.hpp
@@ -8,9 +8,9 @@ namespace geometry {
 namespace _rp2_point {
 namespace internal {
 
-// An |RP2Point| is an element of ℝP², the real projective plane.  |Scalar|
+// An `RP2Point` is an element of ℝP², the real projective plane.  `Scalar`
 // must be a 1-dimensional vector space over ℝ, typically represented by
-// |Quantity| or |double|.
+// `Quantity` or `double`.
 template<typename Scalar, typename Frame>
 class RP2Point {
  public:
diff --git a/geometry/rp2_point_body.hpp b/geometry/rp2_point_body.hpp
index 81d50370f0..4586bef8bc 100644
--- a/geometry/rp2_point_body.hpp
+++ b/geometry/rp2_point_body.hpp
@@ -25,7 +25,7 @@ RP2Point<Scalar, Frame>::RP2Point(
   // [0:0:0] does not represent any point but we cannot reject it as it may
   // result from an underflow or a cancellation.
 
-  // Normalize the sign of |z_| so that we return consistently-signed infinities
+  // Normalize the sign of `z_` so that we return consistently-signed infinities
   // in the functions below.
   if (std::signbit(z_)) {
     x_ = -x_;
diff --git a/geometry/serialization.hpp b/geometry/serialization.hpp
index 7ffe4a30a8..90853996c4 100644
--- a/geometry/serialization.hpp
+++ b/geometry/serialization.hpp
@@ -9,8 +9,8 @@ namespace internal {
 
 using namespace principia::base::_not_constructible;
 
-// A helper class that serializes a |double|, a |Quantity|, a |Point| or a
-// |Multivector| to a protobuf structure like:
+// A helper class that serializes a `double`, a `Quantity`, a `Point` or a
+// `Multivector` to a protobuf structure like:
 //
 // message Message {
 //   oneof message {
@@ -23,7 +23,7 @@ using namespace principia::base::_not_constructible;
 template<typename T, typename Message>
 struct DoubleOrQuantityOrPointOrMultivectorSerializer : not_constructible {};
 
-// A helper class that serializes a |double|, a |Quantity| or a |Multivector|
+// A helper class that serializes a `double`, a `Quantity` or a `Multivector`
 // to a protobuf structure like:
 //
 // message Message {
@@ -36,7 +36,7 @@ struct DoubleOrQuantityOrPointOrMultivectorSerializer : not_constructible {};
 template<typename T, typename Message>
 struct DoubleOrQuantityOrMultivectorSerializer : not_constructible {};
 
-// A helper class that serializes a |Point| or a |Multivector| to a protobuf
+// A helper class that serializes a `Point` or a `Multivector` to a protobuf
 // structure like:
 //
 // message Message {
@@ -48,7 +48,7 @@ struct DoubleOrQuantityOrMultivectorSerializer : not_constructible {};
 template<typename T, typename Message>
 struct PointOrMultivectorSerializer : not_constructible {};
 
-// A helper class that serializes a |Quantity| or a |Multivector| to a protobuf
+// A helper class that serializes a `Quantity` or a `Multivector` to a protobuf
 // structure like:
 //
 // message Message {
diff --git a/geometry/symmetric_bilinear_form.hpp b/geometry/symmetric_bilinear_form.hpp
index 5e1f24b736..d5a6c697ba 100644
--- a/geometry/symmetric_bilinear_form.hpp
+++ b/geometry/symmetric_bilinear_form.hpp
@@ -24,8 +24,8 @@ using namespace principia::geometry::_r3x3_matrix;
 using namespace principia::geometry::_rotation;
 using namespace principia::quantities::_named_quantities;
 
-// A symmetric bilinear form with dimensionality |Scalar|, on the given kind of
-// |Multivector|, expressed in the coordinates of |Frame|.
+// A symmetric bilinear form with dimensionality `Scalar`, on the given kind of
+// `Multivector`, expressed in the coordinates of `Frame`.
 template<typename Scalar,
          typename Frame,
          template<typename, typename> typename Multivector>
@@ -52,19 +52,19 @@ class SymmetricBilinearForm {
       Multivector<LScalar, Frame> const& left,
       Multivector<RScalar, Frame> const& right) const;
 
-  // For a form on vectors, |Anticommutator| returns the form on bivectors
+  // For a form on vectors, `Anticommutator` returns the form on bivectors
   // resulting from the commutator, i.e., up to roundoff,
   //   F.Anticommutator() * α = Anticommutator(F, α),
   //   F.Anticommutator()(α, β) = InnerProduct(α, Anticommutator(F, β)).
   // Further, note that
   //   F.Anticommutator() * Wedge(v, w) = Wedge(F * v, w) + Wedge(v, F * w),
   // which is the generalization to nonsymmetric F.
-  // This operation is linear in |*this|.
+  // This operation is linear in `*this`.
   template<template<typename, typename> typename M = Multivector,
            typename = std::enable_if_t<is_same_template_v<M, Vector>>>
   SymmetricBilinearForm<Scalar, Frame, Bivector> Anticommutator() const;
 
-  // This function is the inverse of |Anticommutator()|.  It is well-defined
+  // This function is the inverse of `Anticommutator()`.  It is well-defined
   // only in dimension 3, where dim ⋀²V = dim V.
   template<template<typename, typename> typename M = Multivector,
            typename = std::enable_if_t<is_same_template_v<M, Bivector>>>
@@ -188,8 +188,8 @@ class SymmetricBilinearForm {
                                   SymmetricBilinearForm<S, F, M> const& form);
 };
 
-// |InnerProductForm()| is the symmetric bilinear form such that for all v and
-// w, |InnerProductForm()(v, w) == InnerProduct(v, w)|.
+// `InnerProductForm()` is the symmetric bilinear form such that for all v and
+// w, `InnerProductForm()(v, w) == InnerProduct(v, w)`.
 template<typename Frame, template<typename, typename> typename Multivector>
 SymmetricBilinearForm<double, Frame, Multivector> const& InnerProductForm();
 
@@ -240,10 +240,10 @@ SymmetricBilinearForm<Quotient<LScalar, RScalar>, Frame, Multivector> operator/(
     RScalar right);
 
 
-// NOTE(egg): An |operator*(SymmetricBilinearForm<L, F, M>, M<R, F>)| would fail
+// NOTE(egg): An `operator*(SymmetricBilinearForm<L, F, M>, M<R, F>)` would fail
 // to deduce M, for reasons that I do not quite understand (they seem to have to
 // do with Vector not being the same thing as Multivector).  Instead we have
-// this |enable_if| mess.
+// this `enable_if` mess.
 
 template<typename LScalar,
          typename RScalar,
@@ -269,8 +269,8 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> operator*(
     Multivector<LScalar, Frame, rank> const& left,
     SymmetricBilinearForm<RScalar, Frame, M> const& right);
 
-// Solves the system |result * right == left|.  Note that by symmetry, this is
-// also the solution of |right * result == left|.
+// Solves the system `result * right == left`.  Note that by symmetry, this is
+// also the solution of `right * result == left`.
 template<typename LScalar,
          typename RScalar,
          typename Frame,
@@ -283,19 +283,19 @@ Multivector<Quotient<LScalar, RScalar>, Frame, rank> operator/(
     Multivector<LScalar, Frame, rank> const& left,
     SymmetricBilinearForm<RScalar, Frame, M> const& right);
 
-// |SymmetricProduct(v, w)| is v ⊙ w ≔ (v ⊗ w + w ⊗ v) / 2.
+// `SymmetricProduct(v, w)` is v ⊙ w ≔ (v ⊗ w + w ⊗ v) / 2.
 template<typename LScalar, typename RScalar, typename Frame>
 SymmetricBilinearForm<Product<LScalar, RScalar>, Frame, Vector>
 SymmetricProduct(Vector<LScalar, Frame> const& left,
                  Vector<RScalar, Frame> const& right);
 
-// |SymmetricSquare(v)| is |SymmetricProduct(v, v)|.
+// `SymmetricSquare(v)` is `SymmetricProduct(v, v)`.
 template<typename Scalar, typename Frame>
 SymmetricBilinearForm<Square<Scalar>, Frame, Vector>
 SymmetricSquare(Vector<Scalar, Frame> const& vector);
 
 // Symmetric bilinear forms on vectors act on bivectors through this function.
-// |Anticommutator(F, B)| is (tr(F)𝟙 - F)B in ℝ³ representation.  In matrix
+// `Anticommutator(F, B)` is (tr(F)𝟙 - F)B in ℝ³ representation.  In matrix
 // representation it is FB + BF = {F, B}.
 template<typename LScalar, typename RScalar, typename Frame>
 Bivector<Product<LScalar, RScalar>, Frame> Anticommutator(
diff --git a/integrators/adams_moulton_integrator.hpp b/integrators/adams_moulton_integrator.hpp
index d15aac41e4..f75c1307ec 100644
--- a/integrators/adams_moulton_integrator.hpp
+++ b/integrators/adams_moulton_integrator.hpp
@@ -10,7 +10,7 @@ namespace internal {
 using namespace principia::numerics::_fixed_arrays;
 
 // Definition of an Adams-Moulton method.  Not technically an "integrator" as
-// it is not a subclass of |integrators::Integrator|.
+// it is not a subclass of `integrators::Integrator`.
 template<int order_>
 struct AdamsMoulton final {
   static constexpr int order = order_;
diff --git a/integrators/cohen_hubbard_oesterwinter.hpp b/integrators/cohen_hubbard_oesterwinter.hpp
index 90e7245929..d65356415f 100644
--- a/integrators/cohen_hubbard_oesterwinter.hpp
+++ b/integrators/cohen_hubbard_oesterwinter.hpp
@@ -14,8 +14,8 @@ using namespace principia::numerics::_fixed_arrays;
 //   f′(x₀) ≅ (f(x₀) - f(x₋₁)) / h + h Σ(ηᵢ f″(x₋ᵢ))
 // where the sum is for i going from 0 to order_ - 1.  The ηᵢ are computed
 // using Mathematica, see cohen_hubbard_oesterwinter.wl.
-// |order_| is the order of the approximation, that is, the error on the
-// derivative is 𝒪(h^(order_ + 1)).  The formula requires |order_| values of the
+// `order_` is the order of the approximation, that is, the error on the
+// derivative is 𝒪(h^(order_ + 1)).  The formula requires `order_` values of the
 // acceleration.  numerators[0] corresponds to f″(x₀), numerators[1] to f″(x₋₁),
 // etc.
 // TODO(phl): This struct shows up in many places.  Factor it out.
diff --git "a/integrators/embedded_explicit_generalized_runge_kutta_nystr\303\266m_integrator.hpp" "b/integrators/embedded_explicit_generalized_runge_kutta_nystr\303\266m_integrator.hpp"
index fabb96ee71..bafa401a0f 100644
--- "a/integrators/embedded_explicit_generalized_runge_kutta_nystr\303\266m_integrator.hpp"
+++ "b/integrators/embedded_explicit_generalized_runge_kutta_nystr\303\266m_integrator.hpp"
@@ -1,4 +1,4 @@
-// The files containing the tree of of child classes of |Integrator| must be
+// The files containing the tree of of child classes of `Integrator` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
diff --git "a/integrators/embedded_explicit_generalized_runge_kutta_nystr\303\266m_integrator_body.hpp" "b/integrators/embedded_explicit_generalized_runge_kutta_nystr\303\266m_integrator_body.hpp"
index 4c54202789..5c879bc234 100644
--- "a/integrators/embedded_explicit_generalized_runge_kutta_nystr\303\266m_integrator_body.hpp"
+++ "b/integrators/embedded_explicit_generalized_runge_kutta_nystr\303\266m_integrator_body.hpp"
@@ -63,7 +63,7 @@ absl::Status EmbeddedExplicitGeneralizedRungeKuttaNyströmIntegrator<
   auto& parameters = this->parameters_;
   auto const& equation = this->equation_;
 
-  // |current_state| gets updated as the integration progresses to allow
+  // `current_state` gets updated as the integration progresses to allow
   // restartability.
 
   // State before the last, truncated step.
@@ -119,9 +119,9 @@ absl::Status EmbeddedExplicitGeneralizedRungeKuttaNyströmIntegrator<
   double tolerance_to_error_ratio;
 
   // The first stage of the Runge-Kutta-Nyström iteration.  In the FSAL case,
-  // |first_stage == 1| after the first step, since the first RHS evaluation has
+  // `first_stage == 1` after the first step, since the first RHS evaluation has
   // already occurred in the previous step.  In the non-FSAL case and in the
-  // first step of the FSAL case, |first_stage == 0|.
+  // first step of the FSAL case, `first_stage == 0`.
   int first_stage = 0;
 
   // The number of steps already performed.
@@ -131,8 +131,8 @@ absl::Status EmbeddedExplicitGeneralizedRungeKuttaNyströmIntegrator<
   absl::Status step_status;
 
   // No step size control on the first step.  If this instance is being
-  // restarted we already have a value of |h| suitable for the next step, based
-  // on the computation of |tolerance_to_error_ratio_| during the last
+  // restarted we already have a value of `h` suitable for the next step, based
+  // on the computation of `tolerance_to_error_ratio_` during the last
   // invocation.
   goto runge_kutta_nyström_step;
 
@@ -177,7 +177,7 @@ absl::Status EmbeddedExplicitGeneralizedRungeKuttaNyströmIntegrator<
 
       auto const h² = h * h;
 
-      // Runge-Kutta-Nyström iteration; fills |g|.
+      // Runge-Kutta-Nyström iteration; fills `g`.
       for (int i = first_stage; i < stages_; ++i) {
         Instant const t_stage =
             (parameters.last_step_is_exact && at_end && c[i] == 1.0)
@@ -310,7 +310,7 @@ Instance::ReadFromMessage(
     EmbeddedExplicitGeneralizedRungeKuttaNyströmIntegrator const&
         integrator)
   requires serializable<typename ODE_::DependentVariable> {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(new Instance(problem,
                                                 append_state,
@@ -346,7 +346,7 @@ NewInstance(InitialValueProblem<ODE> const& problem,
             AppendState const& append_state,
             ToleranceToErrorRatio const& tolerance_to_error_ratio,
             Parameters const& parameters) const {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(
       new Instance(problem,
diff --git a/integrators/embedded_explicit_runge_kutta_integrator.hpp b/integrators/embedded_explicit_runge_kutta_integrator.hpp
index 8139c82d19..2f97252619 100644
--- a/integrators/embedded_explicit_runge_kutta_integrator.hpp
+++ b/integrators/embedded_explicit_runge_kutta_integrator.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of of child classes of |Integrator| must be
+// The files containing the tree of of child classes of `Integrator` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
diff --git a/integrators/embedded_explicit_runge_kutta_integrator_body.hpp b/integrators/embedded_explicit_runge_kutta_integrator_body.hpp
index 2c1765fc0f..9d2949658a 100644
--- a/integrators/embedded_explicit_runge_kutta_integrator_body.hpp
+++ b/integrators/embedded_explicit_runge_kutta_integrator_body.hpp
@@ -65,7 +65,7 @@ Solve(typename ODE::IndependentVariable const& s_final) {
   auto& parameters = this->parameters_;
   auto const& equation = this->equation_;
 
-  // |current_state| gets updated as the integration progresses to allow
+  // `current_state` gets updated as the integration progresses to allow
   // restartability.
 
   // State before the last, truncated step.
@@ -124,8 +124,8 @@ Solve(typename ODE::IndependentVariable const& s_final) {
   }
 
   // No step size control on the first step.  If this instance is being
-  // restarted we already have a value of |h| suitable for the next step, based
-  // on the computation of |tolerance_to_error_ratio_| during the last
+  // restarted we already have a value of `h` suitable for the next step, based
+  // on the computation of `tolerance_to_error_ratio_` during the last
   // invocation.
   goto runge_kutta_step;
 
@@ -169,7 +169,7 @@ Solve(typename ODE::IndependentVariable const& s_final) {
         }
       }
 
-      // Runge-Kutta iteration; fills |k|.
+      // Runge-Kutta iteration; fills `k`.
       for (int i = 0; i < stages_; ++i) {
         if (i == 0 && first_same_as_last) {
           // TODO(phl): Use pointers to avoid copying big objects.
@@ -180,7 +180,7 @@ Solve(typename ODE::IndependentVariable const& s_final) {
                   ? s_final
                   : s.value + (s.error + c[i] * h);
 
-          // TODO(phl): Should dimension |Σⱼ_aᵢⱼ_kⱼ| in the not FSAL case.
+          // TODO(phl): Should dimension `Σⱼ_aᵢⱼ_kⱼ` in the not FSAL case.
           DependentVariableDifferences Σⱼ_aᵢⱼ_kⱼ{};
           for (int j = 0; j < i; ++j) {
             for_all_of(k[j], Σⱼ_aᵢⱼ_kⱼ)
@@ -304,7 +304,7 @@ ReadFromMessage(serialization::
                 Time const& time_step,
                 bool const first_use,
                 EmbeddedExplicitRungeKuttaIntegrator const& integrator) {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(new Instance(problem,
                                                 append_state,
@@ -340,7 +340,7 @@ NewInstance(InitialValueProblem<ODE> const& problem,
             AppendState const& append_state,
             ToleranceToErrorRatio const& tolerance_to_error_ratio,
             Parameters const& parameters) const {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(
       new Instance(problem,
diff --git a/integrators/embedded_explicit_runge_kutta_integrator_test.cpp b/integrators/embedded_explicit_runge_kutta_integrator_test.cpp
index b74d4c8e45..b4304afae6 100644
--- a/integrators/embedded_explicit_runge_kutta_integrator_test.cpp
+++ b/integrators/embedded_explicit_runge_kutta_integrator_test.cpp
@@ -245,7 +245,7 @@ TEST_F(EmbeddedExplicitRungeKuttaIntegratorTest, MaxSteps) {
   EXPECT_THAT(solution.back().s.value, Lt(t_final));
   EXPECT_EQ(40, solution.size());
 
-  // Check that a |max_steps| greater than or equal to the unconstrained number
+  // Check that a `max_steps` greater than or equal to the unconstrained number
   // of steps has no effect.
   for (std::int64_t const max_steps :
        {steps_forward, steps_forward + 1234}) {
@@ -408,7 +408,7 @@ TEST_F(EmbeddedExplicitRungeKuttaIntegratorTest, Restart) {
         AlmostEquals(1.237'882'807'009'299'31 * Second, 0));
   }
 
-  // Do it again in one call to |Solve| and check associativity.
+  // Do it again in one call to `Solve` and check associativity.
   std::vector<ODE::State> solution2;
   {
     ODE harmonic_oscillator;
diff --git "a/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator.hpp" "b/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator.hpp"
index 9b6906627c..f91a7d5f53 100644
--- "a/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator.hpp"
+++ "b/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator.hpp"
@@ -1,4 +1,4 @@
-// The files containing the tree of of child classes of |Integrator| must be
+// The files containing the tree of of child classes of `Integrator` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
diff --git "a/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator_body.hpp" "b/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator_body.hpp"
index 0617ca4fcc..3a2594e067 100644
--- "a/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator_body.hpp"
+++ "b/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator_body.hpp"
@@ -59,7 +59,7 @@ Instance::Solve(Instant const& t_final) {
   auto& parameters = this->parameters_;
   auto const& equation = this->equation_;
 
-  // |current_state| gets updated as the integration progresses to allow
+  // `current_state` gets updated as the integration progresses to allow
   // restartability.
 
   // State before the last, truncated step.
@@ -114,9 +114,9 @@ Instance::Solve(Instant const& t_final) {
   double tolerance_to_error_ratio;
 
   // The first stage of the Runge-Kutta-Nyström iteration.  In the FSAL case,
-  // |first_stage == 1| after the first step, since the first RHS evaluation has
+  // `first_stage == 1` after the first step, since the first RHS evaluation has
   // already occurred in the previous step.  In the non-FSAL case and in the
-  // first step of the FSAL case, |first_stage == 0|.
+  // first step of the FSAL case, `first_stage == 0`.
   int first_stage = 0;
 
   // The number of steps already performed.
@@ -126,8 +126,8 @@ Instance::Solve(Instant const& t_final) {
   absl::Status step_status;
 
   // No step size control on the first step.  If this instance is being
-  // restarted we already have a value of |h| suitable for the next step, based
-  // on the computation of |tolerance_to_error_ratio_| during the last
+  // restarted we already have a value of `h` suitable for the next step, based
+  // on the computation of `tolerance_to_error_ratio_` during the last
   // invocation.
   goto runge_kutta_nyström_step;
 
@@ -172,7 +172,7 @@ Instance::Solve(Instant const& t_final) {
 
       auto const h² = h * h;
 
-      // Runge-Kutta-Nyström iteration; fills |g|.
+      // Runge-Kutta-Nyström iteration; fills `g`.
       for (int i = first_stage; i < stages_; ++i) {
         Instant const t_stage =
             (parameters.last_step_is_exact && at_end && c[i] == 1.0)
@@ -300,7 +300,7 @@ ReadFromMessage(
     bool const first_use,
     EmbeddedExplicitRungeKuttaNyströmIntegrator const& integrator)
   requires serializable<typename ODE_::DependentVariable> {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(new Instance(problem,
                                                 append_state,
@@ -336,7 +336,7 @@ NewInstance(InitialValueProblem<ODE> const& problem,
             AppendState const& append_state,
             ToleranceToErrorRatio const& tolerance_to_error_ratio,
             Parameters const& parameters) const {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(
       new Instance(problem,
diff --git "a/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator_test.cpp" "b/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator_test.cpp"
index 45f19a0b49..ae26831e8a 100644
--- "a/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator_test.cpp"
+++ "b/integrators/embedded_explicit_runge_kutta_nystr\303\266m_integrator_test.cpp"
@@ -236,7 +236,7 @@ TEST_F(EmbeddedExplicitRungeKuttaNyströmIntegratorTest, MaxSteps) {
   EXPECT_THAT(solution.back().time.value, Lt(t_final));
   EXPECT_EQ(100, solution.size());
 
-  // Check that a |max_steps| greater than or equal to the unconstrained number
+  // Check that a `max_steps` greater than or equal to the unconstrained number
   // of steps has no effect.
   for (std::int64_t const max_steps :
        {steps_forward, steps_forward + 1234}) {
@@ -393,7 +393,7 @@ TEST_F(EmbeddedExplicitRungeKuttaNyströmIntegratorTest, Restart) {
         AlmostEquals(0.506'410'259'195'249'068 * Second, 0));
   }
 
-  // Do it again in one call to |Solve| and check associativity.
+  // Do it again in one call to `Solve` and check associativity.
   std::vector<ODE::State> solution2;
   {
     ODE harmonic_oscillator;
diff --git a/integrators/explicit_linear_multistep_integrator.hpp b/integrators/explicit_linear_multistep_integrator.hpp
index 8094eeec3d..68d684a56a 100644
--- a/integrators/explicit_linear_multistep_integrator.hpp
+++ b/integrators/explicit_linear_multistep_integrator.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of of child classes of |Integrator| must be
+// The files containing the tree of of child classes of `Integrator` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
diff --git a/integrators/explicit_linear_multistep_integrator_body.hpp b/integrators/explicit_linear_multistep_integrator_body.hpp
index 462fc3e926..d94140eab6 100644
--- a/integrators/explicit_linear_multistep_integrator_body.hpp
+++ b/integrators/explicit_linear_multistep_integrator_body.hpp
@@ -38,8 +38,8 @@ ExplicitLinearMultistepIntegrator<Method, ODE_>::Instance::Solve(
   if (!starter_.started()) {
     starter_.Solve(s_final);
 
-    // If |s_final| is not large enough, we may not have generated enough
-    // points.  Bail out, we'll continue the next time |Solve| is called.
+    // If `s_final` is not large enough, we may not have generated enough
+    // points.  Bail out, we'll continue the next time `Solve` is called.
     if (!starter_.started()) {
       return absl::OkStatus();
     }
@@ -73,7 +73,7 @@ ExplicitLinearMultistepIntegrator<Method, ODE_>::Instance::Solve(
 
     // See [HW10], equation (7).  Note that our indices are numbered
     // consistently with our implementation of the symmetric linear multistep
-    // integrator, so index |j| in [HW10] becomes index |k - j| below.  This
+    // integrator, so index `j` in [HW10] becomes index `k - j` below.  This
     // makes our formula more similar to equation (6) of [HW10].
     for (int j = 1; j <= k; ++j) {
       --it;
@@ -191,7 +191,7 @@ ExplicitLinearMultistepIntegrator<Method, ODE_>::NewInstance(
     InitialValueProblem<ODE> const& problem,
     AppendState const& append_state,
     IndependentVariableDifference const& step) const {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(
       new Instance(problem, append_state, step, *this));
diff --git a/integrators/explicit_linear_multistep_integrator_test.cpp b/integrators/explicit_linear_multistep_integrator_test.cpp
index 62df0a7982..1db120a622 100644
--- a/integrators/explicit_linear_multistep_integrator_test.cpp
+++ b/integrators/explicit_linear_multistep_integrator_test.cpp
@@ -40,7 +40,7 @@ using namespace principia::testing_utilities::_is_near;
 using namespace principia::testing_utilities::_numerics;
 using namespace principia::testing_utilities::_statistics;
 
-// The execution time is exponential in |step_sizes|.
+// The execution time is exponential in `step_sizes`.
 constexpr int step_sizes = 110;
 constexpr double step_reduction = 1.1;
 
@@ -98,8 +98,8 @@ std::ostream& operator<<(std::ostream& stream,
 }
 
 std::vector<IntegratorTestParam> IntegratorTestParams() {
-  // The |initial_number_of_steps| below were carefully chosen using
-  // Mathematica to only select the domain where |p| and |step| are properly
+  // The `initial_number_of_steps` below were carefully chosen using
+  // Mathematica to only select the domain where `p` and `step` are properly
   // correlated.
   return {PARAM(AdamsBashforthOrder2,
                 10,
diff --git a/integrators/explicit_runge_kutta_integrator.hpp b/integrators/explicit_runge_kutta_integrator.hpp
index e721fcb869..1899a1711d 100644
--- a/integrators/explicit_runge_kutta_integrator.hpp
+++ b/integrators/explicit_runge_kutta_integrator.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of of child classes of |Integrator| must be
+// The files containing the tree of of child classes of `Integrator` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
diff --git a/integrators/explicit_runge_kutta_integrator_body.hpp b/integrators/explicit_runge_kutta_integrator_body.hpp
index c12854ee37..0e828bf3ac 100644
--- a/integrators/explicit_runge_kutta_integrator_body.hpp
+++ b/integrators/explicit_runge_kutta_integrator_body.hpp
@@ -105,7 +105,7 @@ Solve(typename ODE::IndependentVariable const& s_final) {
   }
 
   while (abs_h <= Abs((s_final - s.value) - s.error)) {
-    // Runge-Kutta iteration; fills |k|.
+    // Runge-Kutta iteration; fills `k`.
     for (int i = 0; i < stages_; ++i) {
       if (i == 0 && first_same_as_last) {
         // TODO(phl): Use pointers to avoid copying big objects.
@@ -198,7 +198,7 @@ ExplicitRungeKuttaIntegrator<Method, ODE_>::
 NewInstance(InitialValueProblem<ODE> const& problem,
             AppendState const& append_state,
             typename ODE::IndependentVariableDifference const& step) const {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(
       new Instance(problem, append_state, step, *this));
diff --git a/integrators/integrators.hpp b/integrators/integrators.hpp
index 34d94723bd..7379f50572 100644
--- a/integrators/integrators.hpp
+++ b/integrators/integrators.hpp
@@ -44,13 +44,13 @@ class Integrator {
     virtual ~Instance() = default;
 
     // The subclass must document the time (or independent variable) passed to
-    // the last call to |append_state|.
+    // the last call to `append_state`.
     virtual absl::Status Solve(IndependentVariable const& s_final) = 0;
 
     // The equation integrated by this instance.
     ODE const& equation() const;
 
-    // The |AppendState| function.
+    // The `AppendState` function.
     AppendState const& append_state() const;
 
     // The last instant integrated by this instance.
@@ -63,7 +63,7 @@ class Integrator {
     // Performs a copy of this object.
     virtual not_null<std::unique_ptr<Instance>> Clone() const = 0;
 
-    // |ReadFromMessage| is specific to each subclass because of the functions.
+    // `ReadFromMessage` is specific to each subclass because of the functions.
     virtual void WriteToMessage(
         not_null<serialization::IntegratorInstance*> message) const;
 
@@ -88,10 +88,10 @@ class FixedStepSizeIntegrator : public Integrator<ODE_> {
   using ODE = ODE_;
   using typename Integrator<ODE>::AppendState;
 
-  // The last call to |append_state| has a |state.time.value| equal to the
-  // unique |Instant| of the form |t_final + n * step| in
-  // ]t_final - step, t_final].  |append_state| will be called with
-  // |state.time.values|s at intervals differing from |step| by at most one ULP.
+  // The last call to `append_state` has a `state.time.value` equal to the
+  // unique `Instant` of the form `t_final + n * step` in
+  // ]t_final - step, t_final].  `append_state` will be called with
+  // `state.time.values`s at intervals differing from `step` by at most one ULP.
   class Instance : public Integrator<ODE>::Instance {
    public:
     // The time step used by this instance.
@@ -116,7 +116,7 @@ class FixedStepSizeIntegrator : public Integrator<ODE_> {
     Time const step_;
   };
 
-  // The factory function for |Instance|, above.  It ensures that the instance
+  // The factory function for `Instance`, above.  It ensures that the instance
   // has a back-pointer to its integrator.
   virtual not_null<std::unique_ptr<typename Integrator<ODE>::Instance>>
   NewInstance(InitialValueProblem<ODE> const& problem,
@@ -145,13 +145,13 @@ class AdaptiveStepSizeIntegrator : public Integrator<ODE_> {
       typename ODE::IndependentVariableDifference;
   using typename Integrator<ODE>::AppendState;
 
-  // This functor is called at each step, with the |current_step_size| used by
-  // the integrator and the estimated |error| on that step.  It returns the
+  // This functor is called at each step, with the `current_step_size` used by
+  // the integrator and the estimated `error` on that step.  It returns the
   // ratio of a tolerance to some norm of the error.  The step is recomputed
   // with a smaller step size if the result is less than 1, and accepted
   // otherwise.
   // In both cases, the new step size is chosen so as to try and make the
-  // result of the next call to this functor close to |safety_factor|.
+  // result of the next call to this functor close to `safety_factor`.
   using ToleranceToErrorRatio = std::function<double(
       IndependentVariableDifference const& current_step_size,
       typename ODE::State const& state,
@@ -163,7 +163,7 @@ class AdaptiveStepSizeIntegrator : public Integrator<ODE_> {
                std::int64_t max_steps,
                bool last_step_is_exact);
 
-    // |max_steps| is infinite and the last step is exact.
+    // `max_steps` is infinite and the last step is exact.
     Parameters(IndependentVariableDifference const& first_step,
                double safety_factor);
 
@@ -175,21 +175,21 @@ class AdaptiveStepSizeIntegrator : public Integrator<ODE_> {
             message);
 
     // The first step tried by the integrator. It must have the same sign as
-    // |problem.t_final - initial_state.time.value|.
+    // `problem.t_final - initial_state.time.value`.
     IndependentVariableDifference const first_step;
     // This number must be in ]0, 1[.  Higher values increase the chance of step
     // rejection, lower values yield smaller steps.
     double const safety_factor;
-    // Integration will stop after |*max_steps| even if it has not reached
-    // |t_final|.
+    // Integration will stop after `*max_steps` even if it has not reached
+    // `t_final`.
     std::int64_t const max_steps;
-    // If true, the he last call to |append_state| has
-    // |state.time.value == t_final| (unless |max_steps| is reached).  Otherwise
-    // it may have |state.time.value < t_final|.
+    // If true, the he last call to `append_state` has
+    // `state.time.value == t_final` (unless `max_steps` is reached).  Otherwise
+    // it may have `state.time.value < t_final`.
     bool const last_step_is_exact;
   };
 
-  // The last call to |append_state| will have |state.time.value == t_final|.
+  // The last call to `append_state` will have `state.time.value == t_final`.
   class Instance : public Integrator<ODE>::Instance {
    public:
     // The integrator corresponding to this instance.
@@ -218,7 +218,7 @@ class AdaptiveStepSizeIntegrator : public Integrator<ODE_> {
     bool first_use_;
   };
 
-  // The factory function for |Instance|, above.  It ensures that the instance
+  // The factory function for `Instance`, above.  It ensures that the instance
   // has a back-pointer to its integrator.
   virtual not_null<std::unique_ptr<typename Integrator<ODE>::Instance>>
   NewInstance(InitialValueProblem<ODE> const& problem,
diff --git a/integrators/integrators_body.hpp b/integrators/integrators_body.hpp
index 07dfcfb977..28010e7c34 100644
--- a/integrators/integrators_body.hpp
+++ b/integrators/integrators_body.hpp
@@ -17,9 +17,9 @@
 #include "integrators/symplectic_runge_kutta_nyström_integrator.hpp"
 #include "quantities/serialization.hpp"
 
-// A case branch in a switch on the serialized integrator |kind|.  It determines
-// the |method| type from the |kind| defined in scope |message| and calls
-// |action| on it.  |action| must be a 1-argument macro.
+// A case branch in a switch on the serialized integrator `kind`.  It determines
+// the `method` type from the `kind` defined in scope `message` and calls
+// `action` on it.  `action` must be a 1-argument macro.
 #define PRINCIPIA_INTEGRATOR_CASE(message, kind, method, action) \
   case serialization::message::kind: {                           \
     action(method);                                              \
diff --git a/integrators/methods.hpp b/integrators/methods.hpp
index 4cb57b515c..de3fe21be4 100644
--- a/integrators/methods.hpp
+++ b/integrators/methods.hpp
@@ -174,9 +174,9 @@ struct AsSymplecticRungeKuttaNyström {
         composition == serialization::FixedStepSizeIntegrator::ABA
             ? SymplecticPartitionedRungeKuttaMethod::b
             : SymplecticPartitionedRungeKuttaMethod::a};
-    // SymplecticPartitionedRungeKuttaMethod is a |BAB| method, with A and B
-    // interchangeable.  Exchanging A and B shifts |a| (because |ABA| means b₀
-    // vanishes, whereas |BAB| means aᵣ vanishes).
+    // SymplecticPartitionedRungeKuttaMethod is a `BAB` method, with A and B
+    // interchangeable.  Exchanging A and B shifts `a` (because `ABA` means b₀
+    // vanishes, whereas `BAB` means aᵣ vanishes).
     static constexpr FixedVector<double, stages> b{
         composition == serialization::FixedStepSizeIntegrator::ABA
             ? Shift(SymplecticPartitionedRungeKuttaMethod::a)
diff --git a/integrators/ordinary_differential_equations.hpp b/integrators/ordinary_differential_equations.hpp
index 8871a8c659..62f6702d11 100644
--- a/integrators/ordinary_differential_equations.hpp
+++ b/integrators/ordinary_differential_equations.hpp
@@ -25,7 +25,7 @@ using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
 
-// The |Solve| function of the |AdaptiveStepSizeIntegrator| exclusively returns
+// The `Solve` function of the `AdaptiveStepSizeIntegrator` exclusively returns
 // one of the following statuses.
 // Beware!  Do not RETURN_IF_STOPPED from the right-hand side computation, it's
 // too hard to undo the state changes made half way through the loop of the
@@ -43,7 +43,7 @@ constexpr absl::StatusCode VanishingStepSize =
 }  // namespace termination_condition
 
 // A differential equation of the form y′ = f(s, y).
-// |DependentVariable| are the types of the elements of y.
+// `DependentVariable` are the types of the elements of y.
 template<typename IndependentVariable_, typename... DependentVariable>
 struct ExplicitFirstOrderOrdinaryDifferentialEquation final {
   static constexpr std::int64_t order = 1;
@@ -55,9 +55,9 @@ struct ExplicitFirstOrderOrdinaryDifferentialEquation final {
   using DependentVariableDerivatives = std::tuple<
       Derivative<DependentVariable, IndependentVariable>...>;
 
-  // A functor that computes f(s, y) and stores it in |y′|.  This functor must
-  // be called with |std::get<i>(y′).size()| equal to |std::get<i>(y).size()|
-  // for all i, but there is no requirement on the values in |y′|.
+  // A functor that computes f(s, y) and stores it in `y′`.  This functor must
+  // be called with `std::get<i>(y′).size()` equal to `std::get<i>(y).size()`
+  // for all i, but there is no requirement on the values in `y′`.
   using RightHandSideComputation =
       std::function<absl::Status(IndependentVariable const& s,
                                  DependentVariables const& y,
@@ -83,7 +83,7 @@ struct ExplicitFirstOrderOrdinaryDifferentialEquation final {
 };
 
 // A differential equation of the form X′ = A(X, t) + B(X, t), where exp(hA) and
-// exp(hB) are known.  |DependentVariable| are the types of the elements of X.
+// exp(hB) are known.  `DependentVariable` are the types of the elements of X.
 // These equations can be solved using splitting methods.
 template<typename... DependentVariable>
 struct DecomposableFirstOrderDifferentialEquation final {
@@ -115,14 +115,14 @@ struct DecomposableFirstOrderDifferentialEquation final {
 
   // left_flow(t₀, t₁, X₀, X₁) sets X₁ to exp((t₁-t₀)A)X₀, and
   // right_flow(t₀, t₁, X₀, X₁) sets X₁ to exp((t₁-t₀)B)X₀.
-  // The |std::vectors| in X₁ must have the same |size()| as those in X₀.  There
+  // The `std::vectors` in X₁ must have the same `size()` as those in X₀.  There
   // is no other requirement on their values.
   Flow left_flow;
   Flow right_flow;
 };
 
 // A differential equation of the form q″ = f(t, q, q′).
-// |DependentVariable_| is the type of q.
+// `DependentVariable_` is the type of q.
 template<typename DependentVariable_>
 struct ExplicitSecondOrderOrdinaryDifferentialEquation final {
   static constexpr std::int64_t order = 2;
@@ -143,10 +143,10 @@ struct ExplicitSecondOrderOrdinaryDifferentialEquation final {
   using DependentVariableDerivatives2 =
       std::vector<DependentVariableDerivative2>;
 
-  // A functor that computes f(t, q, q′) and stores it in |accelerations|.
-  // This functor must be called with |accelerations.size()| equal to
-  // |positions.size()| and |velocities.size()| but there is no requirement on
-  // the values in |accelerations|.
+  // A functor that computes f(t, q, q′) and stores it in `accelerations`.
+  // This functor must be called with `accelerations.size()` equal to
+  // `positions.size()` and `velocities.size()` but there is no requirement on
+  // the values in `accelerations`.
   using RightHandSideComputation =
       std::function<absl::Status(IndependentVariable const& t,
                                  DependentVariables const& positions,
@@ -181,7 +181,7 @@ struct ExplicitSecondOrderOrdinaryDifferentialEquation final {
 };
 
 // A differential equation of the form q″ = f(t, q).
-// |DependentVariable_| is the type of q.
+// `DependentVariable_` is the type of q.
 template<typename DependentVariable_>
 struct SpecialSecondOrderDifferentialEquation final {
   static constexpr std::int64_t order = 2;
@@ -209,10 +209,10 @@ struct SpecialSecondOrderDifferentialEquation final {
   using State = typename ExplicitSecondOrderOrdinaryDifferentialEquation<
       DependentVariable>::State;
 
-  // A functor that computes f(q, t) and stores it in |accelerations|.
-  // This functor must be called with |accelerations.size()| equal to
-  // |positions.size()|, but there is no requirement on the values in
-  // |acceleration|.
+  // A functor that computes f(q, t) and stores it in `accelerations`.
+  // This functor must be called with `accelerations.size()` equal to
+  // `positions.size()`, but there is no requirement on the values in
+  // `acceleration`.
   RightHandSideComputation compute_acceleration;
 };
 
diff --git a/integrators/starter.hpp b/integrators/starter.hpp
index 83dc2c36da..f57b185ce8 100644
--- a/integrators/starter.hpp
+++ b/integrators/starter.hpp
@@ -13,16 +13,16 @@ namespace internal {
 using namespace principia::base::_not_null;
 using namespace principia::integrators::_integrators;
 
-// A helper object for starting a linear multistep integrator.  |ODE| is the
-// equation being integrated.  |Step| is an object holding the data produced by
+// A helper object for starting a linear multistep integrator.  `ODE` is the
+// equation being integrated.  `Step` is an object holding the data produced by
 // executing a step of the integrator and used for subsequent steps.  The
-// function |FillStepFromState| must fill this object from an |ODE::State|.
-// |steps| is the number of steps of the integrator being started.
+// function `FillStepFromState` must fill this object from an `ODE::State`.
+// `steps` is the number of steps of the integrator being started.
 template<typename ODE, typename Step, int steps>
 class Starter {
  public:
-  // |startup_step_divisor| specifies how many steps of the |startup_integrator|
-  // should be produced for a step of the main integrator.  |instance| is the
+  // `startup_step_divisor` specifies how many steps of the `startup_integrator`
+  // should be produced for a step of the main integrator.  `instance` is the
   // instance of the main integrator.
   Starter(FixedStepSizeIntegrator<ODE> const& startup_integrator,
           std::int64_t startup_step_divisor,
@@ -30,16 +30,16 @@ class Starter {
               instance);
 
   // Performs the startup integration, i.e., computes enough states to either
-  // reach |s_final| or to reach a point where |instance.previous_steps_| has
-  // |order - 1| elements.  During startup |instance.current_state_| is
-  // updated more frequently than once every |instance.step_|.
+  // reach `s_final` or to reach a point where `instance.previous_steps_` has
+  // `order - 1` elements.  During startup `instance.current_state_` is
+  // updated more frequently than once every `instance.step_`.
   void Solve(typename ODE::IndependentVariable const& s_final);
 
-  // Appends a new step to |previous_steps_| and drops the oldest one if needed.
-  // This object must be |started()|.
+  // Appends a new step to `previous_steps_` and drops the oldest one if needed.
+  // This object must be `started()`.
   void Push(Step step);
 
-  // Returns the startup steps.  This object must be |started()|.
+  // Returns the startup steps.  This object must be `started()`.
   std::list<Step> const& previous_steps() const;
 
   // Returns true iff the startup steps have all been computed.
@@ -52,7 +52,7 @@ class Starter {
   void FillFromMessage(Message const& message);
 
  protected:
-  // Must fill |step| from |state| and the right-hand side of the ODE.  |Step|
+  // Must fill `step` from `state` and the right-hand side of the ODE.  `Step`
   // must contain all the information needed to compute subsequent steps of the
   // integrator.
   virtual void FillStepFromState(ODE const& equation,
@@ -72,7 +72,7 @@ class Starter {
       instance_;
 
   int startup_step_index_ = 0;
-  std::list<Step> previous_steps_;  // At most |order| elements.
+  std::list<Step> previous_steps_;  // At most `order` elements.
 };
 
 }  // namespace internal
diff --git a/integrators/starter_body.hpp b/integrators/starter_body.hpp
index 6118019c51..32cedd6ed9 100644
--- a/integrators/starter_body.hpp
+++ b/integrators/starter_body.hpp
@@ -42,7 +42,7 @@ void Starter<ODE, Step, steps>::Solve(
   auto const startup_append_state =
       [this, &current_state, &equation](typename ODE::State const& state) {
         // Stop changing anything once we're done with the startup.  We may be
-        // called one more time by the |startup_integrator_|.
+        // called one more time by the `startup_integrator_`.
         if (previous_steps_.size() < steps) {
           current_state = state;
           // The startup integrator has a smaller step.  We do not record all
@@ -53,7 +53,7 @@ void Starter<ODE, Step, steps>::Solve(
             previous_steps_.emplace_back();
             FillStepFromState(equation, current_state, previous_steps_.back());
             // This call must happen last for a subtle reason: the callback may
-            // want to |Clone| this instance (see |Ephemeris::Checkpoint|) in
+            // want to `Clone` this instance (see `Ephemeris::Checkpoint`) in
             // which cases it is necessary that all the member variables be
             // filled for restartability to work.
             instance_->append_state()(state);
diff --git a/integrators/symmetric_linear_multistep_integrator.hpp b/integrators/symmetric_linear_multistep_integrator.hpp
index 48853174b7..dac4ebf0b0 100644
--- a/integrators/symmetric_linear_multistep_integrator.hpp
+++ b/integrators/symmetric_linear_multistep_integrator.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of of child classes of |Integrator| must be
+// The files containing the tree of of child classes of `Integrator` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 //  parent.
@@ -69,8 +69,8 @@ class SymmetricLinearMultistepIntegrator
       requires serializable<typename ODE_::DependentVariable>;
 
    private:
-    // The data for a previous step of the integration.  The |Displacement|s
-    // here are really |Position|s, but we do complex computations on them and
+    // The data for a previous step of the integration.  The `Displacement`s
+    // here are really `Position`s, but we do complex computations on them and
     // it would be very inconvenient to cast these computations as barycentres.
     struct Step final {
       std::vector<DoublePrecision<typename ODE::DependentVariableDifference>>
diff --git a/integrators/symmetric_linear_multistep_integrator_body.hpp b/integrators/symmetric_linear_multistep_integrator_body.hpp
index 10e9b95ca7..ac7655e205 100644
--- a/integrators/symmetric_linear_multistep_integrator_body.hpp
+++ b/integrators/symmetric_linear_multistep_integrator_body.hpp
@@ -42,8 +42,8 @@ SymmetricLinearMultistepIntegrator<Method, ODE_>::Instance::Solve(
   if (!starter_.started()) {
     starter_.Solve(t_final);
 
-    // If |t_final| is not large enough, we may not have generated enough
-    // points.  Bail out, we'll continue the next time |Solve| is called.
+    // If `t_final` is not large enough, we may not have generated enough
+    // points.  Bail out, we'll continue the next time `Solve` is called.
     if (!starter_.started()) {
       return absl::OkStatus();
     }
@@ -336,7 +336,7 @@ SymmetricLinearMultistepIntegrator<Method, ODE_>::NewInstance(
     InitialValueProblem<ODE> const& problem,
     AppendState const& append_state,
     Time const& step) const {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(
       new Instance(problem, append_state, step, *this));
diff --git a/integrators/symmetric_linear_multistep_integrator_test.cpp b/integrators/symmetric_linear_multistep_integrator_test.cpp
index d4c1c59703..1dc4fa7398 100644
--- a/integrators/symmetric_linear_multistep_integrator_test.cpp
+++ b/integrators/symmetric_linear_multistep_integrator_test.cpp
@@ -107,8 +107,8 @@ std::ostream& operator<<(std::ostream& stream,
 // Not testing QuinlanTremaine1990Order14 as its characteristics cannot even be
 // computed.
 std::vector<SimpleHarmonicMotionTestInstance> Instances() {
-  // The |beginning_of_convergence| below were carefully chosen using
-  // Mathematica to only select the domain where |p| and |step| are properly
+  // The `beginning_of_convergence` below were carefully chosen using
+  // Mathematica to only select the domain where `p` and `step` are properly
   // correlated.
   return {
 #if OS_MACOSX
diff --git a/integrators/symplectic_partitioned_runge_kutta_integrator.hpp b/integrators/symplectic_partitioned_runge_kutta_integrator.hpp
index 504af17b46..4504900042 100644
--- a/integrators/symplectic_partitioned_runge_kutta_integrator.hpp
+++ b/integrators/symplectic_partitioned_runge_kutta_integrator.hpp
@@ -24,31 +24,31 @@ using namespace principia::integrators::_ordinary_differential_equations;
 using namespace principia::quantities::_quantities;
 
 // A symplectic partitioned Runge-Kutta integrator.  Does not subclass
-// |Integrator|; used to generate (less general)
-// |SymplecticRungeKuttaNyströmIntegrator|s.
+// `Integrator`; used to generate (less general)
+// `SymplecticRungeKuttaNyströmIntegrator`s.
 // Represents a single-step method for the solution of
 //   (q, p)′ = X(q, p, t), with X = A(q, p, t) + B(q, p, t).
-// |Position| is the type of |q|, and |Momentum| is that of |p|.
+// `Position` is the type of `q`, and `Momentum` is that of `p`.
 // The step is the composition of evolutions
 //   exp(aᵣ₋₁ h A) exp(bᵣ₋₁ h B) ... exp(a₀ h A) exp(b₀ h B);
 // A and B are interchangeable.  If aᵣ₋₁ vanishes, this becomes
 //   exp(bᵣ₋₁ h B) exp(aᵣ₋₂ h A) ... exp(a₀ h A) exp(b₀ h B).
-// In that case, |first_same_as_last| is true.
+// In that case, `first_same_as_last` is true.
 // The equation solved by this integrator is a general case of that solved by
-// a |SymplecticRungeKuttaNyströmIntegrator|, see equation (1) in the
+// a `SymplecticRungeKuttaNyströmIntegrator`, see equation (1) in the
 // appropriate file.  This may therefore be turned into a
-// |SymplecticRungeKuttaNyströmIntegrator|.
-// In the |first_same_as_last| case, since A and B are interchangeable
-// for a |SymplecticPartitionedRungeKuttaIntegrator|, the step
+// `SymplecticRungeKuttaNyströmIntegrator`.
+// In the `first_same_as_last` case, since A and B are interchangeable
+// for a `SymplecticPartitionedRungeKuttaIntegrator`, the step
 //   exp(bᵣ₋₁ h A) exp(aᵣ₋₂ h B) ... exp(a₀ h B) exp(b₀ h A)
 // also provides an integrator.  Since for a
-// |SymplecticRungeKuttaNyströmIntegrator| A and B are *not* interchangeable,
+// `SymplecticRungeKuttaNyströmIntegrator` A and B are *not* interchangeable,
 // because of the requirement that [B, [B, [B, A]]] = 0 in (1), there are two
-// different |SymplecticRungeKuttaNyströmIntegrator| corresponding to a
-// |first_same_as_last| |SymplecticPartitionedRungeKuttaIntegrator|: one is
-// |ABA|, the other is |BAB|.
-// NOTE(egg): The |SymplecticRungeKuttaNyströmIntegrator| thus constructed will
-// serialize as a |DUMMY| and probably break in all sorts of hilarious ways if
+// different `SymplecticRungeKuttaNyströmIntegrator` corresponding to a
+// `first_same_as_last` `SymplecticPartitionedRungeKuttaIntegrator`: one is
+// `ABA`, the other is `BAB`.
+// NOTE(egg): The `SymplecticRungeKuttaNyströmIntegrator` thus constructed will
+// serialize as a `DUMMY` and probably break in all sorts of hilarious ways if
 // deserialized.
 // TODO(egg): Make them serializable/deserializable.  We need to prevent
 // combinatorial explosion.
diff --git "a/integrators/symplectic_runge_kutta_nystr\303\266m_integrator.hpp" "b/integrators/symplectic_runge_kutta_nystr\303\266m_integrator.hpp"
index 7259860c10..5656864b9f 100644
--- "a/integrators/symplectic_runge_kutta_nystr\303\266m_integrator.hpp"
+++ "b/integrators/symplectic_runge_kutta_nystr\303\266m_integrator.hpp"
@@ -1,4 +1,4 @@
-// The files containing the tree of of child classes of |Integrator| must be
+// The files containing the tree of of child classes of `Integrator` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 //  parent.
@@ -50,8 +50,8 @@ using namespace principia::quantities::_quantities;
 //   exp(bᵣ₋₁ h B) exp(aᵣ₋₂ h A) ... exp(a₀ h A) exp(b₀ h B).
 // The former is called type ABA, the latter type BAB, following the conventions
 // used in [BCR01b].
-// In the implementation, we call |stages_| the integer r above.  The number of
-// |evaluations| is r-1 in the ABA and BAB cases, and r otherwise.
+// In the implementation, we call `stages_` the integer r above.  The number of
+// `evaluations` is r-1 in the ABA and BAB cases, and r otherwise.
 // See the documentation for an explanation of how types ABA and BAB reduce the
 // number of evaluations required, especially in cases (2) and (3).
 
diff --git "a/integrators/symplectic_runge_kutta_nystr\303\266m_integrator_body.hpp" "b/integrators/symplectic_runge_kutta_nystr\303\266m_integrator_body.hpp"
index 0512152015..1564ad6689 100644
--- "a/integrators/symplectic_runge_kutta_nystr\303\266m_integrator_body.hpp"
+++ "b/integrators/symplectic_runge_kutta_nystr\303\266m_integrator_body.hpp"
@@ -38,7 +38,7 @@ Instance::Solve(Instant const& t_final) {
   auto const& equation = this->equation_;
   auto const& step = this->step_;
 
-  // |current_state| is updated as the integration progresses to allow
+  // `current_state` is updated as the integration progresses to allow
   // restartability.
 
   // Argument checks.
@@ -244,7 +244,7 @@ SymplecticRungeKuttaNyströmIntegrator<Method, ODE_>::NewInstance(
     InitialValueProblem<ODE> const& problem,
     AppendState const& append_state,
     Time const& step) const {
-  // Cannot use |make_not_null_unique| because the constructor of |Instance| is
+  // Cannot use `make_not_null_unique` because the constructor of `Instance` is
   // private.
   return std::unique_ptr<Instance>(
       new Instance(problem, append_state, step, *this));
diff --git "a/integrators/symplectic_runge_kutta_nystr\303\266m_integrator_test.cpp" "b/integrators/symplectic_runge_kutta_nystr\303\266m_integrator_test.cpp"
index 8bf3eb94bd..29e69f87ac 100644
--- "a/integrators/symplectic_runge_kutta_nystr\303\266m_integrator_test.cpp"
+++ "b/integrators/symplectic_runge_kutta_nystr\303\266m_integrator_test.cpp"
@@ -175,8 +175,8 @@ std::vector<SimpleHarmonicMotionTestInstance> Instances() {
                    +1.11001485780803930e-13 * Metre,
                    +1.11056996932035190e-13 * Metre / Second,
                    +6.29052365752613700e-13 * Joule),
-          // We test |NewtonDelambreStørmerVerletLeapfrog| both as |ABA| and
-          // |BAB| (sometimes called leapfrog and pseudo-leapfrog) for coverage.
+          // We test `NewtonDelambreStørmerVerletLeapfrog` both as `ABA` and
+          // `BAB` (sometimes called leapfrog and pseudo-leapfrog) for coverage.
           // We test the others as BAB integrators only.
           SPRK_INSTANCE(NewtonDelambreStørmerVerletLeapfrog,
                         ABA,
@@ -363,8 +363,8 @@ std::vector<SimpleHarmonicMotionTestInstance> Instances() {
                    +1.11001485780803930e-13 * Metre,
                    +1.11063935825939100e-13 * Metre / Second,
                    +6.29052365752613700e-13 * Joule),
-          // We test |NewtonDelambreStørmerVerletLeapfrog| both as |ABA| and
-          // |BAB| (sometimes called leapfrog and pseudo-leapfrog) for coverage.
+          // We test `NewtonDelambreStørmerVerletLeapfrog` both as `ABA` and
+          // `BAB` (sometimes called leapfrog and pseudo-leapfrog) for coverage.
           // We test the others as BAB integrators only.
           SPRK_INSTANCE(NewtonDelambreStørmerVerletLeapfrog,
                         ABA,
diff --git a/journal/method.hpp b/journal/method.hpp
index 5af0df831e..8bafd208e1 100644
--- a/journal/method.hpp
+++ b/journal/method.hpp
@@ -17,7 +17,7 @@ using namespace principia::base::_not_constructible;
 using namespace principia::base::_not_null;
 using namespace principia::journal::_concepts;
 
-// The parameter |Profile| is expected to have the following structure:
+// The parameter `Profile` is expected to have the following structure:
 //
 //  struct SomeProfile : not_constructible {
 //    struct In final {  // Only present if the profile has 'in' parameters.
@@ -44,19 +44,19 @@ class Method final {
  public:
   Method();
 
-  // Only declare this constructor if the profile has an |In| type and no |Out|
+  // Only declare this constructor if the profile has an `In` type and no `Out`
   // type.
   template<typename P = Profile>
   explicit Method(typename P::In const& in)
     requires has_in<P> && (!has_out<P>);
 
-  // Only declare this constructor if the profile has an |Out| type and no |In|
+  // Only declare this constructor if the profile has an `Out` type and no `In`
   // type.
   template<typename P = Profile>
   explicit Method(typename P::Out const& out)
     requires has_out<P> && (!has_in<P>);
 
-  // Only declare this constructor if the profile has an |In| and an |Out|
+  // Only declare this constructor if the profile has an `In` and an `Out`
   // type.
   template<typename P = Profile>
   Method(typename P::In const& in, typename P::Out const& out)
@@ -64,11 +64,11 @@ class Method final {
 
   ~Method();
 
-  // Only declare this method if the profile has no |Return| type.
+  // Only declare this method if the profile has no `Return` type.
   template<typename P = Profile>
   void Return() requires (!has_return<P>);  // NOLINT
 
-  // Only declare this method if the profile has a |Return| type.
+  // Only declare this method if the profile has a `Return` type.
   template<typename P = Profile>
   typename P::Return Return(typename P::Return const& result)
     requires has_return<P>;
@@ -84,7 +84,7 @@ class Method final {
 }  // namespace _method
 
 // To preserve a reasonable style in the interface, we export this class
-// directly in |journal|.
+// directly in `journal`.
 using _method::internal::Method;
 
 }  // namespace journal
diff --git a/journal/player.cpp b/journal/player.cpp
index 7704c7259f..372a26498d 100644
--- a/journal/player.cpp
+++ b/journal/player.cpp
@@ -78,7 +78,7 @@ bool Player::Process(std::unique_ptr<serialization::Method> method_in,
 
   // Check that the version of the journal matches that of the binary.  Remember
   // that a GetVersion message is logged in Recorder::Activate, so it's always
-  // present.  The |StartsWith| test below allows the "-dirty" suffix, which is
+  // present.  The `StartsWith` test below allows the "-dirty" suffix, which is
   // typically present when debugging.
   if (method_in->HasExtension(serialization::GetVersion::extension)) {
     auto const& get_version_out =
diff --git a/journal/player.hpp b/journal/player.hpp
index b2de0c636d..faacd1c201 100644
--- a/journal/player.hpp
+++ b/journal/player.hpp
@@ -23,10 +23,10 @@ class Player final {
   explicit Player(std::filesystem::path const& path);
 
   // Replays the next message in the journal.  Returns false at end of journal.
-  // |index| is the 0-based index of the message in the journal.
+  // `index` is the 0-based index of the message in the journal.
   bool Play(int index);
 
-  // Same as |Play|, but does not execute the messages, only parse them.
+  // Same as `Play`, but does not execute the messages, only parse them.
   bool Scan(int index);
 
   // Return the last replayed messages.
@@ -34,10 +34,10 @@ class Player final {
   serialization::Method const& last_method_out_return() const;
 
  private:
-  // Reads one message from the stream.  Returns a |nullptr| at end of stream.
+  // Reads one message from the stream.  Returns a `nullptr` at end of stream.
   std::unique_ptr<serialization::Method> Read();
 
-  // Implementation of |Play| and |Scan|.
+  // Implementation of `Play` and `Scan`.
   bool Process(std::unique_ptr<serialization::Method> method_in,
                int const index, bool const play);
 
diff --git a/journal/player_test.cpp b/journal/player_test.cpp
index 30244d4968..e24e22fe34 100644
--- a/journal/player_test.cpp
+++ b/journal/player_test.cpp
@@ -91,7 +91,7 @@ TEST_F(PlayerTest, DISABLED_SECULAR_Benchmarks) {
 }
 
 // A convenience test to find the last unpaired method of a journal.  You must
-// set |path|.
+// set `path`.
 TEST_F(PlayerTest, DISABLED_SECULAR_Scan) {
   std::string path =
       R"(P:\Public Mockingbird\Principia\Crashes\3375\JOURNAL.20220610-092143)";  // NOLINT
@@ -109,8 +109,8 @@ TEST_F(PlayerTest, DISABLED_SECULAR_Scan) {
              << player.last_method_out_return().DebugString();
 }
 
-// A test to debug a journal.  You must set |path| and fill the |method_in| and
-// |method_out_return| protocol buffers.
+// A test to debug a journal.  You must set `path` and fill the `method_in` and
+// `method_out_return` protocol buffers.
 TEST_F(PlayerTest, DISABLED_SECULAR_Debug) {
   std::string path =
       R"(P:\Public Mockingbird\Principia\Issues\3872\JOURNAL.20240210-173425)";  // NOLINT
diff --git a/journal/profiles.cpp b/journal/profiles.cpp
index 2443b35326..b73a50c6b9 100644
--- a/journal/profiles.cpp
+++ b/journal/profiles.cpp
@@ -52,8 +52,8 @@ T DeserializePointer(std::uint64_t const address,
   }
 }
 
-// This function uses a |std::string| to store non-UTF-8 data (UTF-16
-// specifically) because proto is silly and uses |std::string| for bytes as well
+// This function uses a `std::string` to store non-UTF-8 data (UTF-16
+// specifically) because proto is silly and uses `std::string` for bytes as well
 // as string.
 [[maybe_unused]] std::u16string DeserializeUtf16(
     std::string const& serialized) {
@@ -67,7 +67,7 @@ std::uint64_t SerializePointer(T* t) {
   return reinterpret_cast<std::uint64_t>(t);
 }
 
-// See the comment on |DeserializeUtf16| regarding the usage of |std::string|.
+// See the comment on `DeserializeUtf16` regarding the usage of `std::string`.
 [[maybe_unused]] std::string SerializeUtf16(
     char16_t const* const deserialized) {
   // Note that the string constructed here contains the final char16_t null.
diff --git a/journal/profiles.hpp b/journal/profiles.hpp
index ccb44cc967..bd308b00b0 100644
--- a/journal/profiles.hpp
+++ b/journal/profiles.hpp
@@ -21,7 +21,7 @@ namespace principia {
 namespace journal {
 
 // This file is not included from other headers, only translation units, so we
-// allow pollution of the |journal| namespace.
+// allow pollution of the `journal` namespace.
 using interface::AdaptiveStepParameters;
 using interface::BodyGeopotentialElement;
 using interface::BodyParameters;
diff --git a/ksp_plugin/celestial.hpp b/ksp_plugin/celestial.hpp
index fd4afb797e..865b3eb9b3 100644
--- a/ksp_plugin/celestial.hpp
+++ b/ksp_plugin/celestial.hpp
@@ -28,7 +28,7 @@ using namespace principia::physics::_degrees_of_freedom;
 using namespace principia::physics::_rotating_body;
 using namespace principia::quantities::_named_quantities;
 
-// Represents a KSP |CelestialBody|.
+// Represents a KSP `CelestialBody`.
 class Celestial {
  public:
   explicit Celestial(not_null<RotatingBody<Barycentric> const*> body);
@@ -36,7 +36,7 @@ class Celestial {
   Celestial(Celestial&&) = delete;
   virtual ~Celestial() = default;
 
-  // True if, and only if, |trajectory_| is not null.
+  // True if, and only if, `trajectory_` is not null.
   bool is_initialized() const;
   void set_trajectory(
       not_null<ContinuousTrajectory<Barycentric> const*> trajectory);
diff --git a/ksp_plugin/equator_relevance_threshold.hpp b/ksp_plugin/equator_relevance_threshold.hpp
index 426e73602a..c3f587b872 100644
--- a/ksp_plugin/equator_relevance_threshold.hpp
+++ b/ksp_plugin/equator_relevance_threshold.hpp
@@ -13,11 +13,11 @@ using namespace principia::ksp_plugin::_frames;
 using namespace principia::physics::_rotating_body;
 using namespace principia::quantities::_quantities;
 
-// Returns a distance from |body| that we consider is too far for the equator to
+// Returns a distance from `body` that we consider is too far for the equator to
 // be of interest.  Specifically, this distance is the maximum of
 // - the semimajor axis of a supersynchronous orbit (1 orbit for 2 body
 //   revolutions);
-// - the distance at which a  |Geopotential| with a tolerance of 0x1p-24 starts
+// - the distance at which a `Geopotential` with a tolerance of 0x1p-24 starts
 //   damping dynamical oblateness;
 Length EquatorRelevanceThreshold(RotatingBody<Barycentric> const& body);
 
diff --git a/ksp_plugin/flight_plan.cpp b/ksp_plugin/flight_plan.cpp
index 0b06e895da..6c886b2c1e 100644
--- a/ksp_plugin/flight_plan.cpp
+++ b/ksp_plugin/flight_plan.cpp
@@ -97,7 +97,7 @@ FlightPlan::FlightPlan(FlightPlan const& other)
     }
     bool first_point = true;
     for (auto const& [time, degrees_of_freedom] : other_segment) {
-      // For segments other than the first, |NewSegment| copied the last point
+      // For segments other than the first, `NewSegment` copied the last point
       // of the previous segment.
       if (!first_point || first_segment) {
         CHECK_OK(trajectory_.Append(time, degrees_of_freedom));
@@ -207,7 +207,7 @@ absl::Status FlightPlan::Replace(NavigationManœuvre::Burn const& burn,
     return DoesNotFit();
   }
 
-  // Replace the manœuvre at position |index| and rebuild all the ones that
+  // Replace the manœuvre at position `index` and rebuild all the ones that
   // follow as they may have a different initial mass.  Also pop the segments
   // that we'll recompute.
   manœuvres_[index] = manœuvre;
@@ -613,7 +613,7 @@ void FlightPlan::PopLastSegment() {
 
 void FlightPlan::PopSegmentsAffectedByManœuvre(int const index) {
   // We will keep, for each manœuvre in [0, index[, its burn and the coast
-  // preceding it, as well as the coast preceding manœuvre |index|.
+  // preceding it, as well as the coast preceding manœuvre `index`.
   int const segments_kept = 2 * index + 1;
   while (number_of_segments() > segments_kept) {
     PopLastSegment();
@@ -636,7 +636,7 @@ void FlightPlan::MakeProlongator(Instant const& prolongation_time) {
   // A helper lambda to swallow the status of RETURN_IF_STOPPED.
   auto const prolong_with_status = [this](Instant const& prolongation_time) {
     // The loop makes sure that we give the main thread a chance to call
-    // methods of the ephemeris.  The call to |Prolong| below is expected
+    // methods of the ephemeris.  The call to `Prolong` below is expected
     // to take about 40 ms.
     do {
       RETURN_IF_STOPPED;
diff --git a/ksp_plugin/flight_plan.hpp b/ksp_plugin/flight_plan.hpp
index e7699b4e5c..45633c6e2d 100644
--- a/ksp_plugin/flight_plan.hpp
+++ b/ksp_plugin/flight_plan.hpp
@@ -34,14 +34,14 @@ using namespace principia::physics::_ephemeris;
 using namespace principia::quantities::_quantities;
 
 // A chain of trajectories obtained by executing the corresponding
-// |NavigationManœuvre|s.
+// `NavigationManœuvre`s.
 class FlightPlan {
  public:
-  // Creates a |FlightPlan| with no burns starting at |initial_time| with
-  // |initial_degrees_of_freedom| and with the given |initial_mass|.  The
+  // Creates a `FlightPlan` with no burns starting at `initial_time` with
+  // `initial_degrees_of_freedom` and with the given `initial_mass`.  The
   // trajectories are computed using the given parameters by the given
-  // |ephemeris|.  The flight plan contains a single coast which, if possible
-  // ends at |desired_final_time|.
+  // `ephemeris`.  The flight plan contains a single coast which, if possible
+  // ends at `desired_final_time`.
   FlightPlan(Mass const& initial_mass,
              Instant const& initial_time,
              DegreesOfFreedom<Barycentric> initial_degrees_of_freedom,
@@ -60,7 +60,7 @@ class FlightPlan {
   virtual Instant initial_time() const;
   virtual Instant desired_final_time() const;
 
-  // End time of the last coast.  If this is less than |desired_final_time()|,
+  // End time of the last coast.  If this is less than `desired_final_time()`,
   // there is at least an anomalous manœuvre.
   virtual Instant actual_final_time() const;
 
@@ -74,35 +74,35 @@ class FlightPlan {
   virtual int number_of_anomalous_manœuvres() const;
 
   // Returns the status associated with the first anomalous segment.  Note that
-  // this may be non-OK even if |number_of_anomalous_manœuvres()| is 0, in the
+  // this may be non-OK even if `number_of_anomalous_manœuvres()` is 0, in the
   // case where only the final coast is anomalous.  The functions that change
   // manœuvres as well as the function that "avoid deadlines" may change this
   // status.
   virtual absl::Status const& anomalous_status() const;
 
-  // Returns the specified manœuvre.  |index| must be in
+  // Returns the specified manœuvre.  `index` must be in
   // [0, number_of_manœuvres()[.
   virtual NavigationManœuvre const& GetManœuvre(int index) const;
 
-  // Inserts a manœuvre at the given |index| using the specified |burn|. |index|
+  // Inserts a manœuvre at the given `index` using the specified `burn`. `index`
   // must be in [0, number_of_manœuvres()].  Returns an error and has no effect
-  // if the given |burn| cannot fit between the preceding burn and the following
+  // if the given `burn` cannot fit between the preceding burn and the following
   // one or the end of the flight plan.  Otherwise, updates the flight plan and
   // returns the integration status.
   virtual absl::Status Insert(NavigationManœuvre::Burn const& burn, int index);
 
-  // Removes the manœuvre with the given |index|, which must be in
+  // Removes the manœuvre with the given `index`, which must be in
   // [0, number_of_manœuvres()[.
   virtual absl::Status Remove(int index);
 
-  // Replaces a manœuvre with one using the specified |burn|.  |index| must be
+  // Replaces a manœuvre with one using the specified `burn`.  `index` must be
   // in [0, number_of_manœuvres()[.  Returns an error and has no effect if the
-  // given |burn| cannot fit between the preceding and following burns.
+  // given `burn` cannot fit between the preceding and following burns.
   // Otherwise, updates the flight plan and returns the integration status.
   virtual absl::Status Replace(NavigationManœuvre::Burn const& burn, int index);
 
   // Updates the desired final time of the flight plan.  Returns an error and
-  // has no effect if |desired_final_time| is before the beginning of the last
+  // has no effect if `desired_final_time` is before the beginning of the last
   // coast.
   virtual absl::Status SetDesiredFinalTime(Instant const& desired_final_time);
 
@@ -122,7 +122,7 @@ class FlightPlan {
   // Returns the number of trajectories in this object.
   virtual int number_of_segments() const;
 
-  // |index| must be in [0, number_of_segments()[.
+  // `index` must be in [0, number_of_segments()[.
   virtual DiscreteTrajectorySegmentIterator<Barycentric>
   GetSegment(int index) const;
   virtual DiscreteTrajectory<Barycentric> const& GetAllSegments() const;
@@ -139,14 +139,14 @@ class FlightPlan {
   // dynamically.
   void EnableAnalysis(bool enabled);
 
-  // |coast_index| must be in [0, number_of_manœuvres()].
+  // `coast_index` must be in [0, number_of_manœuvres()].
   virtual OrbitAnalyser::Analysis* analysis(int coast_index);
   double progress_of_analysis(int coast_index) const;
 
   void WriteToMessage(not_null<serialization::FlightPlan*> message) const;
 
   // This may return a null pointer if the flight plan contained in the
-  // |message| is anomalous.
+  // `message` is anomalous.
   static std::unique_ptr<FlightPlan> ReadFromMessage(
       serialization::FlightPlan const& message,
       not_null<Ephemeris<Barycentric>*> ephemeris);
@@ -165,7 +165,7 @@ class FlightPlan {
   FlightPlan();
 
  private:
-  // Clears and recomputes all trajectories in |segments_|.
+  // Clears and recomputes all trajectories in `segments_`.
   absl::Status RecomputeAllSegments();
 
   // If the flight plan is anomalous because of an integration deadline, try to
@@ -173,23 +173,23 @@ class FlightPlan {
   // the ephemeris has been prolonged enough.
   absl::Status RecomputeSegmentsAvoidingDeadlineIfNeeded();
 
-  // Flows the given |segment| for the duration of |manœuvre| using its
+  // Flows the given `segment` for the duration of `manœuvre` using its
   // intrinsic acceleration.
   absl::Status BurnSegment(
       NavigationManœuvre const& manœuvre,
       DiscreteTrajectorySegmentIterator<Barycentric> segment,
       std::int64_t max_ephemeris_steps);
 
-  // Flows the given |segment| until |desired_final_time| with no intrinsic
+  // Flows the given `segment` until `desired_final_time` with no intrinsic
   // acceleration.
   absl::Status CoastSegment(
       Instant const& desired_final_time,
       DiscreteTrajectorySegmentIterator<Barycentric> segment,
       std::int64_t max_ephemeris_steps);
 
-  // Computes new trajectories and appends them to |segments_|.  This updates
-  // the last coast of |segments_| and then appends one coast and one burn for
-  // each manœuvre in |manœuvres|.  If one of the integration returns an error,
+  // Computes new trajectories and appends them to `segments_`.  This updates
+  // the last coast of `segments_` and then appends one coast and one burn for
+  // each manœuvre in `manœuvres`.  If one of the integration returns an error,
   // returns that error.  In this case the trajectories that follow the one in
   // error are of length 0 and are anomalous.
   // TODO(phl): The argument should really be an std::span, but then Apple has
@@ -198,7 +198,7 @@ class FlightPlan {
                                std::vector<NavigationManœuvre>::iterator end,
                                std::int64_t max_ephemeris_steps);
 
-  // Adds a trajectory to |segments_|, forked at the end of the last one.  If
+  // Adds a trajectory to `segments_`, forked at the end of the last one.  If
   // there are already anomalous trajectories, the newly created trajectory is
   // anomalous too.
   void AddLastSegment();
@@ -207,18 +207,18 @@ class FlightPlan {
   // only anomalous one, there are no anomalous trajectories after this call.
   void ResetLastSegment();
 
-  // Deletes the last trajectory and removes it from |segments_|.  If there are
+  // Deletes the last trajectory and removes it from `segments_`.  If there are
   // anomalous trajectories, their number is decremented and may become 0.
   void PopLastSegment();
 
   // Pops the burn of the manœuvre with the given index and all following
   // segments, then resets the last segment (which is the coast preceding
-  // |manœuvres_[index]|).
+  // `manœuvres_[index]`).
   void PopSegmentsAffectedByManœuvre(int index);
 
-  // Reconstructs each manœuvre after |manœuvres_[index]| (starting with
-  // |manœuvres_[index + 1]|), keeping the same burns but recomputing the
-  // initial masses from |manœuvres_[index].final_mass()|.
+  // Reconstructs each manœuvre after `manœuvres_[index]` (starting with
+  // `manœuvres_[index + 1]`), keeping the same burns but recomputing the
+  // initial masses from `manœuvres_[index].final_mass()`.
   void UpdateInitialMassOfManœuvresAfter(int index);
 
   // Starts a thread to prolong the ephemeris if needed.
@@ -226,7 +226,7 @@ class FlightPlan {
 
   Instant start_of_last_coast() const;
 
-  // In the following functions, |index| refers to the index of a manœuvre.
+  // In the following functions, `index` refers to the index of a manœuvre.
   Instant start_of_burn(int index) const;
   Instant start_of_next_burn(int index) const;
   Instant start_of_previous_coast(int index) const;
@@ -244,12 +244,12 @@ class FlightPlan {
 
   // Never empty; Starts and ends with a coast; coasts and burns alternate.
   std::vector<DiscreteTrajectorySegmentIterator<Barycentric>> segments_;
-  // The last |anomalous_segments_| of |segments_| are anomalous, i.e., they
+  // The last `anomalous_segments_` of `segments_` are anomalous, i.e., they
   // either end prematurely or follow an anomalous segment; in the latter case
   // they are empty.
   int anomalous_segments_ = 0;
   // The status of the first anomalous segment.  Set and used exclusively by
-  // |ComputeSegments|.
+  // `ComputeSegments`.
   absl::Status anomalous_status_;
 
   std::vector<NavigationManœuvre> manœuvres_;
diff --git a/ksp_plugin/flight_plan_optimization_driver.hpp b/ksp_plugin/flight_plan_optimization_driver.hpp
index 1f88c32729..9db754a52e 100644
--- a/ksp_plugin/flight_plan_optimization_driver.hpp
+++ b/ksp_plugin/flight_plan_optimization_driver.hpp
@@ -46,8 +46,8 @@ class FlightPlanOptimizationDriver {
   // optimization is already happening.
   void RequestOptimization(Parameters const& parameters);
 
-  // Returns the last parameters passed to |RequestOptimization|, or nullopt if
-  // |RequestOptimization| was not called.
+  // Returns the last parameters passed to `RequestOptimization`, or nullopt if
+  // `RequestOptimization` was not called.
   std::optional<Parameters> const& last_parameters() const;
 
   // Waits for the current optimization (if any) to complete.
diff --git a/ksp_plugin/flight_plan_optimizer.cpp b/ksp_plugin/flight_plan_optimizer.cpp
index 304ba5aee9..558a5dc26b 100644
--- a/ksp_plugin/flight_plan_optimizer.cpp
+++ b/ksp_plugin/flight_plan_optimizer.cpp
@@ -31,11 +31,11 @@ using namespace principia::physics::_apsides;
 using namespace principia::quantities::_elementary_functions;
 using namespace principia::quantities::_si;
 
-// Conversion factors between |Argument| and |HomogeneousArgument|.
+// Conversion factors between `Argument` and `HomogeneousArgument`.
 constexpr Time time_homogeneization_factor = 1 * Second;
 constexpr Speed speed_homogeneization_factor = 1 * Metre / Second;
 
-// The displacement in |HomogeneousArgument| used to compute the derivatives.
+// The displacement in `HomogeneousArgument` used to compute the derivatives.
 constexpr double δ_homogeneous_argument = 1e-3;
 
 // By how much we extend the flight plan when it is too short to find
@@ -523,7 +523,7 @@ FlightPlanOptimizer::FlightPlanOptimizer(
 
 absl::Status FlightPlanOptimizer::Optimize(int const index,
                                            Speed const& Δv_tolerance) {
-  // We are going to repeatedly tweak the |flight_plan_|, no point in running
+  // We are going to repeatedly tweak the `flight_plan_`, no point in running
   // the orbit analysers.
   flight_plan_->EnableAnalysis(/*enabled=*/false);
 
@@ -531,7 +531,7 @@ absl::Status FlightPlanOptimizer::Optimize(int const index,
   cache_.clear();
 
   // The following is a copy, and is not affected by changes to the
-  // |flight_plan_|.  It is moved into the metric.
+  // `flight_plan_`.  It is moved into the metric.
   NavigationManœuvre manœuvre = flight_plan_->GetManœuvre(index);
   auto const metric = metric_factory_(this, std::move(manœuvre), index);
 
diff --git a/ksp_plugin/flight_plan_optimizer.hpp b/ksp_plugin/flight_plan_optimizer.hpp
index 4a8b563b6b..8b2c573612 100644
--- a/ksp_plugin/flight_plan_optimizer.hpp
+++ b/ksp_plugin/flight_plan_optimizer.hpp
@@ -48,11 +48,11 @@ class FlightPlanOptimizer {
     Velocity<Frenet<Navigation>> ΔΔv;
   };
 
-  // For the gradient descent algorithm, |Argument| is transformed into a
+  // For the gradient descent algorithm, `Argument` is transformed into a
   // homogeneous array of numbers.
   using HomogeneousArgument = FixedVector<double, 4>;
 
-  // These functions convert between the two representations of |Argument|.
+  // These functions convert between the two representations of `Argument`.
   static HomogeneousArgument Homogeneize(Argument const& argument);
   static Argument Dehomogeneize(
       HomogeneousArgument const& homogeneous_argument);
@@ -113,14 +113,14 @@ class FlightPlanOptimizer {
   // state of the flight plan.
   using ProgressCallback = std::function<void(FlightPlan const&)>;
 
-  // Constructs an optimizer for |flight_plan|.  |flight_plan| must outlive this
+  // Constructs an optimizer for `flight_plan`.  `flight_plan` must outlive this
   // object.
   FlightPlanOptimizer(not_null<FlightPlan*> flight_plan,
                       MetricFactory metric_factory,
                       ProgressCallback progress_callback = nullptr);
 
-  // Optimizes the manœuvre at the given |index| to minimize the metric passed
-  // at construction.  The |Δv_tolerance| is used for the initial choice of the
+  // Optimizes the manœuvre at the given `index` to minimize the metric passed
+  // at construction.  The `Δv_tolerance` is used for the initial choice of the
   // step and for deciding when to stop, and must be small enough to not miss
   // interesting features of the trajectory, and large enough to avoid costly
   // startup steps.  Changes the flight plan passed at construction.
@@ -145,8 +145,8 @@ class FlightPlanOptimizer {
   using LengthGradient = Gradient<Length, HomogeneousArgument>;
   using AngleGradient = Gradient<Angle, HomogeneousArgument>;
 
-  // Compute the closest periapsis of the |flight_plan| with respect to the
-  // |celestial|, occurring after |begin_time|.  If |extend_if_needed| is true,
+  // Compute the closest periapsis of the `flight_plan` with respect to the
+  // `celestial`, occurring after `begin_time`.  If `extend_if_needed` is true,
   // the flight plan is extended until its end is not the point that minimizes
   // the metric.
   DiscreteTrajectory<Barycentric>::value_type EvaluateClosestPeriapsis(
@@ -154,8 +154,8 @@ class FlightPlanOptimizer {
       Instant const& begin_time,
       bool extend_if_needed) const;
 
-  // Replaces the manœuvre at the given |index| based on the |argument|, and
-  // computes the closest periapis.  Leaves the |flight_plan| unchanged.
+  // Replaces the manœuvre at the given `index` based on the `argument`, and
+  // computes the closest periapis.  Leaves the `flight_plan` unchanged.
   DiscreteTrajectory<Barycentric>::value_type EvaluatePeriapsisWithReplacement(
       Celestial const& celestial,
       HomogeneousArgument const& homogeneous_argument,
@@ -168,9 +168,9 @@ class FlightPlanOptimizer {
       NavigationManœuvre const& manœuvre,
       int index);
 
-  // Replaces the manœuvre at the given |index| based on the |argument|, and
+  // Replaces the manœuvre at the given `index` based on the `argument`, and
   // computes the gradient of the closest periapis with respect to the
-  // |argument|.  Leaves the |flight_plan| unchanged.
+  // `argument`.  Leaves the `flight_plan` unchanged.
   LengthGradient Evaluate𝛁DistanceToCelestialWithReplacement(
       Celestial const& celestial,
       HomogeneousArgument const& homogeneous_argument,
@@ -209,8 +209,8 @@ class FlightPlanOptimizer {
       NavigationManœuvre const& manœuvre,
       int index);
 
-  // Returns a burn obtained by applying the changes in |homogeneous_argument|
-  // to the |manœuvre|.
+  // Returns a burn obtained by applying the changes in `homogeneous_argument`
+  // to the `manœuvre`.
   static NavigationManœuvre::Burn UpdatedBurn(
       HomogeneousArgument const& homogeneous_argument,
       NavigationManœuvre const& manœuvre);
diff --git a/ksp_plugin/frames.hpp b/ksp_plugin/frames.hpp
index cc9b43b404..88bd10f7e0 100644
--- a/ksp_plugin/frames.hpp
+++ b/ksp_plugin/frames.hpp
@@ -29,7 +29,7 @@ using World = Frame<serialization::Frame::PluginTag,
                     Handedness::Left,
                     serialization::Frame::WORLD>;
 
-// Same as |World| but with the y and z axes switched through the looking-glass:
+// Same as `World` but with the y and z axes switched through the looking-glass:
 // it is a right-handed basis. "We're all mad here. I'm mad. You're mad."
 using AliceWorld = Frame<serialization::Frame::PluginTag,
                          Arbitrary,
@@ -42,23 +42,23 @@ using Barycentric = Frame<serialization::Frame::PluginTag,
                           Handedness::Right,
                           serialization::Frame::BARYCENTRIC>;
 
-// The |Apparent...| frames are used for data obtained after the physics
+// The `Apparent...` frames are used for data obtained after the physics
 // simulation of the game has run, and before we perform our correction.
 
-// |World| coordinates from the game, but before the correction.
+// `World` coordinates from the game, but before the correction.
 using ApparentWorld = Frame<serialization::Frame::PluginTag,
                             Arbitrary,
                             Handedness::Left,
                             serialization::Frame::APPARENT_WORLD>;
 
-// The axes are those of |Barycentric|.  The origin is that of |ApparentWorld|,
+// The axes are those of `Barycentric`.  The origin is that of `ApparentWorld`,
 // and should not be depended upon.
 using Apparent = Frame<serialization::Frame::PluginTag,
                        NonRotating,
                        Handedness::Right,
                        serialization::Frame::APPARENT>;
 
-// |Barycentric|, with its y and z axes swapped.
+// `Barycentric`, with its y and z axes swapped.
 using CelestialSphere = Frame<serialization::Frame::PluginTag,
                               Inertial,
                               Handedness::Left,
@@ -87,21 +87,21 @@ using Navigation = Frame<serialization::Frame::PluginTag,
                          serialization::Frame::NAVIGATION>;
 
 // The plotting frame, but with the y and z axes swapped compared to
-// |Navigation|.  This frame defines the camera horizontal, and its angular
+// `Navigation`.  This frame defines the camera horizontal, and its angular
 // velocity defines the angular velocity of the camera (note that the linear
 // motion of the camera is defined in-game by following a specific target, which
-// may be in motion with respect to |CameraReference|, so the camera is not
+// may be in motion with respect to `CameraReference`, so the camera is not
 // necessarily at rest in that frame).
 using CameraReference = Frame<serialization::Frame::PluginTag,
                               Arbitrary,
                               Handedness::Left,
                               serialization::Frame::CAMERA_REFERENCE>;
 
-// |CameraReference|, rotated about its y axis by the angle of the planetarium
+// `CameraReference`, rotated about its y axis by the angle of the planetarium
 // rotation.  KSP compensates for the planetarium rotation so that the
 // orientation of the camera remains inertially fixed regardless of whether
 // World is rotating; we must undo this compensation in order for the camera to
-// be fixed in |CameraReference|.
+// be fixed in `CameraReference`.
 using CameraCompensatedReference =
     Frame<serialization::Frame::PluginTag,
           Arbitrary,
@@ -109,9 +109,9 @@ using CameraCompensatedReference =
           serialization::Frame::CAMERA_COMPENSATED_REFERENCE>;
 
 // A nonrotating referencence frame comoving with the sun with the same axes as
-// |AliceWorld|. Since it is nonrotating (though not inertial), differences
+// `AliceWorld`. Since it is nonrotating (though not inertial), differences
 // between velocities are consistent with those in an inertial reference frame.
-// When |AliceWorld| rotates the axes are not fixed in the reference frame, so
+// When `AliceWorld` rotates the axes are not fixed in the reference frame, so
 // this (frame, basis) pair is inconsistent across instants. Operations should
 // only be performed between simultaneous quantities, then converted to a
 // consistent (frame, basis) pair before use.
@@ -120,8 +120,8 @@ using AliceSun = Frame<serialization::Frame::PluginTag,
                        Handedness::Right,
                        serialization::Frame::ALICE_SUN>;
 
-// Same as above, but with same axes as |World| instead of those of
-// |AliceWorld|. The caveats are the same as for |AliceSun|.
+// Same as above, but with same axes as `World` instead of those of
+// `AliceWorld`. The caveats are the same as for `AliceSun`.
 using WorldSun = Frame<serialization::Frame::PluginTag,
                        NonRotating,
                        Handedness::Left,
@@ -141,8 +141,8 @@ using EccentricPart = Frame<serialization::Frame::PluginTag,
                             Handedness::Left,
                             serialization::Frame::ECCENTRIC_PART>;
 
-// The axes are those of |EccentricPart|.  The origin is the centre of mass of
-// the part, which may be offset from |EccentricPart::origin|.
+// The axes are those of `EccentricPart`.  The origin is the centre of mass of
+// the part, which may be offset from `EccentricPart::origin`.
 using RigidPart = Frame<serialization::Frame::PluginTag,
                         Arbitrary,
                         Handedness::Left,
@@ -154,12 +154,12 @@ using MainBodyCentred = Frame<serialization::Frame::PluginTag,
                               Handedness::Right,
                               serialization::Frame::MAIN_BODY_CENTRED>;
 
-// Convenient instances of types from |physics| for the above frames.
+// Convenient instances of types from `physics` for the above frames.
 using NavigationFrame = RigidReferenceFrame<Barycentric, Navigation>;
 using NavigationManœuvre = Manœuvre<Barycentric, Navigation>;
 using PlottingFrame = ReferenceFrame<Barycentric, Navigation>;
 
-// The map between the vector spaces of |WorldSun| and |AliceSun|.
+// The map between the vector spaces of `WorldSun` and `AliceSun`.
 Permutation<WorldSun, AliceSun> const sun_looking_glass(
     Permutation<WorldSun, AliceSun>::CoordinatePermutation::XZY);
 
diff --git a/ksp_plugin/geometric_potential_plotter.cpp b/ksp_plugin/geometric_potential_plotter.cpp
index 55603e6ccc..6f87802cb5 100644
--- a/ksp_plugin/geometric_potential_plotter.cpp
+++ b/ksp_plugin/geometric_potential_plotter.cpp
@@ -64,7 +64,7 @@ absl::Status GeometricPotentialPlotter::PlotEquipotentials(
                     .ComputeLines(parameters);
 
   absl::MutexLock l(&lock_);
-  // We don’t reset |next_equipotentials_| unless |result.ok()|, so that if we
+  // We don’t reset `next_equipotentials_` unless `result.ok()`, so that if we
   // have a transient error, we keep the old ones until the problem goes away.
   if (result.ok()) {
     next_equipotentials_ = {{}, parameters};
diff --git a/ksp_plugin/geometric_potential_plotter.hpp b/ksp_plugin/geometric_potential_plotter.hpp
index 22a8c71ac8..e79dd198f9 100644
--- a/ksp_plugin/geometric_potential_plotter.hpp
+++ b/ksp_plugin/geometric_potential_plotter.hpp
@@ -39,17 +39,17 @@ class GeometricPotentialPlotter {
       not_null<Ephemeris<Barycentric>*> ephemeris);
 
   // Cancel any computation in progress, causing the next call to
-  // |RequestEquipotentials| to be processed as fast as possible.
+  // `RequestEquipotentials` to be processed as fast as possible.
   void Interrupt();
 
   // Sets the parameters that will be used for the computation of the next
   // equipotentials.
   void RequestEquipotentials(Parameters const& parameters);
 
-  // The last value passed to |RequestEquipotentials|.
+  // The last value passed to `RequestEquipotentials`.
   std::optional<Parameters> const& last_parameters() const;
 
-  // Sets |equipotentials()| to the latest computed equipotentials.
+  // Sets `equipotentials()` to the latest computed equipotentials.
   void RefreshEquipotentials();
 
   Equipotentials const* equipotentials() const;
@@ -65,14 +65,14 @@ class GeometricPotentialPlotter {
   mutable absl::Mutex lock_;
   jthread plotter_;
 
-  // The |plotter_| is idle:
-  // — if it is not joinable, e.g. because it was stopped by |Interrupt()|, or
-  // — if it is done computing |next_equipotentials_| and has stopped or is
+  // The `plotter_` is idle:
+  // — if it is not joinable, e.g. because it was stopped by `Interrupt()`, or
+  // — if it is done computing `next_equipotentials_` and has stopped or is
   //   about to stop executing.
   // If it is joined once idle (and joinable), it will not attempt to acquire
-  // |lock_|.
+  // `lock_`.
   bool plotter_idle_ GUARDED_BY(lock_) = true;
-  // |next_analysis_| is set by the |analyser_| thread; it is read and cleared
+  // `next_analysis_` is set by the `analyser_` thread; it is read and cleared
   // by the main thread.
   std::optional<Equipotentials> next_equipotentials_ GUARDED_BY(lock_);
 };
diff --git a/ksp_plugin/identification.hpp b/ksp_plugin/identification.hpp
index a8589a6349..c846450362 100644
--- a/ksp_plugin/identification.hpp
+++ b/ksp_plugin/identification.hpp
@@ -18,12 +18,12 @@ namespace internal {
 
 using namespace principia::base::_not_null;
 
-// The GUID of a vessel, obtained by |v.id.ToString()| in C#. We use this as a
+// The GUID of a vessel, obtained by `v.id.ToString()` in C#. We use this as a
 // key in a map.
 using GUID = std::string;
 
-// Corresponds to KSP's |Part.flightID|, *not* to |Part.uid|.  C#'s |uint|
-// corresponds to |uint32_t|.
+// Corresponds to KSP's `Part.flightID`, *not* to `Part.uid`.  C#'s `uint`
+// corresponds to `uint32_t`.
 using PartId = std::uint32_t;
 
 // Comparator by PartId.  Useful for ensuring a consistent ordering in sets of
diff --git a/ksp_plugin/interface.cpp b/ksp_plugin/interface.cpp
index 3118ab3d83..22ab9aae88 100644
--- a/ksp_plugin/interface.cpp
+++ b/ksp_plugin/interface.cpp
@@ -153,7 +153,7 @@ Ephemeris<Barycentric>::AccuracyParameters MakeAccuracyParameters(
 
 Ephemeris<Barycentric>::AdaptiveStepParameters MakeAdaptiveStepParameters(
     ConfigurationAdaptiveStepParameters const& parameters) {
-  // It is erroneous for a psychohistory integration to fail, so the |max_steps|
+  // It is erroneous for a psychohistory integration to fail, so the `max_steps`
   // must be unlimited.
   return Ephemeris<Barycentric>::AdaptiveStepParameters(
       ParseAdaptiveStepSizeIntegrator<
@@ -318,10 +318,10 @@ void __cdecl principia__ActivatePlayer() {
   Vessel::MakeSynchronous();
 }
 
-// If |activate| is true and there is no active journal, create one and
-// activate it.  If |activate| is false and there is an active journal,
+// If `activate` is true and there is no active journal, create one and
+// activate it.  If `activate` is false and there is an active journal,
 // deactivate it.  Does nothing if there is already a journal in the desired
-// state.  |verbose| causes methods to be output in the INFO log before being
+// state.  `verbose` causes methods to be output in the INFO log before being
 // executed.
 void __cdecl principia__ActivateRecorder(bool const activate) {
   // NOTE: Do not journal!  You'd end up with half a message in the journal and
@@ -406,8 +406,8 @@ void __cdecl principia__CatchUpLaggingVessels(
   return m.Return();
 }
 
-// Calls |plugin->CelestialFromParent| with the arguments given.
-// |plugin| must not be null.  No transfer of ownership.
+// Calls `plugin->CelestialFromParent` with the arguments given.
+// `plugin` must not be null.  No transfer of ownership.
 QP __cdecl principia__CelestialFromParent(Plugin const* const plugin,
                                           int const celestial_index) {
   journal::Method<journal::CelestialFromParent> m({plugin, celestial_index});
@@ -496,9 +496,9 @@ void __cdecl principia__DeleteInterchange(void const** const native_pointer) {
   return m.Return();
 }
 
-// Deletes and nulls |*plugin|.
-// |plugin| must not be null.  No transfer of ownership of |*plugin|, takes
-// ownership of |**plugin|.
+// Deletes and nulls `*plugin`.
+// `plugin` must not be null.  No transfer of ownership of `*plugin`, takes
+// ownership of `**plugin`.
 void __cdecl principia__DeletePlugin(Plugin const** const plugin) {
   CHECK_NOTNULL(plugin);
   journal::Method<journal::DeletePlugin> m({plugin}, {plugin});
@@ -512,9 +512,9 @@ void __cdecl principia__DeletePlugin(Plugin const** const plugin) {
   return m.Return();
 }
 
-// Deletes and nulls |*native_string|.  |native_string| must not be null.  No
-// transfer of ownership of |*native_string|, takes ownership of
-// |**native_string|.
+// Deletes and nulls `*native_string`.  `native_string` must not be null.  No
+// transfer of ownership of `*native_string`, takes ownership of
+// `**native_string`.
 void __cdecl principia__DeleteString(char const** const native_string) {
   journal::Method<journal::DeleteString> m({native_string}, {native_string});
   TakeOwnershipArray(native_string);
@@ -529,12 +529,12 @@ void __cdecl principia__DeleteU16String(char16_t const** const native_string) {
   return m.Return();
 }
 
-// The caller takes ownership of |**plugin| when it is not null.  No transfer of
-// ownership of |*serialization| or |**deserializer|.  |*deserializer| and
-// |*plugin| must be null on the first call and must be passed unchanged to the
+// The caller takes ownership of `**plugin` when it is not null.  No transfer of
+// ownership of `*serialization` or `**deserializer`.  `*deserializer` and
+// `*plugin` must be null on the first call and must be passed unchanged to the
 // successive calls.  The caller must perform an extra call with
-// |serialization_size| set to 0 to indicate the end of the input stream.  When
-// this last call returns, |*plugin| is not null and may be used by the caller.
+// `serialization_size` set to 0 to indicate the end of the input stream.  When
+// this last call returns, `*plugin` is not null and may be used by the caller.
 void __cdecl principia__DeserializePlugin(
     char const* const serialization,
     PushDeserializer** const deserializer,
@@ -576,7 +576,7 @@ void __cdecl principia__DeserializePlugin(
   (*deserializer)->Push(std::move(bytes));
 
   // If the data was empty, delete the deserializer.  This ensures that
-  // |*plugin| is filled.
+  // `*plugin` is filled.
   if (bytes_size == 0) {
     LOG(INFO) << "End plugin deserialization";
     TakeOwnership(deserializer);
@@ -585,8 +585,8 @@ void __cdecl principia__DeserializePlugin(
   return m.Return();
 }
 
-// Calls |plugin->EndInitialization|.
-// |plugin| must not be null.  No transfer of ownership.
+// Calls `plugin->EndInitialization`.
+// `plugin` must not be null.  No transfer of ownership.
 void __cdecl principia__EndInitialization(Plugin* const plugin) {
   journal::Method<journal::EndInitialization> m({plugin});
   CHECK_NOTNULL(plugin);
@@ -876,8 +876,8 @@ void __cdecl principia__InsertCelestialJacobiKeplerian(
   return m.Return();
 }
 
-// Calls |plugin->InsertOrKeepVessel| with the arguments given.
-// |plugin| must not be null.  No transfer of ownership.
+// Calls `plugin->InsertOrKeepVessel` with the arguments given.
+// `plugin` must not be null.  No transfer of ownership.
 void __cdecl principia__InsertOrKeepVessel(Plugin* const plugin,
                                            char const* const vessel_guid,
                                            char const* const vessel_name,
@@ -977,8 +977,8 @@ void __cdecl principia__InsertOrKeepLoadedPart(
   return m.Return();
 }
 
-// Calls |plugin->SetVesselStateOffset| with the arguments given.
-// |plugin| must not be null.  No transfer of ownership.
+// Calls `plugin->SetVesselStateOffset` with the arguments given.
+// `plugin` must not be null.  No transfer of ownership.
 void __cdecl principia__InsertUnloadedPart(Plugin* const plugin,
                                            PartId const part_id,
                                            char const* const name,
@@ -995,7 +995,7 @@ void __cdecl principia__InsertUnloadedPart(Plugin* const plugin,
   return m.Return();
 }
 
-// Exports |LOG(SEVERITY) << text| for fast logging from the C# adapter.
+// Exports `LOG(SEVERITY) << text` for fast logging from the C# adapter.
 // This will always evaluate its argument even if the corresponding log severity
 // is disabled, so it is less efficient than LOG(SEVERITY).
 void __cdecl principia__LogError(char const* const file,
@@ -1104,9 +1104,9 @@ static PushDeserializer* verification_deserializer = nullptr;
 static Plugin const* verification_plugin = nullptr;
 #endif
 
-// |plugin| must not be null.  The caller takes ownership of the result, except
+// `plugin` must not be null.  The caller takes ownership of the result, except
 // when it is null (at the end of the stream).  No transfer of ownership of
-// |*plugin|.  |*serializer| must be null on the first call and must be passed
+// `*plugin`.  `*serializer` must be null on the first call and must be passed
 // unchanged to the successive calls; its ownership is not transferred.
 char const* __cdecl principia__SerializePlugin(
     Plugin const* const plugin,
@@ -1177,7 +1177,7 @@ void __cdecl principia__SetBufferDuration(int const seconds) {
   return m.Return();
 }
 
-// Log messages at a level |<= max_severity| are buffered.
+// Log messages at a level `<= max_severity` are buffered.
 // Log messages at a higher level are flushed immediately.
 void __cdecl principia__SetBufferedLogging(int const max_severity) {
   journal::Method<journal::SetBufferedLogging> m({max_severity});
@@ -1199,11 +1199,11 @@ void __cdecl principia__SetMainBody(Plugin* const plugin, int const index) {
   return m.Return();
 }
 
-// Make it so that all log messages of at least |min_severity| are logged to
+// Make it so that all log messages of at least `min_severity` are logged to
 // stderr (in addition to logging to the usual log file(s)).
 void __cdecl principia__SetStderrLogging(int const min_severity) {
   journal::Method<journal::SetStderrLogging> m({min_severity});
-  // NOTE(egg): We could use |FLAGS_stderrthreshold| instead, the difference
+  // NOTE(egg): We could use `FLAGS_stderrthreshold` instead, the difference
   // seems to be a mutex.
   google::SetStderrLogging(min_severity);
   return m.Return();
@@ -1217,7 +1217,7 @@ void __cdecl principia__SetSuppressedLogging(int const min_severity) {
   return m.Return();
 }
 
-// Show all VLOG(m) messages for |m <= level|.
+// Show all VLOG(m) messages for `m <= level`.
 void __cdecl principia__SetVerboseLogging(int const level) {
   journal::Method<journal::SetVerboseLogging> m({level});
   FLAGS_v = level;
@@ -1240,8 +1240,8 @@ XYZ __cdecl principia__UnmanageableVesselVelocity(Plugin const* const plugin,
       parent_index));
 }
 
-// Calls |plugin->UpdateCelestialHierarchy| with the arguments given.
-// |plugin| must not be null.  No transfer of ownership.
+// Calls `plugin->UpdateCelestialHierarchy` with the arguments given.
+// `plugin` must not be null.  No transfer of ownership.
 void __cdecl principia__UpdateCelestialHierarchy(Plugin const* const plugin,
                                                  int const celestial_index,
                                                  int const parent_index) {
diff --git a/ksp_plugin/interface.hpp b/ksp_plugin/interface.hpp
index 5d3c84ee34..d4d9c9a577 100644
--- a/ksp_plugin/interface.hpp
+++ b/ksp_plugin/interface.hpp
@@ -39,8 +39,8 @@ namespace principia {
 namespace interface {
 
 // This is used for interfacing, and should only appear in C++ code in tests
-// and generated code; we allow ourselves to pollute the |interface| namespace
-// with convenience |using|s.
+// and generated code; we allow ourselves to pollute the `interface` namespace
+// with convenience `using`s.
 
 using namespace principia::base::_not_null;
 using namespace principia::base::_pull_serializer;
@@ -70,9 +70,9 @@ using namespace principia::physics::_rigid_reference_frame;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// Takes ownership of |**pointer| and returns it to the caller.  Nulls
-// |*pointer|.  |pointer| must not be null.  No transfer of ownership of
-// |*pointer|.
+// Takes ownership of `**pointer` and returns it to the caller.  Nulls
+// `*pointer`.  `pointer` must not be null.  No transfer of ownership of
+// `*pointer`.
 template<typename T>
 std::unique_ptr<T> TakeOwnership(T** pointer);
 template<typename T>
diff --git a/ksp_plugin/interface_body.hpp b/ksp_plugin/interface_body.hpp
index 4a00bacea4..6cfc9a17bc 100644
--- a/ksp_plugin/interface_body.hpp
+++ b/ksp_plugin/interface_body.hpp
@@ -662,7 +662,7 @@ inline RigidMotion<EccentricPart, World> MakePartRigidMotion(
   return part_rigid_motion;
 }
 
-// Same as |MakePartRigidMotion|, but uses the separate type |ApparentWorld| to
+// Same as `MakePartRigidMotion`, but uses the separate type `ApparentWorld` to
 // avoid mixing uncorrected and corrected data.
 inline RigidMotion<EccentricPart, ApparentWorld> MakePartApparentRigidMotion(
     QP const& part_world_degrees_of_freedom,
diff --git a/ksp_plugin/interface_external.cpp b/ksp_plugin/interface_external.cpp
index 5e0ad91665..3dafab6bc1 100644
--- a/ksp_plugin/interface_external.cpp
+++ b/ksp_plugin/interface_external.cpp
@@ -299,12 +299,12 @@ Status* __cdecl principia__ExternalGetNearestPlannedCoastDegreesOfFreedom(
   }
 
   Instant const current_time = plugin->CurrentTime();
-  // The given |World| position and requested |World| degrees of freedom are
-  // body-centred inertial, so |body_centred_inertial| up to an orthogonal map
+  // The given `World` position and requested `World` degrees of freedom are
+  // body-centred inertial, so `body_centred_inertial` up to an orthogonal map
   // to world coordinates.  Do the conversion directly.
-  // NOTE(egg): it is correct to use the orthogonal map at |current_time|,
-  // because |body_centred_inertial| does not rotate with respect to
-  // |Barycentric|, so the orthogonal map does not depend on time.
+  // NOTE(egg): it is correct to use the orthogonal map at `current_time`,
+  // because `body_centred_inertial` does not rotate with respect to
+  // `Barycentric`, so the orthogonal map does not depend on time.
   RigidMotion<Navigation, World> to_world_body_centred_inertial(
       RigidTransformation<Navigation, World>(
           Navigation::origin,
diff --git a/ksp_plugin/interface_planetarium.cpp b/ksp_plugin/interface_planetarium.cpp
index c6e7802872..1ab5a06ac2 100644
--- a/ksp_plugin/interface_planetarium.cpp
+++ b/ksp_plugin/interface_planetarium.cpp
@@ -121,7 +121,7 @@ void __cdecl principia__PlanetariumDelete(
   return m.Return();
 }
 
-// Fills the array of size |vertices_size| at |vertices| with vertices for the
+// Fills the array of size `vertices_size` at `vertices` with vertices for the
 // rendering of the segment with the given index in the flight plan of the
 // vessel with the given GUID.
 void __cdecl principia__PlanetariumPlotFlightPlanSegment(
@@ -165,7 +165,7 @@ void __cdecl principia__PlanetariumPlotFlightPlanSegment(
   return m.Return();
 }
 
-// Fills the array of size |vertices_size| at |vertices| with vertices for the
+// Fills the array of size `vertices_size` at `vertices` with vertices for the
 // rendered prediction of the vessel with the given GUID.
 void __cdecl principia__PlanetariumPlotPrediction(
     Planetarium const* const planetarium,
@@ -197,10 +197,10 @@ void __cdecl principia__PlanetariumPlotPrediction(
   return m.Return();
 }
 
-// Fills the array of size |vertices_size| at |vertices| with vertices for the
+// Fills the array of size `vertices_size` at `vertices` with vertices for the
 // rendered past trajectory of the vessel with the given GUID; the
-// trajectory goes back |max_history_length| seconds before the present time (or
-// to the earliest time available if the relevant |t_min| is more recent).
+// trajectory goes back `max_history_length` seconds before the present time (or
+// to the earliest time available if the relevant `t_min` is more recent).
 void __cdecl principia__PlanetariumPlotPsychohistory(
     Planetarium const* const planetarium,
     Plugin const* const plugin,
@@ -235,7 +235,7 @@ void __cdecl principia__PlanetariumPlotPsychohistory(
     Instant const desired_first_time =
         plugin->CurrentTime() - max_history_length * Second;
 
-    // Since we would want to plot starting from |desired_first_time|, ask the
+    // Since we would want to plot starting from `desired_first_time`, ask the
     // reanimator to reconstruct the past.  That may take a while, during which
     // time the history will be shorter than desired.
     vessel->RequestReanimation(desired_first_time);
@@ -255,10 +255,10 @@ void __cdecl principia__PlanetariumPlotPsychohistory(
   }
 }
 
-// Fills the array of size |vertices_size| at |vertices| with vertices for the
+// Fills the array of size `vertices_size` at `vertices` with vertices for the
 // rendered past trajectory of the celestial with the given index; the
-// trajectory goes back |max_history_length| seconds before the present time (or
-// to the earliest time available if the relevant |t_min| is more recent).
+// trajectory goes back `max_history_length` seconds before the present time (or
+// to the earliest time available if the relevant `t_min` is more recent).
 void __cdecl principia__PlanetariumPlotCelestialPastTrajectory(
     Planetarium const* const planetarium,
     Plugin const* const plugin,
@@ -290,7 +290,7 @@ void __cdecl principia__PlanetariumPlotCelestialPastTrajectory(
     Instant const desired_first_time =
         plugin->CurrentTime() - max_history_length * Second;
 
-    // Since we would want to plot starting from |desired_first_time|, ask the
+    // Since we would want to plot starting from `desired_first_time`, ask the
     // reanimator to reconstruct the past.  That may take a while, during which
     // time the history will be shorter than desired.
     plugin->RequestReanimation(desired_first_time);
@@ -314,7 +314,7 @@ void __cdecl principia__PlanetariumPlotCelestialPastTrajectory(
   }
 }
 
-// Fills the array of size |vertices_size| at |vertices| with vertices for the
+// Fills the array of size `vertices_size` at `vertices` with vertices for the
 // rendered future trajectory of the celestial with the given index; the
 // trajectory goes as far as the furthest of the final time of the prediction or
 // that of the flight plan.
@@ -373,7 +373,7 @@ void __cdecl principia__PlanetariumPlotCelestialFutureTrajectory(
   }
 }
 
-// Fills the array of size |vertices_size| at |vertices| with vertices for the
+// Fills the array of size `vertices_size` at `vertices` with vertices for the
 // rendered prediction of the vessel with the given GUID.
 void __cdecl principia__PlanetariumPlotEquipotential(
     Planetarium const* const planetarium,
diff --git a/ksp_plugin/interface_renderer.cpp b/ksp_plugin/interface_renderer.cpp
index ebae852aa9..d1b081ff9a 100644
--- a/ksp_plugin/interface_renderer.cpp
+++ b/ksp_plugin/interface_renderer.cpp
@@ -127,7 +127,7 @@ void __cdecl principia__RenderedPredictionNodes(Plugin const* const plugin,
   return m.Return();
 }
 
-// Calls |plugin| to create a |NavigationFrame| using the given |parameters|,
+// Calls `plugin` to create a `NavigationFrame` using the given `parameters`,
 // sets it as the current plotting frame.
 void __cdecl principia__SetPlottingFrame(
     Plugin* const plugin,
diff --git a/ksp_plugin/interface_vessel.cpp b/ksp_plugin/interface_vessel.cpp
index bc1e6227fe..8334c1c4ec 100644
--- a/ksp_plugin/interface_vessel.cpp
+++ b/ksp_plugin/interface_vessel.cpp
@@ -34,8 +34,8 @@ XYZ __cdecl principia__VesselBinormal(Plugin const* const plugin,
   return m.Return(ToXYZ(plugin->VesselBinormal(vessel_guid)));
 }
 
-// Calls |plugin->VesselFromParent| with the arguments given.
-// |plugin| must not be null.  No transfer of ownership.
+// Calls `plugin->VesselFromParent` with the arguments given.
+// `plugin` must not be null.  No transfer of ownership.
 QP __cdecl principia__VesselFromParent(Plugin const* const plugin,
                                        int const parent_index,
                                        char const* const vessel_guid) {
diff --git a/ksp_plugin/iterators.hpp b/ksp_plugin/iterators.hpp
index f9ed41c3a9..a31f506eb4 100644
--- a/ksp_plugin/iterators.hpp
+++ b/ksp_plugin/iterators.hpp
@@ -26,7 +26,7 @@ class Iterator {
   virtual int Size() const = 0;
 };
 
-// A concrete, typed subclass of |Iterator| which holds a |Container|.
+// A concrete, typed subclass of `Iterator` which holds a `Container`.
 template<typename Container>
 class TypedIterator : public Iterator {
  public:
@@ -35,7 +35,7 @@ class TypedIterator : public Iterator {
                 Plugin const* plugin);
 
   // Obtains the element denoted by this iterator and converts it to some
-  // |Interchange| type using |convert|.
+  // `Interchange` type using `convert`.
   template<typename Interchange>
   Interchange Get(
       std::function<Interchange(typename Container::value_type const&)> const&
@@ -54,7 +54,7 @@ class TypedIterator : public Iterator {
   Plugin const* plugin_;
 };
 
-// A specialization for |DiscreteTrajectory<World>|.
+// A specialization for `DiscreteTrajectory<World>`.
 template<>
 class TypedIterator<DiscreteTrajectory<World>> : public Iterator {
  public:
@@ -62,7 +62,7 @@ class TypedIterator<DiscreteTrajectory<World>> : public Iterator {
                 not_null<Plugin const*> plugin);
 
   // Obtains the element denoted by this iterator and converts it to some
-  // |Interchange| type using |convert|.
+  // `Interchange` type using `convert`.
   template<typename Interchange>
   Interchange Get(
       std::function<Interchange(
diff --git "a/ksp_plugin/man\305\223uvre.hpp" "b/ksp_plugin/man\305\223uvre.hpp"
index ccd24f284b..000eaebbca 100644
--- "a/ksp_plugin/man\305\223uvre.hpp"
+++ "b/ksp_plugin/man\305\223uvre.hpp"
@@ -35,14 +35,14 @@ using namespace principia::physics::_rigid_reference_frame;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// This class represents a constant-thrust burn.  |InertialFrame| is an
-// underlying inertial reference frame, |Frame| is the reference frame used to
+// This class represents a constant-thrust burn.  `InertialFrame` is an
+// underlying inertial reference frame, `Frame` is the reference frame used to
 // compute the Frenet frame.
 template<typename InertialFrame, typename Frame>
 class Manœuvre {
  public:
   // Characterization of intensity.  All members for exactly one of the groups
-  // must be supplied.  The |direction| and |Δv| are given in the Frenet frame
+  // must be supplied.  The `direction` and `Δv` are given in the Frenet frame
   // of the trajectory at the beginning of the burn.
   struct Intensity final {
     // Group 1.
@@ -130,15 +130,15 @@ class Manœuvre {
   void clear_coasting_trajectory();
 
   // Sets the trajectory segment at the end of which the manœuvre takes place.
-  // Must be called before any of the functions below.  |trajectory| must have a
-  // point at |initial_time()|.
+  // Must be called before any of the functions below.  `trajectory` must have a
+  // point at `initial_time()`.
   void set_coasting_trajectory(
       DiscreteTrajectorySegmentIterator<InertialFrame> trajectory);
 
   // This manœuvre must be inertially fixed.
   virtual Vector<double, InertialFrame> InertialDirection() const;
 
-  // The result is valid until |*this| is destroyed.  This manœuvre must be
+  // The result is valid until `*this` is destroyed.  This manœuvre must be
   // inertially fixed.
   typename Ephemeris<InertialFrame>::IntrinsicAcceleration
   InertialIntrinsicAcceleration() const;
@@ -150,22 +150,22 @@ class Manœuvre {
   // Frenet frame at the beginning of the manœuvre.
   virtual OrthogonalMap<Frenet<Frame>, InertialFrame> FrenetFrame() const;
 
-  // Note that |coasting_trajectory| is neither written nor read.
+  // Note that `coasting_trajectory` is neither written nor read.
   void WriteToMessage(not_null<serialization::Manoeuvre*> message) const;
   static Manœuvre ReadFromMessage(
       serialization::Manoeuvre const& message,
       not_null<Ephemeris<InertialFrame>*> ephemeris);
 
  private:
-  // Computes the Frenet frame at instant |t|, assuming that the motion has the
-  // given |position| and |velocity|.
+  // Computes the Frenet frame at instant `t`, assuming that the motion has the
+  // given `position` and `velocity`.
   OrthogonalMap<Frenet<Frame>, InertialFrame>
   ComputeFrenetFrame(
       Instant const& t,
       DegreesOfFreedom<InertialFrame> const& degrees_of_freedom) const;
 
-  // Computes the acceleration at instant |t|, assuming that it happens in the
-  // given |direction|.
+  // Computes the acceleration at instant `t`, assuming that it happens in the
+  // given `direction`.
   Vector<Acceleration, InertialFrame>
   ComputeIntrinsicAcceleration(
       Instant const& t,
diff --git "a/ksp_plugin/man\305\223uvre_body.hpp" "b/ksp_plugin/man\305\223uvre_body.hpp"
index cd28ebae7a..6166fc7cf0 100644
--- "a/ksp_plugin/man\305\223uvre_body.hpp"
+++ "b/ksp_plugin/man\305\223uvre_body.hpp"
@@ -23,14 +23,14 @@ Manœuvre<InertialFrame, Frame>::Manœuvre(Mass const& initial_mass,
   : initial_mass_(initial_mass),
     construction_burn_(burn),
     burn_(burn) {
-  // Fill the missing fields of |intensity|.
+  // Fill the missing fields of `intensity`.
   auto& intensity = burn_.intensity;
   if (intensity.Δv) {
     CHECK(!intensity.direction && !intensity.duration);
     intensity.direction = NormalizeOrZero(*intensity.Δv);
     auto const speed = intensity.Δv->Norm();
     if (speed == Speed()) {
-      // This handles the case where |thrust_| vanishes, where the usual formula
+      // This handles the case where `thrust_` vanishes, where the usual formula
       // would yield NaN.
       intensity.duration = Time();
     } else {
@@ -45,7 +45,7 @@ Manœuvre<InertialFrame, Frame>::Manœuvre(Mass const& initial_mass,
                    std::log(initial_mass_ / final_mass());
   }
 
-  // Fill the missing fields of |timing|.
+  // Fill the missing fields of `timing`.
   auto& timing = burn_.timing;
   if (timing.initial_time) {
     CHECK(!timing.time_of_half_Δv);
diff --git a/ksp_plugin/orbit_analyser.cpp b/ksp_plugin/orbit_analyser.cpp
index 93e21dd3c6..909eedee2f 100644
--- a/ksp_plugin/orbit_analyser.cpp
+++ b/ksp_plugin/orbit_analyser.cpp
@@ -122,7 +122,7 @@ absl::Status OrbitAnalyser::AnalyseOrbit(Parameters const& parameters) {
         FlowWithProgressBar(parameters, analysis_duration, trajectory));
     analysis.mission_duration_ = trajectory.back().time - parameters.first_time;
 
-    // TODO(egg): |next_analysis_percentage_| only reflects the progress of
+    // TODO(egg): `next_analysis_percentage_` only reflects the progress of
     // the integration, but the analysis itself can take a while; this results
     // in the progress bar being stuck at 100% while the elements and nodes
     // are being computed.
diff --git a/ksp_plugin/orbit_analyser.hpp b/ksp_plugin/orbit_analyser.hpp
index b28119e682..93cce10789 100644
--- a/ksp_plugin/orbit_analyser.hpp
+++ b/ksp_plugin/orbit_analyser.hpp
@@ -43,18 +43,18 @@ using namespace principia::physics::_ephemeris;
 using namespace principia::physics::_rotating_body;
 using namespace principia::quantities::_quantities;
 
-// The |OrbitAnalyser| asynchronously integrates a trajectory, and computes
+// The `OrbitAnalyser` asynchronously integrates a trajectory, and computes
 // orbital elements, recurrence, and ground track properties of the resulting
 // orbit.
 class OrbitAnalyser {
  public:
   // The analysis stores the computed orbital characteristics.  It is publicly
-  // mutable via |SetRecurrence| and |ResetRecurrence| to allow the caller to
+  // mutable via `SetRecurrence` and `ResetRecurrence` to allow the caller to
   // consider a nominal recurrence other than the one deduced from the orbital
   // elements: analysing the precomputed ground track with respect to a
   // different recurrence is relatively cheap, so it is inconvenient to wait for
   // a whole new analysis to do so, but doing it at every frame is still
-  // wasteful, so we cache that in the |Analysis|.
+  // wasteful, so we cache that in the `Analysis`.
   class Analysis {
    public:
     Instant const& first_time() const;
@@ -64,20 +64,20 @@ class OrbitAnalyser {
     std::optional<OrbitalElements> const& elements() const;
     std::optional<OrbitRecurrence> const& recurrence() const;
     std::optional<OrbitGroundTrack> const& ground_track() const;
-    // |equatorial_crossings().has_value()| if and only if
-    // |recurrence().has_value && ground_track().has_value()|;
-    // |*equatorial_crossings()| is
+    // `equatorial_crossings().has_value()` if and only if
+    // `recurrence().has_value && ground_track().has_value()`;
+    // `*equatorial_crossings()` is
     //   ground_track()->equator_crossing_longitudes(
     //       *recurrence(), /*first_ascending_pass_index=*/1)
     // precomputed to avoid performing this calculation at every frame.
     std::optional<OrbitGroundTrack::EquatorCrossingLongitudes> const&
     equatorial_crossings() const;
 
-    // Sets |recurrence|, updating |equatorial_crossings| if needed.
+    // Sets `recurrence`, updating `equatorial_crossings` if needed.
     void SetRecurrence(OrbitRecurrence const& recurrence);
-    // Resets |recurrence| to a value deduced from |*elements| by
-    // |OrbitRecurrence::ClosestRecurrence|, or to nullopt if
-    // |!elements.has_value()|, updating |equatorial_crossings| if needed.
+    // Resets `recurrence` to a value deduced from `*elements` by
+    // `OrbitRecurrence::ClosestRecurrence`, or to nullopt if
+    // `!elements.has_value()`, updating `equatorial_crossings` if needed.
     void ResetRecurrence();
 
    private:
@@ -101,7 +101,7 @@ class OrbitAnalyser {
     Instant first_time;
     DegreesOfFreedom<Barycentric> first_degrees_of_freedom;
     Time mission_duration;
-    // The analyser may compute the trajectory up to |extended_mission_duration|
+    // The analyser may compute the trajectory up to `extended_mission_duration`
     // to ensure that at least one revolution is analysed.
     std::optional<Time> extended_mission_duration;
   };
@@ -113,20 +113,20 @@ class OrbitAnalyser {
   virtual ~OrbitAnalyser();
 
   // Cancels any computation in progress, causing the next call to
-  // |RequestAnalysis| to be processed as fast as possible.
+  // `RequestAnalysis` to be processed as fast as possible.
   void Interrupt();
 
   // Sets the parameters that will be used for the computation of the next
   // analysis.
   void RequestAnalysis(Parameters const& parameters);
 
-  // The last value passed to |RequestAnalysis|.
+  // The last value passed to `RequestAnalysis`.
   std::optional<Parameters> const& last_parameters() const;
 
-  // Sets |analysis()| to the latest computed analysis.
+  // Sets `analysis()` to the latest computed analysis.
   void RefreshAnalysis();
 
-  // Mutable so that the caller can call |SetRecurrence| and |ResetRecurrence|.
+  // Mutable so that the caller can call `SetRecurrence` and `ResetRecurrence`.
   Analysis* analysis();
 
   // The result is in [0, 1]; it tracks the progress of the computation of the
@@ -147,9 +147,9 @@ class OrbitAnalyser {
       RotatingBody<Barycentric> const*& primary,
       Time& smallest_osculating_period);
 
-  // Flows the |trajectory| with a fixed step integrator using the given
-  // |parameters|.  This is done in small increments and
-  // |progress_of_next_analysis_| is updated after each increment to be able to
+  // Flows the `trajectory` with a fixed step integrator using the given
+  // `parameters`.  This is done in small increments and
+  // `progress_of_next_analysis_` is updated after each increment to be able to
   // display a progress bar.  This function may be stopped.
   absl::Status FlowWithProgressBar(
       Parameters const& parameters,
@@ -158,14 +158,14 @@ class OrbitAnalyser {
 
   // If we can find a sun, computes its mean motion around the primary if it
   // doesn't require too long an integration.  If there is no sun, or the
-  // integration would take too long, |mean_sun| is set to |std::nullopt|.
+  // integration would take too long, `mean_sun` is set to `std::nullopt`.
   absl::Status ComputeMeanSunIfPossible(
       Parameters const& parameters,
       BodyCentredNonRotatingReferenceFrame<Barycentric, PrimaryCentred> const&
           primary_centred,
       std::optional<OrbitGroundTrack::MeanSun>& mean_sun);
 
-  // Converts the |trajectory| to the given |primary_centred| frame.  This
+  // Converts the `trajectory` to the given `primary_centred` frame.  This
   // function may be stopped.
   static absl::StatusOr<DiscreteTrajectory<PrimaryCentred>> ToPrimaryCentred(
       BodyCentredNonRotatingReferenceFrame<Barycentric, PrimaryCentred> const&
@@ -182,18 +182,18 @@ class OrbitAnalyser {
 
   mutable absl::Mutex lock_;
   jthread analyser_;
-  // The |analyser_| is idle:
-  // — if it is not joinable, e.g. because it was stopped by |Interrupt()|, or
-  // — if it is done computing |next_analysis_| and has stopped or is about to
+  // The `analyser_` is idle:
+  // — if it is not joinable, e.g. because it was stopped by `Interrupt()`, or
+  // — if it is done computing `next_analysis_` and has stopped or is about to
   //   stop executing.
   // If it is joined once idle (and joinable), it will not attempt to acquire
-  // |lock_|.
+  // `lock_`.
   bool analyser_idle_ GUARDED_BY(lock_) = true;
-  // |next_analysis_| is set by the |analyser_| thread; it is read and cleared
+  // `next_analysis_` is set by the `analyser_` thread; it is read and cleared
   // by the main thread.
   std::optional<Analysis> next_analysis_ GUARDED_BY(lock_);
-  // |progress_of_next_analysis_| is set by the |analyser_| thread; it tracks
-  // progress in computing |next_analysis_|.
+  // `progress_of_next_analysis_` is set by the `analyser_` thread; it tracks
+  // progress in computing `next_analysis_`.
   std::atomic<double> progress_of_next_analysis_ = 0;
 };
 
diff --git a/ksp_plugin/part.cpp b/ksp_plugin/part.cpp
index 20fb143fb3..932c7c5464 100644
--- a/ksp_plugin/part.cpp
+++ b/ksp_plugin/part.cpp
@@ -317,8 +317,8 @@ not_null<std::unique_ptr<Part>> Part::ReadFromMessage(
     auto tail = DiscreteTrajectory<Barycentric>::ReadFromMessage(
         message.prehistory(),
         /*tracked=*/{});
-    // The |history_| has been created by the constructor above.  Construct the
-    // various trajectories from the |tail|.
+    // The `history_` has been created by the constructor above.  Construct the
+    // various trajectories from the `tail`.
     for (auto it = tail.begin(); it != tail.end();) {
       auto const& [time, degrees_of_freedom] = *it;
       ++it;
diff --git a/ksp_plugin/part.hpp b/ksp_plugin/part.hpp
index 39f84ebecc..e9a274ad37 100644
--- a/ksp_plugin/part.hpp
+++ b/ksp_plugin/part.hpp
@@ -82,7 +82,7 @@ class Part final {
   Mass const& mass() const;
   void set_centre_of_mass(Position<EccentricPart> const& centre_of_mass);
   // Returns the transformation from the part-centre-of-mass-centred to the
-  // part-position-centred frame; the offset is set by |set_centre_of_mass|.
+  // part-position-centred frame; the offset is set by `set_centre_of_mass`.
   RigidMotion<RigidPart, EccentricPart> MakeRigidToEccentricMotion() const;
   void set_inertia_tensor(InertiaTensor<RigidPart> const& inertia_tensor);
   InertiaTensor<RigidPart> const& inertia_tensor() const;
@@ -91,7 +91,7 @@ class Part final {
   void set_is_solid_rocket_motor(bool is_solid_rocket_motor);
   bool is_solid_rocket_motor() const;
 
-  // The difference between successive values passed to |set_mass()|.
+  // The difference between successive values passed to `set_mass()`.
   Mass const& mass_change() const;
 
   // Clears, increments or returns the intrinsic force exerted on the part by
@@ -125,9 +125,9 @@ class Part final {
 
   // Appends a point to the history or psychohistory of this part.  These
   // temporarily hold the trajectory of the part and are constructed by
-  // |PileUp::AdvanceTime|.  They are consumed by |Vessel::AdvanceTime| for the
-  // containing |Vessel|.
-  // Note that |AppendToHistory| clears the psychohistory so the order of the
+  // `PileUp::AdvanceTime`.  They are consumed by `Vessel::AdvanceTime` for the
+  // containing `Vessel`.
+  // Note that `AppendToHistory` clears the psychohistory so the order of the
   // calls matter.
   void AppendToHistory(
       Instant const& time,
@@ -139,14 +139,14 @@ class Part final {
   // Clears the history and psychohistory.
   void ClearHistory();
 
-  // Requires |!is_piled_up()|.  The part assumes co-ownership of the |pile_up|.
+  // Requires `!is_piled_up()`.  The part assumes co-ownership of the `pile_up`.
   void set_containing_pile_up(not_null<std::shared_ptr<PileUp>> const& pile_up);
 
   // A pointer to the containing pile up, if any.
   PileUp* containing_pile_up() const;
 
-  // Whether this part is in a |PileUp|, i.e., has a non-null
-  // |containing_pile_up|.
+  // Whether this part is in a `PileUp`, i.e., has a non-null
+  // `containing_pile_up`.
   bool is_piled_up() const;
 
   // Remove this part from its pile-up, if any.  This may cause the pile-up to
@@ -184,9 +184,9 @@ class Part final {
   bool truthful_;
   Mass mass_;
   Position<EccentricPart> centre_of_mass_ = EccentricPart::origin;
-  // NOTE(eggrobin): |mass_change_| and |is_solid_rocket_motor_| are set by
-  // |InsertOrKeepLoadedPart|, and used by |PileUp::RecomputeFromParts|.
-  // Ultimately, both are called in the adapter in |WaitedForFixedUpdate|.
+  // NOTE(eggrobin): `mass_change_` and `is_solid_rocket_motor_` are set by
+  // `InsertOrKeepLoadedPart`, and used by `PileUp::RecomputeFromParts`.
+  // Ultimately, both are called in the adapter in `WaitedForFixedUpdate`.
   // They therefore do not need to be serialized.
   Mass mass_change_;
   bool is_solid_rocket_motor_ = false;
@@ -204,15 +204,15 @@ class Part final {
   // history and the psychohistory.
   DiscreteTrajectory<Barycentric> trajectory_;
 
-  // The |history_| is nearly always present, except in some transient
+  // The `history_` is nearly always present, except in some transient
   // situations.
   DiscreteTrajectorySegmentIterator<Barycentric> history_;
 
-  // The |psychohistory_| is destroyed by |AppendToHistory| and is recreated
-  // as needed by |AppendToPsychohistory|.
+  // The `psychohistory_` is destroyed by `AppendToHistory` and is recreated
+  // as needed by `AppendToPsychohistory`.
   DiscreteTrajectorySegmentIterator<Barycentric> psychohistory_;
 
-  // We will use union-find algorithms on |Part|s.
+  // We will use union-find algorithms on `Part`s.
   not_null<std::unique_ptr<Subset<Part>::Node>> const subset_node_;
   friend class Subset<Part>::Node;
 
diff --git a/ksp_plugin/part_subsets.cpp b/ksp_plugin/part_subsets.cpp
index e62e2d9f6c..2ad7306917 100644
--- a/ksp_plugin/part_subsets.cpp
+++ b/ksp_plugin/part_subsets.cpp
@@ -32,7 +32,7 @@ Subset<Part>::Properties::Properties(not_null<Part*> const part) {
 
 void Subset<Part>::Properties::MergeWith(Properties& other) {
   if (SubsetsOfSamePileUp(*this, other)) {
-    // The subsets |*this| and |other| are disjoint.
+    // The subsets `*this` and `other` are disjoint.
     CHECK_EQ(missing_ - other.parts_.size(),
              other.missing_ - parts_.size());
     missing_ -= other.parts_.size();
diff --git a/ksp_plugin/part_subsets.hpp b/ksp_plugin/part_subsets.hpp
index 47ed997dad..03610671be 100644
--- a/ksp_plugin/part_subsets.hpp
+++ b/ksp_plugin/part_subsets.hpp
@@ -8,7 +8,7 @@
 #include "ksp_plugin/pile_up.hpp"
 #include "physics/ephemeris.hpp"
 
-// This ksp_plugin file is in namespace |base| to specialize templates declared
+// This ksp_plugin file is in namespace `base` to specialize templates declared
 // therein.
 
 namespace principia {
@@ -24,25 +24,25 @@ using namespace principia::ksp_plugin::_frames;
 using namespace principia::ksp_plugin::_pile_up;
 using namespace principia::physics::_ephemeris;
 
-// Within an union-find on |Part|s, we maintain lists of the elements in the
+// Within an union-find on `Part`s, we maintain lists of the elements in the
 // disjoint sets.  Moreover, we keep track of the inclusion relations of those
-// sets to the sets of |Part|s in existing |PileUp|s, destroying existing
-// |PileUp|s as we learn that they will not appear in the new arrangement.
-// The |Collect| operation finalizes this, destroying existing |PileUp| which
-// are strict supersets of the new sets, and creating the new |PileUp|s.
+// sets to the sets of `Part`s in existing `PileUp`s, destroying existing
+// `PileUp`s as we learn that they will not appear in the new arrangement.
+// The `Collect` operation finalizes this, destroying existing `PileUp` which
+// are strict supersets of the new sets, and creating the new `PileUp`s.
 template<>
 class Subset<Part>::Properties final {
   using PileUps = std::list<PileUp*>;
 
  public:
-  // |*part| must outlive the constructed object.
+  // `*part` must outlive the constructed object.
   explicit Properties(not_null<Part*> part);
 
-  // If |*this| and |other| are subsets of different |PileUp|s, or one is a
-  // subset and not the other, the relevant |PileUp|s are erased.
-  // Otherwise, |this->subset_of_existing_pile_up_| keeps track of the number of
+  // If `*this` and `other` are subsets of different `PileUp`s, or one is a
+  // subset and not the other, the relevant `PileUp`s are erased.
+  // Otherwise, `this->subset_of_existing_pile_up_` keeps track of the number of
   // missing parts.
-  // Maintains |parts_| by joining the lists.
+  // Maintains `parts_` by joining the lists.
   void MergeWith(Properties& other);
 
   // “What’s this thing suddenly coming towards me very fast? Very very fast.
@@ -52,13 +52,13 @@ class Subset<Part>::Properties final {
   void Ground();
   bool grounded() const;
 
-  // If |collected_|, performs no action.
-  // Otherwise, sets |collected_|, and:
-  // - if |EqualsExistingPileUp()|, performs no action.
-  // - if |StrictSubsetOfExistingPileUp()|, erases the existing |PileUp| inserts
-  //   a new |PileUp| into |pile_ups| with the parts in |parts_|.
-  // - if |!subset_of_existing_pile_up_|, inserts a new |PileUp| into |pile_ups|
-  //   with the parts in |parts_|.  The new |PileUp| is created using the given
+  // If `collected_`, performs no action.
+  // Otherwise, sets `collected_`, and:
+  // - if `EqualsExistingPileUp()`, performs no action.
+  // - if `StrictSubsetOfExistingPileUp()`, erases the existing `PileUp` inserts
+  //   a new `PileUp` into `pile_ups` with the parts in `parts_`.
+  // - if `!subset_of_existing_pile_up_`, inserts a new `PileUp` into `pile_ups`
+  //   with the parts in `parts_`.  The new `PileUp` is created using the given
   //   parameters.
   void Collect(
       PileUps& pile_ups,
@@ -70,26 +70,26 @@ class Subset<Part>::Properties final {
       not_null<Ephemeris<Barycentric>*> ephemeris);
 
  private:
-  // Whether |left| and |right| are both subsets of the same existing |PileUp|.
-  // Implies |left.SubsetOfExistingPileUp()| and
-  // |right.SubsetOfExistingPileUp()|.
+  // Whether `left` and `right` are both subsets of the same existing `PileUp`.
+  // Implies `left.SubsetOfExistingPileUp()` and
+  // `right.SubsetOfExistingPileUp()`.
   static bool SubsetsOfSamePileUp(Properties const& left,
                                   Properties const& right);
-  // Whether the set of |Part|s in |parts_| is equal to the set of |Part|s
-  // in an existing |PileUp|.  Implies |SubsetOfExistingPileUp()|.
+  // Whether the set of `Part`s in `parts_` is equal to the set of `Part`s
+  // in an existing `PileUp`.  Implies `SubsetOfExistingPileUp()`.
   bool EqualsExistingPileUp() const;
-  // Whether the set of |Part|s in |parts_| is a subset of the set of
-  // |Part|s in an existing |PileUp|.  In that case
-  // |parts_.front()->containing_pile_up()| is that |PileUp|.
+  // Whether the set of `Part`s in `parts_` is a subset of the set of
+  // `Part`s in an existing `PileUp`.  In that case
+  // `parts_.front()->containing_pile_up()` is that `PileUp`.
   bool SubsetOfExistingPileUp() const;
-  // Whether the set of |Part|s in |parts_| is a strict subset of the set of
-  // |Part|s in an existing |PileUp|.  Implies |SubsetOfExistingPileUp()|.
+  // Whether the set of `Part`s in `parts_` is a strict subset of the set of
+  // `Part`s in an existing `PileUp`.  Implies `SubsetOfExistingPileUp()`.
   bool StrictSubsetOfExistingPileUp() const;
 
-  // Whether |Collect| has been called.
+  // Whether `Collect` has been called.
   bool collected_ = false;
-  // if |SubsetOfExistingPileUp()|, |missing_| is the number of parts in that
-  // |PileUp| that are not in this subset.
+  // if `SubsetOfExistingPileUp()`, `missing_` is the number of parts in that
+  // `PileUp` that are not in this subset.
   int missing_;
   // The list of parts in this subset.
   std::list<not_null<Part*>> parts_;
diff --git a/ksp_plugin/pile_up.cpp b/ksp_plugin/pile_up.cpp
index 33397a98b8..7e52168705 100644
--- a/ksp_plugin/pile_up.cpp
+++ b/ksp_plugin/pile_up.cpp
@@ -453,7 +453,7 @@ void PileUp::DeformPileUpIfNeeded(Instant const& t) {
     }
     return;
   }
-  // A consistency check that |SetPartApparentDegreesOfFreedom| was called for
+  // A consistency check that `SetPartApparentDegreesOfFreedom` was called for
   // all the parts.
   // TODO(egg): I'd like to log some useful information on check failure, but I
   // need a clean way of getting the debug strings of all parts (rather than
@@ -482,10 +482,10 @@ void PileUp::DeformPileUpIfNeeded(Instant const& t) {
 
   // In a non-rigid body, the principal axes are not stable, and cannot be used
   // to determine attitude.  We treat this as a flexible body, and use the parts
-  // to propagate the attitude: the part orientations at |t0| and |t| are used
+  // to propagate the attitude: the part orientations at `t0` and `t` are used
   // as input to Davenport's method to figure out how the game rotated the pile-
-  // up overall.  This is then used to determine the attitute at |t| based on
-  // the principal axis at |t|.
+  // up overall.  This is then used to determine the attitute at `t` based on
+  // the principal axis at `t`.
 
   // Compute the canonical axes of all the parts using their apparent and actual
   // motions.
@@ -519,7 +519,7 @@ void PileUp::DeformPileUpIfNeeded(Instant const& t) {
                        /*weights=*/masses);
 
   // In order to prevent roundoff accumulation from eventually producing
-  // noticeably non-unit quaternions, we normalize |initial_attitude|.
+  // noticeably non-unit quaternions, we normalize `initial_attitude`.
   Rotation<PileUpPrincipalAxes, NonRotatingPileUp> initial_attitude =
       davenport_rotation.Inverse() *
       apparent_system.LinearMotion().orthogonal_map().AsRotation() *
@@ -527,7 +527,7 @@ void PileUp::DeformPileUpIfNeeded(Instant const& t) {
   initial_attitude = Rotation<PileUpPrincipalAxes, NonRotatingPileUp>(
       Normalize(initial_attitude.quaternion()));
 
-  // We take into account the changes to |angular_momentum_| and to the moments
+  // We take into account the changes to `angular_momentum_` and to the moments
   // of inertia for the step from t0 to t before propagating the attitude from
   // t0 to t. This forms a splitting with the game, with the game changing
   // angular momentum and moment of inertia according to various physical
@@ -596,7 +596,7 @@ absl::Status PileUp::AdvanceTime(Instant const& t) {
     status = ephemeris_->FlowWithFixedStep(t, *fixed_instance_);
     psychohistory_ = trajectory_.NewSegment();
     if (history_->back().time < t) {
-      // Do not clear the |fixed_instance_| here, we will use it for the next
+      // Do not clear the `fixed_instance_` here, we will use it for the next
       // fixed-step integration.
       status.Update(ephemeris_->FlowWithAdaptiveStep(
           &trajectory_,
@@ -608,10 +608,10 @@ absl::Status PileUp::AdvanceTime(Instant const& t) {
     // Destroy the fixed instance, it wouldn't be correct to use it the next
     // time we go through this function.  It will be re-created as needed.
     fixed_instance_ = nullptr;
-    // We make the |psychohistory_|, if any, authoritative, i.e. append it to
-    // the end of the |history_|.  We integrate on top of it.  Note how we skip
+    // We make the `psychohistory_`, if any, authoritative, i.e. append it to
+    // the end of the `history_`.  We integrate on top of it.  Note how we skip
     // the first point of the psychohistory, which is already present in the
-    // |trajectory_|.
+    // `trajectory_`.
     auto const psychohistory_trajectory =
         trajectory_.DetachSegments(psychohistory_);
     CHECK(!psychohistory_trajectory.empty());
@@ -630,7 +630,7 @@ absl::Status PileUp::AdvanceTime(Instant const& t) {
     psychohistory_ = trajectory_.NewSegment();
   }
 
-  // Append the |history_| to the parts' history and the |psychohistory_| to the
+  // Append the `history_` to the parts' history and the `psychohistory_` to the
   // parts' psychohistory.  Drop the history of the pile-up, we won't need it
   // anymore.
   auto const history_end = history_->end();
diff --git a/ksp_plugin/pile_up.hpp b/ksp_plugin/pile_up.hpp
index ab4711a91f..0898c1e8f2 100644
--- a/ksp_plugin/pile_up.hpp
+++ b/ksp_plugin/pile_up.hpp
@@ -69,10 +69,10 @@ using ApparentPileUp = Frame<struct ApparentPileUpTag,
                              NonRotating,
                              Handedness::Right>;
 
-// The origin of |NonRotatingPileUp| is the centre of mass of the pile up.
-// Its axes are those of |Barycentric|. It is used to describe the rotational
+// The origin of `NonRotatingPileUp` is the centre of mass of the pile up.
+// Its axes are those of `Barycentric`. It is used to describe the rotational
 // motion of the pile up (being a nonrotating frame) without running into
-// numerical issues from having a faraway origin like that of |Barycentric|.
+// numerical issues from having a faraway origin like that of `Barycentric`.
 // This also makes the quantities more conceptually convenient: the angular
 // momentum and inertia tensor with respect to the centre of mass are easier to
 // reason with than the same quantities with respect to the barycentre of the
@@ -82,16 +82,16 @@ using NonRotatingPileUp = Frame<serialization::Frame::PluginTag,
                                 Handedness::Right,
                                 serialization::Frame::NON_ROTATING_PILE_UP>;
 
-// The origin of |PileUpPrincipalAxes| is the centre of mass of the pile up. Its
+// The origin of `PileUpPrincipalAxes` is the centre of mass of the pile up. Its
 // axes are instantaneous principal axes of the pile up.
 using PileUpPrincipalAxes = Frame<serialization::Frame::PluginTag,
                                   Arbitrary,
                                   Handedness::Right,
                                   serialization::Frame::PILE_UP_PRINCIPAL_AXES>;
 
-// A |PileUp| handles a connected component of the graph of |Parts| under
+// A `PileUp` handles a connected component of the graph of `Parts` under
 // physical contact.  It advances the history and psychohistory of its component
-// |Parts|, modeling them as a massless body at their centre of mass.
+// `Parts`, modeling them as a massless body at their centre of mass.
 class PileUp {
  public:
   PileUp(
@@ -102,14 +102,14 @@ class PileUp {
       not_null<Ephemeris<Barycentric>*> ephemeris,
       std::function<void()> deletion_callback);
 
-  // Runs the |deletion_callback| passed at construction, if not null.
+  // Runs the `deletion_callback` passed at construction, if not null.
   virtual ~PileUp();
 
   std::list<not_null<Part*>> const& parts() const;
   Ephemeris<Barycentric>::FixedStepParameters const& fixed_step_parameters()
       const;
 
-  // Set the rigid motion for the given |part|.  This rigid motion is *apparent*
+  // Set the rigid motion for the given `part`.  This rigid motion is *apparent*
   // in the sense that it was reported by the game but we know better since we
   // are doing science.
   void SetPartApparentRigidMotion(
@@ -117,7 +117,7 @@ class PileUp {
       RigidMotion<RigidPart, Apparent> const& rigid_motion);
 
   // Deforms the pile-up, advances the time, and nudges the parts, in sequence.
-  // Does nothing if the psychohistory is already advanced beyond |t|.  Several
+  // Does nothing if the psychohistory is already advanced beyond `t`.  Several
   // executions of this method may happen concurrently on multiple threads, but
   // not concurrently with any other method of this class.
   absl::Status DeformAndAdvanceTime(Instant const& t);
@@ -138,7 +138,7 @@ class PileUp {
       std::function<void()> deletion_callback);
 
  private:
-  // A pointer to a member function of |Part| used to append a point to either
+  // A pointer to a member function of `Part` used to append a point to either
   // trajectory (history or psychohistory).
   using AppendToPartTrajectory =
       void (Part::*)(Instant const&, DegreesOfFreedom<Barycentric> const&);
@@ -157,34 +157,34 @@ class PileUp {
       not_null<Ephemeris<Barycentric>*> ephemeris,
       std::function<void()> deletion_callback);
 
-  // Sets |euler_solver_| and updates |rigid_pile_up_|.
+  // Sets `euler_solver_` and updates `rigid_pile_up_`.
   void MakeEulerSolver(InertiaTensor<NonRotatingPileUp> const& inertia_tensor,
                        Instant const& t);
 
-  // Update the degrees of freedom (in |NonRotatingPileUp|) of all the parts by
+  // Update the degrees of freedom (in `NonRotatingPileUp`) of all the parts by
   // translating the *apparent* degrees of freedom so that their centre of mass
   // matches that computed by integration.
-  // |SetPartApparentDegreesOfFreedom| must have been called for each part in
+  // `SetPartApparentDegreesOfFreedom` must have been called for each part in
   // the pile-up, or for none.
-  // The degrees of freedom set by this method are used by |NudgeParts|.
+  // The degrees of freedom set by this method are used by `NudgeParts`.
   void DeformPileUpIfNeeded(Instant const& t);
 
-  // Flows the history authoritatively as far as possible up to |t|, advances
+  // Flows the history authoritatively as far as possible up to `t`, advances
   // the histories of the parts and updates the degrees of freedom of the parts
-  // if the pile-up is in the bubble.  After this call, the tail (of |*this|)
-  // and of its parts have a (possibly ahistorical) final point exactly at |t|.
+  // if the pile-up is in the bubble.  After this call, the tail (of `*this`)
+  // and of its parts have a (possibly ahistorical) final point exactly at `t`.
   absl::Status AdvanceTime(Instant const& t);
 
   // Adjusts the degrees of freedom of all parts in this pile up based on the
-  // degrees of freedom of the pile-up computed by |AdvanceTime| and on the
-  // |NonRotatingPileUp| degrees of freedom of the parts, as set by
-  // |DeformPileUpIfNeeded|.
+  // degrees of freedom of the pile-up computed by `AdvanceTime` and on the
+  // `NonRotatingPileUp` degrees of freedom of the parts, as set by
+  // `DeformPileUpIfNeeded`.
   void NudgeParts() const;
 
   template<AppendToPartTrajectory append_to_part_trajectory>
   void AppendToPart(DiscreteTrajectory<Barycentric>::iterator it) const;
 
-  // Wrapped in a |unique_ptr| to be moveable.
+  // Wrapped in a `unique_ptr` to be moveable.
   not_null<std::unique_ptr<absl::Mutex>> lock_;
 
   std::list<not_null<Part*>> parts_;
@@ -206,18 +206,18 @@ class PileUp {
   // history and the psychohistory.
   DiscreteTrajectory<Barycentric> trajectory_;
 
-  // The |history_| is the past trajectory of the pile-up.  It is normally
-  // integrated with a fixed step using |fixed_instance_|, except in the
+  // The `history_` is the past trajectory of the pile-up.  It is normally
+  // integrated with a fixed step using `fixed_instance_`, except in the
   // presence of intrinsic acceleration.  It is authoritative in the sense that
   // it is never going to change.
   DiscreteTrajectorySegmentIterator<Barycentric> history_;
 
-  // The |psychohistory_| is the recent past trajectory of the pile-up.  Since
-  // we need to draw something between the last point of the |history_| and the
+  // The `psychohistory_` is the recent past trajectory of the pile-up.  Since
+  // we need to draw something between the last point of the `history_` and the
   // current time, we must have a bit of trajectory that may not cover an entire
-  // fixed step.  This part is the |psychohistory_|, and it is forked at the end
-  // of the |history_|.  It is not authoritative in the sense that it may not
-  // match the |history_| that we'll ultimately compute.  The name comes from
+  // fixed step.  This part is the `psychohistory_`, and it is forked at the end
+  // of the `history_`.  It is not authoritative in the sense that it may not
+  // match the `history_` that we'll ultimately compute.  The name comes from
   // the fact that we are trying to predict the future, but since we are not as
   // good as Hari Seldon we only do it over a short period of time.
   DiscreteTrajectorySegmentIterator<Barycentric> psychohistory_;
diff --git a/ksp_plugin/planetarium.hpp b/ksp_plugin/planetarium.hpp
index 4e889ff950..334786406d 100644
--- a/ksp_plugin/planetarium.hpp
+++ b/ksp_plugin/planetarium.hpp
@@ -59,9 +59,9 @@ class Planetarium {
  public:
   class Parameters final {
    public:
-    // |sphere_radius_multiplier| defines the "dark area" around a celestial
-    // where we don't draw trajectories.  |angular_resolution| defines the limit
-    // beyond which spheres don't participate in hiding.  |field_of_view|
+    // `sphere_radius_multiplier` defines the "dark area" around a celestial
+    // where we don't draw trajectories.  `angular_resolution` defines the limit
+    // beyond which spheres don't participate in hiding.  `field_of_view`
     // is the half-angle of a cone outside of which not plotting takes place.
     explicit Parameters(double sphere_radius_multiplier,
                         Angle const& angular_resolution,
@@ -87,7 +87,7 @@ class Planetarium {
               PlottingToScaledSpaceConversion plotting_to_scaled_space);
 
   // A no-op method that just returns all the points in the trajectory defined
-  // by |begin| and |end|.
+  // by `begin` and `end`.
   RP2Lines<Length, Camera> PlotMethod0(
       DiscreteTrajectory<Barycentric> const& trajectory,
       DiscreteTrajectory<Barycentric>::iterator begin,
@@ -114,7 +114,7 @@ class Planetarium {
       Instant const& now,
       bool reverse) const;
 
-  // The same method, operating on the |Trajectory| interface.
+  // The same method, operating on the `Trajectory` interface.
   RP2Lines<Length, Camera> PlotMethod2(
       Trajectory<Barycentric> const& trajectory,
       Instant const& first_time,
@@ -135,8 +135,8 @@ class Planetarium {
       std::function<void(ScaledSpacePoint const&)> const& add_point,
       int max_points) const;
 
-  // The same method, operating on the |Trajectory| interface for any frame that
-  // can be converted to |Navigation|.
+  // The same method, operating on the `Trajectory` interface for any frame that
+  // can be converted to `Navigation`.
   template<typename Frame>
   void PlotMethod3(
       Trajectory<Frame> const& trajectory,
@@ -149,13 +149,13 @@ class Planetarium {
       Length* minimal_distance = nullptr) const;
 
  private:
-  // Computes the coordinates of the spheres that represent the |ephemeris_|
-  // bodies.  These coordinates are in the |plotting_frame_| at time |now|.
+  // Computes the coordinates of the spheres that represent the `ephemeris_`
+  // bodies.  These coordinates are in the `plotting_frame_` at time `now`.
   std::vector<Sphere<Navigation>> ComputePlottableSpheres(
       Instant const& now) const;
 
-  // Computes the segments of the trajectory defined by |begin| and |end| that
-  // are not hidden by the |plottable_spheres|.
+  // Computes the segments of the trajectory defined by `begin` and `end` that
+  // are not hidden by the `plottable_spheres`.
   Segments<Navigation> ComputePlottableSegments(
       const std::vector<Sphere<Navigation>>& plottable_spheres,
       DiscreteTrajectory<Barycentric>::iterator begin,
diff --git a/ksp_plugin/planetarium_body.hpp b/ksp_plugin/planetarium_body.hpp
index 11df4a8611..66cd491916 100644
--- a/ksp_plugin/planetarium_body.hpp
+++ b/ksp_plugin/planetarium_body.hpp
@@ -19,8 +19,8 @@ using namespace principia::physics::_similar_motion;
 using namespace principia::quantities::_elementary_functions;
 using namespace principia::quantities::_named_quantities;
 
-// A helper function that converts a trajectory expressed in |Frame| into one
-// expressed in |Navigation|, using the given |plotting_frame| if needed for the
+// A helper function that converts a trajectory expressed in `Frame` into one
+// expressed in `Navigation`, using the given `plotting_frame` if needed for the
 // transformation.
 template<typename Frame>
 DegreesOfFreedom<Navigation> EvaluateDegreesOfFreedomInNavigation(
diff --git a/ksp_plugin/plugin.cpp b/ksp_plugin/plugin.cpp
index 332ad7daaf..4445b06f7b 100644
--- a/ksp_plugin/plugin.cpp
+++ b/ksp_plugin/plugin.cpp
@@ -103,7 +103,7 @@ Length const& MaxCollisionError() {
   return max_collision_error;
 }
 
-// Keep this consistent with |prediction_steps_| in |main_window.cs|.
+// Keep this consistent with `prediction_steps_` in `main_window.cs`.
 constexpr std::int64_t max_steps_in_prediction = 1 << 24;
 
 Plugin::Plugin(std::string const& game_epoch,
@@ -124,10 +124,10 @@ Plugin::Plugin(std::string const& game_epoch,
 
 Plugin::~Plugin() {
   // We must manually destroy the vessels, triggering the destruction of the
-  // parts, which have callbacks to remove themselves from |part_id_to_vessel_|,
+  // parts, which have callbacks to remove themselves from `part_id_to_vessel_`,
   // which must therefore still exist.  This also causes the parts to be
   // destroyed, and therefore to destroy the pile-ups, which want to remove
-  // themselves from |pile_up_|, which also exists.
+  // themselves from `pile_up_`, which also exists.
   vessels_.clear();
 }
 
@@ -264,8 +264,8 @@ void Plugin::EndInitialization() {
 
   // This would use NewBodyCentredNonRotatingNavigationFrame, but we don't have
   // the sun's index at hand.
-  // TODO(egg): maybe these functions should take |Celestial*|s, and we should
-  // then export |FindOrDie(celestials_, _)|.
+  // TODO(egg): maybe these functions should take `Celestial*`s, and we should
+  // then export `FindOrDie(celestials_, _)`.
   renderer_ = std::make_unique<Renderer>(
       sun_,
       make_not_null_unique<
@@ -314,7 +314,7 @@ void Plugin::SetMainBody(Index const index) {
 
 Rotation<BodyWorld, World> Plugin::CelestialRotation(
     Index const index) const {
-  // |BodyWorld| with its y and z axes swapped (so that z is the polar axis).
+  // `BodyWorld` with its y and z axes swapped (so that z is the polar axis).
   using BodyFixed = Frame<struct BodyFixedTag>;
   Permutation<BodyWorld, BodyFixed> const body_mirror(OddPermutation::XZY);
 
@@ -342,7 +342,7 @@ Rotation<CelestialSphere, World> Plugin::CelestialSphereRotation()
 
 Angle Plugin::CelestialInitialRotation(Index const celestial_index) const {
   auto const& body = *FindOrDie(celestials_, celestial_index)->body();
-  // Offset by π/2 since |AngleAt| is with respect to the y axis of the
+  // Offset by π/2 since `AngleAt` is with respect to the y axis of the
   // celestial frame of the body, but KSP counts from the x axis.
   return body.AngleAt(game_epoch_) + π / 2 * Radian;
 }
@@ -448,7 +448,7 @@ void Plugin::InsertOrKeepLoadedPart(
   Instant const previous_time = current_time_ - Δt;
   OrthogonalMap<Barycentric, Barycentric> const Δplanetarium_rotation =
       Exp(Δt * angular_velocity_of_world_).Forget<OrthogonalMap>();
-  // TODO(egg): Can we use |BarycentricToWorld| here?
+  // TODO(egg): Can we use `BarycentricToWorld` here?
   BodyCentredNonRotatingReferenceFrame<Barycentric, MainBodyCentred> const
       main_body_frame{ephemeris_.get(),
                       FindOrDie(celestials_, main_body_index)->body()};
@@ -538,9 +538,9 @@ bool Plugin::PartIsTruthful(PartId const part_id) const {
 void Plugin::PrepareToReportCollisions() {
   for (auto const& [_, vessel] : vessels_) {
     // NOTE(egg): The lifetime requirement on the second argument of
-    // |MakeSingleton| (which forwards to the argument of the constructor of
-    // |Subset<Part>::Properties|) is that |part| outlives the constructed
-    // |Properties|; since these are owned by |part|, this is true.
+    // `MakeSingleton` (which forwards to the argument of the constructor of
+    // `Subset<Part>::Properties`) is that `part` outlives the constructed
+    // `Properties`; since these are owned by `part`, this is true.
     vessel->ForAllParts(
         [](Part& part) { Subset<Part>::MakeSingleton(part, &part); });
   }
@@ -617,7 +617,7 @@ void Plugin::FreeVesselsAndPartsAndCollectPileUps(Time const& Δt) {
   // are disjoint unions of vessels.
   {
     // Note that we need to go through an intermediate set, since destroying a
-    // vessel destroys its parts, which invalidates the intrusive |Subset| data
+    // vessel destroys its parts, which invalidates the intrusive `Subset` data
     // structure.
     VesselSet grounded_vessels;
     for (auto const& [_, vessel] : vessels_) {
@@ -662,15 +662,15 @@ void Plugin::FreeVesselsAndPartsAndCollectPileUps(Time const& Δt) {
 void Plugin::SetPartApparentRigidMotion(
     PartId const part_id,
     RigidMotion<EccentricPart, ApparentWorld> const& rigid_motion) {
-  // As a reference frame, |Apparent| differs from |World| only by having the
-  // same axes as |Barycentric| and being nonrotating.  However, there is
-  // another semantic distinction: |Apparent...| coordinates are uncorrected
+  // As a reference frame, `Apparent` differs from `World` only by having the
+  // same axes as `Barycentric` and being nonrotating.  However, there is
+  // another semantic distinction: `Apparent...` coordinates are uncorrected
   // data from the game, given immediately after its physics step; before using
   // them, we must correct them in accordance with the data computed by the pile
   // up.  This correction overrides the origin of position and velocity, so we
   // need not worry about the current definition of
-  // |{World::origin, World::unmoving}| as we do when getting the actual degrees
-  // of freedom (via |Plugin::BarycentricToWorld|).
+  // `{World::origin, World::unmoving}` as we do when getting the actual degrees
+  // of freedom (via `Plugin::BarycentricToWorld`).
   RigidMotion<ApparentWorld, Apparent> world_to_apparent{
       RigidTransformation<ApparentWorld, Apparent>{
           ApparentWorld::origin,
@@ -928,7 +928,7 @@ void Plugin::UpdatePrediction(std::vector<GUID> const& vessel_guids) const {
   Vessel* target_vessel = nullptr;
 
   // If there is a target vessel, ensure that the prediction of the
-  // |predicted_vessels| is not longer than that of the target vessel.  This is
+  // `predicted_vessels` is not longer than that of the target vessel.  This is
   // necessary to build the targeting frame.
   if (renderer_->HasTargetVessel()) {
     target_vessel = &renderer_->GetTargetVessel();
@@ -1509,7 +1509,7 @@ void Plugin::WriteToMessage(
 
   ephemeris_->WriteToMessage(message->mutable_ephemeris());
 
-  // |history_downsampling_parameters_| is not persisted.
+  // `history_downsampling_parameters_` is not persisted.
   history_fixed_step_parameters_.WriteToMessage(
       message->mutable_history_parameters());
   psychohistory_parameters_.WriteToMessage(
@@ -1726,8 +1726,8 @@ Velocity<World> Plugin::VesselVelocity(
   DegreesOfFreedom<Navigation> const plotting_frame_degrees_of_freedom =
       renderer_->BarycentricToPlotting(time)(degrees_of_freedom);
   // Note that in the rotating-pulsating reference frame, this value is given in
-  // current metres per second (that is, in metres at |time| per second, for a
-  // velocity at |time|).
+  // current metres per second (that is, in metres at `time` per second, for a
+  // velocity at `time`).
   return renderer_->PlottingToWorld(time, PlanetariumRotation())(
       plotting_frame_degrees_of_freedom.velocity());
 }
@@ -1778,7 +1778,7 @@ void Plugin::AddPart(not_null<Vessel*> const vessel,
   auto const [_, inserted] = part_id_to_vessel_.emplace(part_id, vessel);
   CHECK(inserted) << NAMED(part_id);
   auto deletion_callback = [part_id, &map = part_id_to_vessel_] {
-    // This entails a lookup, but iterators are not stable in |flat_hash_map|.
+    // This entails a lookup, but iterators are not stable in `flat_hash_map`.
     map.erase(part_id);
   };
   auto part = make_not_null_unique<Part>(part_id,
diff --git a/ksp_plugin/plugin.hpp b/ksp_plugin/plugin.hpp
index 57d0058f83..f5ead59b8e 100644
--- a/ksp_plugin/plugin.hpp
+++ b/ksp_plugin/plugin.hpp
@@ -99,8 +99,8 @@ using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 using namespace principia::quantities::_si;
 
-// The index of a body in |FlightGlobals.Bodies|, obtained by
-// |b.flightGlobalsIndex| in C#. We use this as a key in a map.
+// The index of a body in `FlightGlobals.Bodies`, obtained by
+// `b.flightGlobalsIndex` in C#. We use this as a key in a map.
 using Index = int;
 
 class Plugin {
@@ -112,18 +112,18 @@ class Plugin {
   Plugin& operator=(Plugin&&) = delete;
   virtual ~Plugin();
 
-  // Constructs a |Plugin|. The current time of that instance is
-  // |solar_system_epoch|.  The angle between the axes of |World| and
-  // |Barycentric| at |solar_system_epoch| is set to |planetarium_rotation|.
+  // Constructs a `Plugin`. The current time of that instance is
+  // `solar_system_epoch`.  The angle between the axes of `World` and
+  // `Barycentric` at `solar_system_epoch` is set to `planetarium_rotation`.
   // The epochs must be given in a format parseable by ParseTT.
   Plugin(std::string const& game_epoch,
          std::string const& solar_system_epoch,
          Angle const& planetarium_rotation);
 
-  // Inserts a celestial body with index |celestial_index| and the given
-  // |gravity_model| and |initial_state|.
-  // If |parent_index| is null, inserts the sun, otherwise the parent of the new
-  // body is the body with index |*parent_index|, which must already have been
+  // Inserts a celestial body with index `celestial_index` and the given
+  // `gravity_model` and `initial_state`.
+  // If `parent_index` is null, inserts the sun, otherwise the parent of the new
+  // body is the body with index `*parent_index`, which must already have been
   // inserted.
   // All the bodies must be inserted using the same method.
   virtual void InsertCelestialAbsoluteCartesian(
@@ -148,7 +148,7 @@ class Plugin {
   virtual void InitializePsychohistoryParameters(
       Ephemeris<Barycentric>::AdaptiveStepParameters const& parameters);
   // No setter for the default prediction parameters, as that default is always
-  // overriden by the vessel-specific |SetPredictionAdaptiveStepParameters|.
+  // overriden by the vessel-specific `SetPredictionAdaptiveStepParameters`.
 
   // Ends initialization.  The sun must have been inserted.
   virtual void EndInitialization();
@@ -159,15 +159,15 @@ class Plugin {
   // base, that has an attachment.
   virtual bool HasEncounteredApocalypse(std::string* details) const;
 
-  // Sets the parent of the celestial body with index |celestial_index| to the
-  // one with index |parent_index|. Both bodies must already have been
+  // Sets the parent of the celestial body with index `celestial_index` to the
+  // one with index `parent_index`. Both bodies must already have been
   // inserted. Must be called after initialization.
-  // For a KSP |CelestialBody| |b|, the arguments correspond to
-  // |b.flightGlobalsIndex|, |b.orbit.referenceBody.flightGlobalsIndex|.
+  // For a KSP `CelestialBody` `b`, the arguments correspond to
+  // `b.flightGlobalsIndex`, `b.orbit.referenceBody.flightGlobalsIndex`.
   virtual void UpdateCelestialHierarchy(Index celestial_index,
                                         Index parent_index) const;
 
-  // Sets the celestial whose axis of rotation will coincide with the |Alice|
+  // Sets the celestial whose axis of rotation will coincide with the `Alice`
   // z axis.
   virtual void SetMainBody(Index index);
   virtual Rotation<BodyWorld, World> CelestialRotation(Index index) const;
@@ -181,27 +181,27 @@ class Plugin {
 
   virtual Index CelestialIndexOfBody(MassiveBody const& body) const;
 
-  // Inserts a new vessel with GUID |vessel_guid| if it does not already exist,
-  // and flags the vessel with GUID |vessel_guid| so it is kept when calling
-  // |FreeVesselsAndPartsAndCollectPileUps|. The parent body for the vessel is
-  // set to the one with index |parent_index|, which must have been inserted
+  // Inserts a new vessel with GUID `vessel_guid` if it does not already exist,
+  // and flags the vessel with GUID `vessel_guid` so it is kept when calling
+  // `FreeVesselsAndPartsAndCollectPileUps`. The parent body for the vessel is
+  // set to the one with index `parent_index`, which must have been inserted
   // during initialization.
-  // Sets |inserted| to true if a new vessel was inserted, to false otherwise.
-  // If |InsertOrKeepVessel| is called with |loaded=false|, and returns
-  // |inserted=true|, |InsertUnloadedPart| must be called for its parts
-  // before the call to |AdvanceTime|, giving the vessel an initial state.
-  // For a KSP |Vessel| |v|, the arguments correspond to |v.id|,
-  // |v.orbit.referenceBody.flightGlobalsIndex|, |v.loaded|.
+  // Sets `inserted` to true if a new vessel was inserted, to false otherwise.
+  // If `InsertOrKeepVessel` is called with `loaded=false`, and returns
+  // `inserted=true`, `InsertUnloadedPart` must be called for its parts
+  // before the call to `AdvanceTime`, giving the vessel an initial state.
+  // For a KSP `Vessel` `v`, the arguments correspond to `v.id`,
+  // `v.orbit.referenceBody.flightGlobalsIndex`, `v.loaded`.
   virtual void InsertOrKeepVessel(GUID const& vessel_guid,
                                   std::string const& vessel_name,
                                   Index parent_index,
                                   bool loaded,
                                   bool& inserted);
 
-  // Adds a part with the given |part_id| to the vessel with the given |GUID|,
+  // Adds a part with the given `part_id` to the vessel with the given `GUID`,
   // which must be unloaded, putting the part at the given offset from the
   // parent body of the vessel.  The part is given unit mass; this does not
-  // matter, since the |PileUp| will be deformed when it first loads anyway.
+  // matter, since the `PileUp` will be deformed when it first loads anyway.
   virtual void InsertUnloadedPart(
       PartId part_id,
       std::string const& name,
@@ -210,10 +210,10 @@ class Plugin {
 
   // Inserts a new part with the given ID if it does not already exist, and
   // flags the part with the given ID so it is kept when calling
-  // |FreeVesselsAndPartsAndCollectPileUps|.
-  // The part is created in the given |vessel|, or if it already existed in
+  // `FreeVesselsAndPartsAndCollectPileUps`.
+  // The part is created in the given `vessel`, or if it already existed in
   // another vessel, is moved to that one.  If the part is created, its degrees
-  // of freedom are set using those given and the |main_body_index|; otherwise
+  // of freedom are set using those given and the `main_body_index`; otherwise
   // these three parameters are ignored.
   virtual void InsertOrKeepLoadedPart(
       PartId part_id,
@@ -228,7 +228,7 @@ class Plugin {
       RigidMotion<EccentricPart, World> const& part_rigid_motion,
       Time const& Δt);
 
-  // Calls |apply_intrinsic_force| and |apply_intrinsic_torque| on the
+  // Calls `apply_intrinsic_force` and `apply_intrinsic_torque` on the
   // relevant part, which must be in a loaded vessel.
   virtual void ApplyPartIntrinsicForce(
       PartId part_id,
@@ -243,42 +243,42 @@ class Plugin {
 
   virtual bool PartIsTruthful(PartId part_id) const;
 
-  // Calls |MakeSingleton| for all parts in loaded vessels, enabling the use of
+  // Calls `MakeSingleton` for all parts in loaded vessels, enabling the use of
   // union-find for pile up construction.  This must be called after the calls
-  // to |ApplyPartIntrinsicForce|, and before the calls to
-  // |ReportGroundCollision| or |ReportPartCollision|.
+  // to `ApplyPartIntrinsicForce`, and before the calls to
+  // `ReportGroundCollision` or `ReportPartCollision`.
   virtual void PrepareToReportCollisions();
 
-  // Notifies |this| that the given part is touching the ground.
+  // Notifies `this` that the given part is touching the ground.
   virtual void ReportGroundCollision(PartId part) const;
 
-  // Notifies |this| that the given parts are touching, and should gravitate
+  // Notifies `this` that the given parts are touching, and should gravitate
   // as part of a single rigid body.
   virtual void ReportPartCollision(PartId part1, PartId part2) const;
 
-  // Destroys the vessels for which |InsertOrKeepVessel| has not been called
-  // since the last call to |FreeVesselsAndCollectPileUps|, as well as the
+  // Destroys the vessels for which `InsertOrKeepVessel` has not been called
+  // since the last call to `FreeVesselsAndCollectPileUps`, as well as the
   // vessels which transitively touch the ground.  Destroys the parts in loaded
-  // vessels for which |InsertOrKeepLoadedPart| has not been called.  Updates
-  // the list of |pile_ups_| according to the reported collisions.
+  // vessels for which `InsertOrKeepLoadedPart` has not been called.  Updates
+  // the list of `pile_ups_` according to the reported collisions.
   virtual void FreeVesselsAndPartsAndCollectPileUps(Time const& Δt);
 
-  // Calls |SetPartApparentRigidMotion| on the pile-up containing the relevant
+  // Calls `SetPartApparentRigidMotion` on the pile-up containing the relevant
   // part.  This part must be in a loaded vessel.
   virtual void SetPartApparentRigidMotion(
       PartId part_id,
       RigidMotion<EccentricPart, ApparentWorld> const& rigid_motion);
 
-  // Returns the motion of the given part in |World|, assuming that
-  // the origin of |World| is fixed at the centre of mass of the
-  // |part_at_origin|.
+  // Returns the motion of the given part in `World`, assuming that
+  // the origin of `World` is fixed at the centre of mass of the
+  // `part_at_origin`.
   virtual RigidMotion<EccentricPart, World> GetPartActualMotion(
       PartId part_id,
       RigidMotion<Barycentric, World> const& barycentric_to_world) const;
 
-  // Returns the |World| degrees of freedom of the |Celestial| with the given
-  // |Index|, identifying the origin of |World| with the centre of mass of the
-  // |Part| with the given |PartId|.
+  // Returns the `World` degrees of freedom of the `Celestial` with the given
+  // `Index`, identifying the origin of `World` with the centre of mass of the
+  // `Part` with the given `PartId`.
   virtual DegreesOfFreedom<World> CelestialWorldDegreesOfFreedom(
       Index index,
       RigidMotion<Barycentric, World> const& barycentric_to_world,
@@ -289,53 +289,53 @@ class Plugin {
       PartId reference_part_id,
       std::optional<Position<World>> const& main_body_centre) const;
 
-  // Simulates the system until instant |t|.  Sets |current_time_| to |t|.
+  // Simulates the system until instant `t`.  Sets `current_time_` to `t`.
   // Must be called after initialization.
   // Clears the intrinsic force on all loaded parts.
-  // |t| must be greater than |current_time_|.  |planetarium_rotation| is the
-  // value of KSP's |Planetarium.InverseRotAngle| at instant |t|, which provides
-  // the rotation between the |World| axes and the |Barycentric| axes (we don't
+  // `t` must be greater than `current_time_`.  `planetarium_rotation` is the
+  // value of KSP's `Planetarium.InverseRotAngle` at instant `t`, which provides
+  // the rotation between the `World` axes and the `Barycentric` axes (we don't
   // use Planetarium.Rotation since it undergoes truncation to single-precision
   // even though it's a double-precision value).  Note that KSP's
-  // |Planetarium.InverseRotAngle| is in degrees.
+  // `Planetarium.InverseRotAngle` is in degrees.
   virtual void AdvanceTime(Instant const& t, Angle const& planetarium_rotation);
 
-  // Advances time to |current_time_| for all pile ups that are not already
+  // Advances time to `current_time_` for all pile ups that are not already
   // there, filling the tails of all their parts up to that instant; then
-  // advances time on all vessels that are not yet at |current_time_|.  Inserts
+  // advances time on all vessels that are not yet at `current_time_`.  Inserts
   // the set of vessels that have collided with a celestial into
-  // |collided_vessels|.
+  // `collided_vessels`.
   virtual void CatchUpLaggingVessels(VesselSet& collided_vessels);
 
-  // Advances time to |current_time_| on the pile up containing the given
+  // Advances time to `current_time_` on the pile up containing the given
   // vessel if the pile up is not there already, and advances time to
-  // |current_time_| on that vessel.  This operation is asynchronous: the caller
+  // `current_time_` on that vessel.  This operation is asynchronous: the caller
   // must wait on the returned future before using the trajectories of the
   // vessel.  The caller must ensure that the vessels don't change while this
   // method is running.
   virtual not_null<std::unique_ptr<PileUpFuture>> CatchUpVessel(
       GUID const& vessel_guid);
 
-  // Waits for the |future| to return and inserts the set of vessels that have
-  // collided with a celestial into |collided_vessels|.
+  // Waits for the `future` to return and inserts the set of vessels that have
+  // collided with a celestial into `collided_vessels`.
   virtual void WaitForVesselToCatchUp(PileUpFuture& pile_up_future,
                                       VesselSet& collided_vessels);
 
-  // Returns the displacement and velocity of the vessel with GUID |vessel_guid|
-  // relative to its parent at current time. For a KSP |Vessel| |v|, the
-  // argument corresponds to  |v.id.ToString()|, the return value to
-  // |{v.orbit.pos, v.orbit.vel}|.
-  // A vessel with GUID |vessel_guid| must have been inserted and kept. Must
+  // Returns the displacement and velocity of the vessel with GUID `vessel_guid`
+  // relative to its parent at current time. For a KSP `Vessel` `v`, the
+  // argument corresponds to  `v.id.ToString()`, the return value to
+  // `{v.orbit.pos, v.orbit.vel}`.
+  // A vessel with GUID `vessel_guid` must have been inserted and kept. Must
   // be called after initialization.
   virtual RelativeDegreesOfFreedom<AliceSun> VesselFromParent(
       Index parent_index,
       GUID const& vessel_guid) const;
 
   // Returns the displacement and velocity of the celestial at index
-  // |celestial_index| relative to its parent at current time. For a KSP
-  // |CelestialBody| |b|, the argument corresponds to |b.flightGlobalsIndex|,
-  // the return value to |{b.orbit.pos, b.orbit.vel}|.
-  // A celestial with index |celestial_index| must have been inserted, and it
+  // `celestial_index` relative to its parent at current time. For a KSP
+  // `CelestialBody` `b`, the argument corresponds to `b.flightGlobalsIndex`,
+  // the return value to `{b.orbit.pos, b.orbit.vel}`.
+  // A celestial with index `celestial_index` must have been inserted, and it
   // must not be the sun. Must be called after initialization.
   virtual RelativeDegreesOfFreedom<AliceSun> CelestialFromParent(
       Index celestial_index) const;
@@ -345,7 +345,7 @@ class Plugin {
       Ephemeris<Barycentric>::AdaptiveStepParameters const&
           prediction_adaptive_step_parameters) const;
 
-  // Updates the prediction for the vessels with guids in |vessel_guids|.
+  // Updates the prediction for the vessels with guids in `vessel_guids`.
   void UpdatePrediction(std::vector<GUID> const& vessel_guids) const;
 
   virtual void CreateFlightPlan(GUID const& vessel_guid,
@@ -356,8 +356,8 @@ class Plugin {
   // and cover the actual final time of the flight plan.
   virtual void ExtendPredictionForFlightPlan(GUID const& vessel_guid) const;
 
-  // Computes the apsides of the trajectory defined by |begin| and |end| with
-  // respect to the celestial with index |celestial_index|.
+  // Computes the apsides of the trajectory defined by `begin` and `end` with
+  // respect to the celestial with index `celestial_index`.
   virtual void ComputeAndRenderApsides(
       Index celestial_index,
       Trajectory<Barycentric> const& trajectory,
@@ -369,8 +369,8 @@ class Plugin {
       DiscreteTrajectory<World>& apoapsides,
       DiscreteTrajectory<World>& periapsides) const;
 
-  // Computes the first collision between the trajectory defined by |begin| and
-  // |end| and the celestial with index |celestial_index|.
+  // Computes the first collision between the trajectory defined by `begin` and
+  // `end` and the celestial with index `celestial_index`.
   virtual std::optional<DiscreteTrajectory<World>::value_type>
   ComputeAndRenderFirstCollision(
       Index celestial_index,
@@ -382,8 +382,8 @@ class Plugin {
       std::function<Length(Angle const& latitude,
                            Angle const& longitude)> const& radius) const;
 
-  // Computes the closest approaches of the trajectory defined by |begin| and
-  // |end| with respect to the trajectory of the targetted vessel.
+  // Computes the closest approaches of the trajectory defined by `begin` and
+  // `end` with respect to the trajectory of the targetted vessel.
   virtual void ComputeAndRenderClosestApproaches(
       Trajectory<Barycentric> const& trajectory,
       DiscreteTrajectory<Barycentric>::iterator const& begin,
@@ -392,7 +392,7 @@ class Plugin {
       int max_points,
       DiscreteTrajectory<World>& closest_approaches) const;
 
-  // Computes the nodes of the trajectory defined by |begin| and |end| with
+  // Computes the nodes of the trajectory defined by `begin` and `end` with
   // respect to plane of the trajectory of the targetted vessel.
   virtual void ComputeAndRenderNodes(
       DiscreteTrajectory<Barycentric>::iterator const& begin,
@@ -439,12 +439,12 @@ class Plugin {
   virtual void SetTargetVessel(GUID const& vessel_guid,
                                Index reference_body_index);
 
-  // The navball field at |current_time| for the current |plotting_frame_|.
+  // The navball field at `current_time` for the current `plotting_frame_`.
   virtual std::unique_ptr<FrameField<World, Navball>> NavballFrameField(
       Position<World> const& sun_world_position) const;
 
   // The unit tangent, normal, or binormal vector to the trajectory of the
-  // vessel with the given GUID in the current |plotting_frame_|.
+  // vessel with the given GUID in the current `plotting_frame_`.
   virtual Vector<double, World> VesselTangent(GUID const& vessel_guid) const;
   virtual Vector<double, World> VesselNormal(GUID const& vessel_guid) const;
   virtual Vector<double, World> VesselBinormal(GUID const& vessel_guid) const;
@@ -453,13 +453,13 @@ class Plugin {
 
   // Takes degrees of freedom relative to the celestial with the given index,
   // and returns the velocity in the plotting frame expressed in the coordinates
-  // of |World|.  This is used to display the velocity of a vessel not known to
+  // of `World`.  This is used to display the velocity of a vessel not known to
   // the plugin.
   virtual Velocity<World> UnmanageableVesselVelocity(
       RelativeDegreesOfFreedom<AliceSun> const& degrees_of_freedom,
       Index parent_index) const;
-  // Same as |UnmanageableVesselVelocity|, but uses the known degrees of freedom
-  // of a vessel in |vessels_|.
+  // Same as `UnmanageableVesselVelocity`, but uses the known degrees of freedom
+  // of a vessel in `vessels_`.
   virtual Velocity<World> VesselVelocity(GUID const& vessel_guid) const;
 
   void RequestReanimation(Instant const& desired_t_min) const;
@@ -468,8 +468,8 @@ class Plugin {
 
   virtual Instant CurrentTime() const;
 
-  // The rotation between the |AliceWorld| basis at |current_time_| and the
-  // |Barycentric| axes. Since |AliceSun| is not a rotating reference frame,
+  // The rotation between the `AliceWorld` basis at `current_time_` and the
+  // `Barycentric` axes. Since `AliceSun` is not a rotating reference frame,
   // this change of basis is all that's required to convert relative velocities
   // or displacements between simultaneous events.
   virtual Rotation<Barycentric, AliceSun> const& PlanetariumRotation() const;
@@ -504,16 +504,16 @@ class Plugin {
       Index celestial_index,
       std::optional<Index> const& parent_index);
 
-  // Computes the value returned by |PlanetariumRotation|.  Must be called
-  // whenever |main_body_| or |planetarium_rotation_| changes.
+  // Computes the value returned by `PlanetariumRotation`.  Must be called
+  // whenever `main_body_` or `planetarium_rotation_` changes.
   void UpdatePlanetariumRotation();
 
   Velocity<World> VesselVelocity(
       Instant const& time,
       DegreesOfFreedom<Barycentric> const& degrees_of_freedom) const;
 
-  // Fill |celestials| using the |index| and |parent_index| fields found in
-  // |celestial_messages|.
+  // Fill `celestials` using the `index` and `parent_index` fields found in
+  // `celestial_messages`.
   template<typename T>
   static void ReadCelestialsFromMessages(
       Ephemeris<Barycentric> const& ephemeris,
@@ -529,7 +529,7 @@ class Plugin {
                std::string const& name,
                Args... args);
 
-  // Whether |loaded_vessels_| contains |vessel|.
+  // Whether `loaded_vessels_` contains `vessel`.
   bool is_loaded(not_null<Vessel*> vessel) const;
 
   // Initialization objects.
@@ -584,14 +584,14 @@ class Plugin {
   RotatingBody<Barycentric> const* main_body_ = nullptr;
   AngularVelocity<Barycentric> angular_velocity_of_world_;
 
-  // Do not |erase| from this list, use |Part::reset_containing_pile_up| instead
+  // Do not `erase` from this list, use `Part::reset_containing_pile_up` instead
   // and the pile-up will remove itself once no part owns it.  The elements are
-  // not |not_null<>| because we temporarily need to insert null pointers.
+  // not `not_null<>` because we temporarily need to insert null pointers.
   std::list<PileUp*> pile_ups_;
 
   // The vessels that are currently loaded, i.e. in the physics bubble.
   VesselSet loaded_vessels_;
-  // The vessels that will be kept during the next call to |AdvanceTime|.
+  // The vessels that will be kept during the next call to `AdvanceTime`.
   VesselConstSet kept_vessels_;
   // Contains the adaptive step parameters for the vessel that existed in the
   // past but are no longer known to the plugin.  Useful to avoid losing the
diff --git a/ksp_plugin/renderer.cpp b/ksp_plugin/renderer.cpp
index 1ffe7ab52e..c2365e8343 100644
--- a/ksp_plugin/renderer.cpp
+++ b/ksp_plugin/renderer.cpp
@@ -133,15 +133,15 @@ Renderer::RenderPlottingTrajectoryInWorld(
   // that we are considering an observer fixed in the plotting frame.
   // - Instead of applying the full rigid motion and consistently transforming
   // the velocities, or even just applying the orthogonal map, it simply
-  // identifies the axes of |World| with those of the plotting frame. This is
+  // identifies the axes of `World` with those of the plotting frame. This is
   // because we are interested in the magnitude of the velocity (the speed) in
   // the plotting frame, as well as the coordinates (in frames with a physically
   // significant plane, the z coordinate becomes the out-of-plane velocity).
   // We apply the scaling at the time of the velocity, instead of the scaling at
-  // |time| or no scaling, because we want speeds in current metres per second,
-  // not in constant metres (at |time|) per second, nor in constant lunar
+  // `time` or no scaling, because we want speeds in current metres per second,
+  // not in constant metres (at `time`) per second, nor in constant lunar
   // distances (masquerading as metres) per second.
-  // The resulting |DegreesOfFreedom| should be seen as no more than a
+  // The resulting `DegreesOfFreedom` should be seen as no more than a
   // convenient hack to send a plottable position together with a velocity in
   // the coordinates we want.  In fact, it needs an articial permutation to
   // avoid a violation of handedness.
@@ -338,7 +338,7 @@ Rotation<CameraCompensatedReference, World> Renderer::CameraReferenceRotation(
 void Renderer::WriteToMessage(
     not_null<serialization::Renderer*> message) const {
   plotting_frame_->WriteToMessage(message->mutable_plotting_frame());
-  // No serialization of the |target_|.
+  // No serialization of the `target_`.
 }
 
 not_null<std::unique_ptr<Renderer>> Renderer::ReadFromMessage(
diff --git a/ksp_plugin/renderer.hpp b/ksp_plugin/renderer.hpp
index a6ad9be628..51cacda16d 100644
--- a/ksp_plugin/renderer.hpp
+++ b/ksp_plugin/renderer.hpp
@@ -69,18 +69,18 @@ class Renderer {
       not_null<std::unique_ptr<PlottingFrame>> plotting_frame);
 
   // Returns the current plotting frame.  This may not be the last set by
-  // |SetPlottingFrame| if it is overridden by a target vessel.
+  // `SetPlottingFrame` if it is overridden by a target vessel.
   virtual not_null<PlottingFrame const*> GetPlottingFrame() const;
 
   // Overrides the current plotting frame with one that is centred on the given
-  // |vessel|.
+  // `vessel`.
   virtual void SetTargetVessel(
       not_null<Vessel*> vessel,
       not_null<Celestial const*> celestial,
       not_null<Ephemeris<Barycentric> const*> ephemeris);
 
-  // Reverts to frame last set by |SetPlottingFrame|.  The second version only
-  // has an effect if the given |vessel| is the current target vessel.
+  // Reverts to frame last set by `SetPlottingFrame`.  The second version only
+  // has an effect if the given `vessel` is the current target vessel.
   virtual void ClearTargetVessel();
   virtual void ClearTargetVesselIf(not_null<Vessel*> vessel);
 
@@ -89,11 +89,11 @@ class Renderer {
   virtual Vessel& GetTargetVessel();
   virtual Vessel const& GetTargetVessel() const;
 
-  // Returns a trajectory in |World| corresponding to the trajectory defined by
-  // |begin| and |end|, as seen in the current plotting frame.  In this function
-  // and others in this class, |sun_world_position| is the current position of
-  // the sun in |World| space as returned by |Planetarium.fetch.Sun.position|;
-  // it is used to define the relation between |WorldSun| and |World|.
+  // Returns a trajectory in `World` corresponding to the trajectory defined by
+  // `begin` and `end`, as seen in the current plotting frame.  In this function
+  // and others in this class, `sun_world_position` is the current position of
+  // the sun in `World` space as returned by `Planetarium.fetch.Sun.position`;
+  // it is used to define the relation between `WorldSun` and `World`.
   virtual DiscreteTrajectory<World>
   RenderBarycentricTrajectoryInWorld(
       Instant const& time,
@@ -103,15 +103,15 @@ class Renderer {
       Rotation<Barycentric, AliceSun> const& planetarium_rotation) const;
 
   // Returns a trajectory in the current plotting frame corresponding to the
-  // trajectory defined by |begin| and |end|.  If there is a target vessel, its
+  // trajectory defined by `begin` and `end`.  If there is a target vessel, its
   // prediction must not be empty.
   virtual DiscreteTrajectory<Navigation>
   RenderBarycentricTrajectoryInPlotting(
       DiscreteTrajectory<Barycentric>::iterator const& begin,
       DiscreteTrajectory<Barycentric>::iterator const& end) const;
 
-  // Returns a trajectory in |World| corresponding to the trajectory defined by
-  // |begin| and |end| in the current plotting frame.
+  // Returns a trajectory in `World` corresponding to the trajectory defined by
+  // `begin` and `end` in the current plotting frame.
   virtual DiscreteTrajectory<World>
   RenderPlottingTrajectoryInWorld(
       Instant const& time,
@@ -144,20 +144,20 @@ class Renderer {
       Rotation<Barycentric, AliceSun> const& planetarium_rotation) const;
 
   // Converts from the Frenet frame of the manœuvre's initial time in the
-  // plotted frame to the |World| coordinates.
+  // plotted frame to the `World` coordinates.
   virtual OrthogonalMap<Frenet<Navigation>, World> FrenetToWorld(
       Instant const& time,
       NavigationManœuvre const& manœuvre,
       Rotation<Barycentric, AliceSun> const& planetarium_rotation) const;
 
   // Converts from the Frenet frame of the vessel's free-falling trajectory in
-  // the plotted frame to the |World| coordinates.
+  // the plotted frame to the `World` coordinates.
   virtual OrthogonalMap<Frenet<Navigation>, World> FrenetToWorld(
       Vessel const& vessel,
       Rotation<Barycentric, AliceSun> const& planetarium_rotation) const;
 
   // Converts from the Frenet frame of the vessel's free-falling trajectory in
-  // the given |navigation_frame| to the |World| coordinates.
+  // the given `navigation_frame` to the `World` coordinates.
   virtual OrthogonalMap<Frenet<Navigation>, World> FrenetToWorld(
       Vessel const& vessel,
       NavigationFrame const& navigation_frame,
diff --git a/ksp_plugin/vessel.cpp b/ksp_plugin/vessel.cpp
index 740c3b2707..5787848001 100644
--- a/ksp_plugin/vessel.cpp
+++ b/ksp_plugin/vessel.cpp
@@ -188,7 +188,7 @@ void Vessel::DetectCollapsibilityChange() {
     // that downsampling does not change collapsibility boundaries.
 
     // In normal situations we create a new segment with the collapsibility
-    // given by |will_be_collapsible|.  In one cornercase we delete the current
+    // given by `will_be_collapsible`.  In one cornercase we delete the current
     // segment.
     enum {
       Create,
@@ -215,7 +215,7 @@ void Vessel::DetectCollapsibilityChange() {
         // If there are no checkpoints in the current trajectory (this would
         // happen if we restored the last part of trajectory and it didn't
         // overlap with a checkpoint and no reanimation happened) then the
-        // |oldest_reanimated_checkpoint_| need to be updated to reflect the
+        // `oldest_reanimated_checkpoint_` need to be updated to reflect the
         // newly created checkpoint.
         absl::MutexLock l(&lock_);
         if (oldest_reanimated_checkpoint_ == InfiniteFuture) {
@@ -361,7 +361,7 @@ void Vessel::MakeFlightPlanOptimizationDriver(
 void Vessel::StartFlightPlanOptimizationDriver(
     FlightPlanOptimizationDriver::Parameters const& parameters) {
   // No need to deserialize here, we have surely called
-  // |MakeFlightPlanOptimizationDriver|, otherwise the driver would be null.
+  // `MakeFlightPlanOptimizationDriver`, otherwise the driver would be null.
   CHECK(has_deserialized_flight_plan());
   auto const& driver = std::get<OptimizableFlightPlan>(selected_flight_plan())
                            .optimization_driver;
@@ -436,7 +436,7 @@ void Vessel::AdvanceTime() {
   // multiple points, say one at t₀ + 21 s and one at t₀ + 24 s.  In this case
   // trying to insert the point at t₀ + 21 s would put us before the last point
   // of the history of B and would fail a check.  Therefore, we just ignore that
-  // point.  See #2507 and the |last_time| in AppendToVesselTrajectory.
+  // point.  See #2507 and the `last_time` in AppendToVesselTrajectory.
   AppendToVesselTrajectory(&Part::psychohistory_begin,
                            &Part::psychohistory_end,
                            *psychohistory_);
@@ -600,11 +600,11 @@ absl::Status Vessel::RebaseFlightPlan(Mass const& initial_mass) {
 }
 
 void Vessel::RefreshPrediction() {
-  // The |prognostication| is a trajectory which is computed asynchronously and
+  // The `prognostication` is a trajectory which is computed asynchronously and
   // may be used as a prediction;
   std::optional<DiscreteTrajectory<Barycentric>> prognostication;
 
-  // Note that we know that |RefreshPrediction| is called on the main thread,
+  // Note that we know that `RefreshPrediction` is called on the main thread,
   // therefore the ephemeris currently covers the last time of the
   // psychohistory.  Were this to change, this code might have to change.
   PrognosticatorParameters prognosticator_parameters{
@@ -706,9 +706,9 @@ void Vessel::WriteToMessage(not_null<serialization::Vessel*> const message,
   }
 
   // If the vessel is collapsible, we serialize at most the last
-  // |max_points_to_serialize| of the part of the trajectory that ends at the
-  // |backstory_|.  If it is not, however, we must serialize at least the entire
-  // |backstory_| otherwise we'd lose the beginning of a non-collapsible
+  // `max_points_to_serialize` of the part of the trajectory that ends at the
+  // `backstory_`.  If it is not, however, we must serialize at least the entire
+  // `backstory_` otherwise we'd lose the beginning of a non-collapsible
   // segment.
   std::int64_t const history_size = backstory_->end() - trajectory_.begin();
   std::int64_t const max_points_to_serialize_present_in_history =
@@ -768,7 +768,7 @@ not_null<std::unique_ptr<Vessel>> Vessel::ReadFromMessage(
           : is_pre_हरीश_चंद्र  ? "हरीश चंद्र"
                             : "Hilbert") << " Vessel";
 
-  // NOTE(egg): for now we do not read the |MasslessBody| as it can contain no
+  // NOTE(egg): for now we do not read the `MasslessBody` as it can contain no
   // information.
   auto vessel = make_not_null_unique<Vessel>(
       message.guid(),
@@ -797,8 +797,8 @@ not_null<std::unique_ptr<Vessel>> Vessel::ReadFromMessage(
     auto const psychohistory =
         DiscreteTrajectory<Barycentric>::ReadFromMessage(message.history(),
                                                          /*tracked=*/{});
-    // The |backstory_| has been created by the constructor above.  Reconstruct
-    // it from the |psychohistory|.
+    // The `backstory_` has been created by the constructor above.  Reconstruct
+    // it from the `psychohistory`.
     for (auto it = psychohistory.begin(); it != psychohistory.end();) {
       auto const& [time, degrees_of_freedom] = *it;
       ++it;
@@ -958,10 +958,10 @@ Vessel::Vessel()
 
 Checkpointer<serialization::Vessel>::Writer Vessel::MakeCheckpointerWriter() {
   return [this](not_null<serialization::Vessel::Checkpoint*> const message) {
-    // The extremities of the |backstory_| are implicitly exact.  Note that
-    // |backstory_->end()| might cause serialization of a 1-point psychohistory
+    // The extremities of the `backstory_` are implicitly exact.  Note that
+    // `backstory_->end()` might cause serialization of a 1-point psychohistory
     // or prediction (at the last time of the backstory).  To figure things out
-    // when reading we must track the |backstory_|.
+    // when reading we must track the `backstory_`.
     trajectory_.WriteToMessage(message->mutable_non_collapsible_segment(),
                                backstory_->begin(),
                                backstory_->end(),
@@ -1004,7 +1004,7 @@ absl::Status Vessel::Reanimate(Instant const desired_t_min) {
     checkpoints = checkpointer_->all_checkpoints_between(
         oldest_checkpoint_to_reanimate, oldest_reanimated_checkpoint_);
 
-    // The |oldest_reanimated_checkpoint_| has already been reanimated before,
+    // The `oldest_reanimated_checkpoint_` has already been reanimated before,
     // we don't need it below.
     checkpoints.erase(oldest_reanimated_checkpoint_);
   }
@@ -1050,7 +1050,7 @@ absl::StatusOr<Instant> Vessel::ReanimateOneCheckpoint(
   std::int64_t const reanimated_trajectory_size = reanimated_trajectory.size();
 
   // Construct a new collapsible segment at the end of the non-collapsible
-  // backstory and integrate it until |t_final|.
+  // backstory and integrate it until `t_final`.
   ++reanimated_backstory;
   reanimated_trajectory.DeleteSegments(reanimated_backstory);
   auto const collapsible_segment = reanimated_trajectory.NewSegment();
@@ -1114,7 +1114,7 @@ absl::StatusOr<DiscreteTrajectory<Barycentric>> Vessel::FlowPrognostication(
       FlightPlan::max_ephemeris_steps_per_frame);
   bool const reached_t_max = status.ok();
   if (reached_t_max) {
-    // This will prolong the ephemeris by |max_ephemeris_steps_per_frame|.
+    // This will prolong the ephemeris by `max_ephemeris_steps_per_frame`.
     status = ephemeris_->FlowWithAdaptiveStep(
         &prognostication,
         Ephemeris<Barycentric>::NoIntrinsicAcceleration,
@@ -1130,7 +1130,7 @@ absl::StatusOr<DiscreteTrajectory<Barycentric>> Vessel::FlowPrognostication(
     return status;
   } else {
     // Unless we were stopped, ignore the status, which indicates a failure to
-    // reach |t_max|, and provide a short prognostication.
+    // reach `t_max`, and provide a short prognostication.
     return std::move(prognostication);
   }
 }
diff --git a/ksp_plugin/vessel.hpp b/ksp_plugin/vessel.hpp
index 40cf029b62..b672b22e87 100644
--- a/ksp_plugin/vessel.hpp
+++ b/ksp_plugin/vessel.hpp
@@ -71,13 +71,13 @@ using namespace principia::physics::_rotating_body;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// Represents a KSP |Vessel|.
+// Represents a KSP `Vessel`.
 class Vessel {
  public:
   using Manœuvres = std::vector<
       not_null<std::unique_ptr<Manœuvre<Barycentric, Navigation> const>>>;
 
-  // Constructs a vessel whose parent is initially |*parent|.
+  // Constructs a vessel whose parent is initially `*parent`.
   Vessel(GUID guid,
          std::string name,
          not_null<Celestial const*> parent,
@@ -109,22 +109,22 @@ class Vessel {
   virtual void set_parent(not_null<Celestial const*> parent);
 
   // Adds the given part to this vessel.  Note that this does not add the part
-  // to the set of kept parts, and that unless |KeepPart| is called, the part
-  // will be removed by the next call to |FreeParts|.
+  // to the set of kept parts, and that unless `KeepPart` is called, the part
+  // will be removed by the next call to `FreeParts`.
   virtual void AddPart(not_null<std::unique_ptr<Part>> part);
-  // Removes and returns the part with the given ID.  This may empty |parts_|,
+  // Removes and returns the part with the given ID.  This may empty `parts_`,
   // as happens when a vessel ceases to exist while loaded.  Note that in that
-  // case |FreeParts| must not be called.
+  // case `FreeParts` must not be called.
   virtual not_null<std::unique_ptr<Part>> ExtractPart(PartId id);
   // Prevents the part with the given ID from being removed in the next call to
-  // |FreeParts|.
+  // `FreeParts`.
   virtual void KeepPart(PartId id);
-  // Whether |KeepPart| was called with this |id| since the last call to
-  // |FreeParts|.
+  // Whether `KeepPart` was called with this `id` since the last call to
+  // `FreeParts`.
   virtual bool WillKeepPart(PartId id) const;
-  // Removes any part for which |KeepPart| has not been called since the last
-  // call to |FreeParts|.  Checks that there are still parts left after the
-  // removals; thus a call to |AddPart| must occur before |FreeParts| is first
+  // Removes any part for which `KeepPart` has not been called since the last
+  // call to `FreeParts`.  Checks that there are still parts left after the
+  // removals; thus a call to `AddPart` must occur before `FreeParts` is first
   // called.
   virtual void FreeParts();
 
@@ -137,8 +137,8 @@ class Vessel {
   virtual void DetectCollapsibilityChange();
 
   // If the trajectory is empty, appends a single point to it, computed as the
-  // barycentre of all parts.  |parts_| must not be empty.  After this call,
-  // |trajectory_| is never empty again and the psychohistory is usable.  Must
+  // barycentre of all parts.  `parts_` must not be empty.  After this call,
+  // `trajectory_` is never empty again and the psychohistory is usable.  Must
   // be called (at least once) after the creation of the vessel.
   virtual void CreateTrajectoryIfNeeded(Instant const& t);
 
@@ -148,12 +148,12 @@ class Vessel {
   virtual void DisableDownsampling();
 
   // Returns the part with the given ID.  Such a part must have been added using
-  // |AddPart|.
+  // `AddPart`.
   virtual not_null<Part*> part(PartId id) const;
 
-  // Calls |action| on one part.
+  // Calls `action` on one part.
   virtual void ForSomePart(std::function<void(Part&)> action) const;
-  // Calls |action| on all parts.
+  // Calls `action` on all parts.
   virtual void ForAllParts(std::function<void(Part&)> action) const;
 
   virtual DiscreteTrajectory<Barycentric> const& trajectory() const;
@@ -204,9 +204,9 @@ class Vessel {
   virtual bool UpdateFlightPlanFromOptimization();
 
   // Deserializes the flight plan if it is held lazily by this object.  Does
-  // nothing if there is no such flight plan.  If |has_flight_plan| returns
+  // nothing if there is no such flight plan.  If `has_flight_plan` returns
   // true, calling this method ensures that the flight plan may later be
-  // accessed by |flight_plan|.  This method is idempotent.
+  // accessed by `flight_plan`.  This method is idempotent.
   void ReadFlightPlanFromMessage();
 
   // Extends the history and psychohistory of this vessel by computing the
@@ -215,16 +215,16 @@ class Vessel {
   virtual void AdvanceTime();
 
   // Asks the reanimator thread to asynchronously reconstruct the past so that
-  // the |t_min()| of the vessel ultimately ends up at or before
-  // |desired_t_min|.
+  // the `t_min()` of the vessel ultimately ends up at or before
+  // `desired_t_min`.
   void RequestReanimation(Instant const& desired_t_min) EXCLUDES(lock_);
 
-  // Same as |RequestReanimation|, but synchronous.  This function blocks until
-  // the |t_min()| of the vessel is at or before |desired_t_min|.
+  // Same as `RequestReanimation`, but synchronous.  This function blocks until
+  // the `t_min()` of the vessel is at or before `desired_t_min`.
   void AwaitReanimation(Instant const& desired_t_min) EXCLUDES(lock_);
 
   // Creates a flight plan at the end of history using the given parameters;
-  // selects that flight plan, which is the last one in |flight_plans_|.
+  // selects that flight plan, which is the last one in `flight_plans_`.
   virtual void CreateFlightPlan(
       Instant const& final_time,
       Mass const& initial_mass,
@@ -233,7 +233,7 @@ class Vessel {
       Ephemeris<Barycentric>::GeneralizedAdaptiveStepParameters const&
           flight_plan_generalized_adaptive_step_parameters);
 
-  // Requires |has_flight_plan()|.
+  // Requires `has_flight_plan()`.
   // Inserts a flight plan equivalent to the current one immediately before it.
   // The current flight plan remains selected.
   // Note that conceptually, this is equivalent to inserting an equivalent
@@ -243,17 +243,17 @@ class Vessel {
   virtual void DuplicateFlightPlan();
 
   // Deletes the currently selected flight plan.  Performs no action unless
-  // |has_flight_plan()|.
+  // `has_flight_plan()`.
   virtual void DeleteFlightPlan();
 
-  // Requires |has_flight_plan()|.
-  // If |history_->back().time| lies within a planned manœuvre, UNAVAILABLE is
+  // Requires `has_flight_plan()`.
+  // If `history_->back().time` lies within a planned manœuvre, UNAVAILABLE is
   // returned.
-  // Otherwise, deletes |flight_plan_| and recreates it from the current
-  // |history_| and the given |initial_mass|, re-adding any future manœuvres.
+  // Otherwise, deletes `flight_plan_` and recreates it from the current
+  // `history_` and the given `initial_mass`, re-adding any future manœuvres.
   // Past manœuvres are discarded, under the assumption that they have been
   // performed.
-  // If |history_->back().time| is greater than the current desired final time,
+  // If `history_->back().time` is greater than the current desired final time,
   // the flight plan length is kept; otherwise, the desired final time is kept.
   absl::Status RebaseFlightPlan(Mass const& initial_mass);
 
@@ -263,7 +263,7 @@ class Vessel {
   virtual void RefreshPrediction();
 
   // Same as above, but when this call returns the prediction is guaranteed to
-  // have a last time at or before |time|.
+  // have a last time at or before `time`.
   virtual void RefreshPrediction(Instant const& time);
 
   // Stop the asynchronous prognosticator as soon as convenient.
@@ -281,7 +281,7 @@ class Vessel {
   double progress_of_orbit_analysis() const;
 
   // Prepares the last completed analysis so that will be returned by
-  // |orbit_analysis|.
+  // `orbit_analysis`.
   // TODO(phl): This API is weird.  Why does the caller need a 2-step dance?
   void RefreshOrbitAnalysis();
 
@@ -291,7 +291,7 @@ class Vessel {
   // Returns "vessel_name (GUID)".
   std::string ShortDebugString() const;
 
-  // The vessel must satisfy |is_initialized()|.
+  // The vessel must satisfy `is_initialized()`.
   virtual void WriteToMessage(not_null<serialization::Vessel*> message,
                               PileUp::SerializationIndexForPileUp const&
                                   serialization_index_for_pile_up) const;
@@ -335,7 +335,7 @@ class Vessel {
   using LazilyDeserializedFlightPlan =
       std::variant<OptimizableFlightPlan, serialization::FlightPlan>;
 
-  // Return functions that can be passed to a |Checkpointer| to write this
+  // Return functions that can be passed to a `Checkpointer` to write this
   // vessel to a checkpoint or read it back.
   Checkpointer<serialization::Vessel>::Writer
   MakeCheckpointerWriter();
@@ -344,36 +344,36 @@ class Vessel {
 
   absl::Status Reanimate(Instant const desired_t_min) EXCLUDES(lock_);
 
-  // |t_initial| is the time of the checkpoint, which is the end of the non-
-  // collapsible segment.  |t_final| is the start of the trajectory or of the
+  // `t_initial` is the time of the checkpoint, which is the end of the non-
+  // collapsible segment.  `t_final` is the start of the trajectory or of the
   // next reanimated segment.  Returns the start of this reanimated segment,
-  // which will be the |t_final| of the next iteration.
+  // which will be the `t_final` of the next iteration.
   absl::StatusOr<Instant> ReanimateOneCheckpoint(
       serialization::Vessel::Checkpoint const& message,
       Instant const& t_initial,
       Instant const& t_final) EXCLUDES(lock_);
 
   // Merges any reanimated trajectories found in the queue and returns true if
-  // the reanimation reached |desired_t_min|, or if the vessel is fully
+  // the reanimation reached `desired_t_min`, or if the vessel is fully
   // reanimated.
   bool DesiredTMinReachedOrFullyReanimated(Instant const& desired_t_min)
       SHARED_LOCKS_REQUIRED(lock_);
 
-  // Runs the integrator to compute the |prognostication_| based on the given
+  // Runs the integrator to compute the `prognostication_` based on the given
   // parameters.
   absl::StatusOr<DiscreteTrajectory<Barycentric>>
   FlowPrognostication(PrognosticatorParameters prognosticator_parameters);
 
-  // Appends to |trajectory_| the centre of mass of the trajectories of the
-  // parts denoted by |part_trajectory_begin| and |part_trajectory_end|.  Only
-  // the points that are strictly after the start of the |segment| are used.
+  // Appends to `trajectory_` the centre of mass of the trajectories of the
+  // parts denoted by `part_trajectory_begin` and `part_trajectory_end`.  Only
+  // the points that are strictly after the start of the `segment` are used.
   void AppendToVesselTrajectory(
       TrajectoryIterator part_trajectory_begin,
       TrajectoryIterator part_trajectory_end,
       DiscreteTrajectorySegment<Barycentric> const& segment);
 
-  // Attaches the given |trajectory| to the end of the |psychohistory_| to
-  // become the new |prediction_|.  If |prediction_| is not null, it is deleted.
+  // Attaches the given `trajectory` to the end of the `psychohistory_` to
+  // become the new `prediction_`.  If `prediction_` is not null, it is deleted.
   void AttachPrediction(DiscreteTrajectory<Barycentric>&& trajectory);
 
   // A vessel is collapsible if it is alone in its pile-up and is in inertial
@@ -412,7 +412,7 @@ class Vessel {
   // The vessel trajectory is made of a number of history segments ending at the
   // backstory and (most of the time) the psychohistory and prediction.  The
   // prediction is periodically recomputed by the prognosticator.  Only grows
-  // "backwards" under |lock_|.
+  // "backwards" under `lock_`.
   DiscreteTrajectory<Barycentric> trajectory_;
 
   not_null<std::unique_ptr<Checkpointer<serialization::Vessel>>> checkpointer_;
@@ -425,7 +425,7 @@ class Vessel {
   RecurringThread<Instant> reanimator_;
   Clientele<Instant> reanimator_clientele_;
 
-  // Parameter passed to the last call to |RequestReanimation|, if any.
+  // Parameter passed to the last call to `RequestReanimation`, if any.
   std::optional<Instant> last_desired_t_min_;
 
   // The trajectories that have been reanimated are put in this queue by
@@ -433,13 +433,13 @@ class Vessel {
   std::queue<DiscreteTrajectory<Barycentric>> reanimated_trajectories_
       GUARDED_BY(lock_);
 
-  // The last (most recent) segment of the |history_| prior to the
-  // |psychohistory_|.  May be identical to |history_|.  Always identical to
-  // |std::prev(psychohistory_)|.
+  // The last (most recent) segment of the `history_` prior to the
+  // `psychohistory_`.  May be identical to `history_`.  Always identical to
+  // `std::prev(psychohistory_)`.
   DiscreteTrajectorySegmentIterator<Barycentric> backstory_;
 
-  // The |psychohistory_| is the segment following the |backstory_| and the
-  // |prediction_| is the segment following the |psychohistory_|.
+  // The `psychohistory_` is the segment following the `backstory_` and the
+  // `prediction_` is the segment following the `psychohistory_`.
   DiscreteTrajectorySegmentIterator<Barycentric> psychohistory_;
   DiscreteTrajectorySegmentIterator<Barycentric> prediction_;
 
diff --git a/ksp_plugin_adapter/boxed.cs b/ksp_plugin_adapter/boxed.cs
index 0062010778..a68357e3a3 100644
--- a/ksp_plugin_adapter/boxed.cs
+++ b/ksp_plugin_adapter/boxed.cs
@@ -3,7 +3,7 @@ namespace ksp_plugin_adapter {
 
 // Strongly-typed boxing.  This is used for marshaling optional parameters,
 // since custom marshalers are only allowed on classes, strings, arrays, and
-// boxed value types, so that |T?| cannot be marshaled, and |object| is not
+// boxed value types, so that `T?` cannot be marshaled, and `object` is not
 // statically typed.
 internal class Boxed<T> where T : struct {
   public T all { get; }
@@ -13,7 +13,7 @@ protected Boxed(T all) {
   }
 }
 
-// The |MarshalAsAttribute| does not support marshaling of generic types.
+// The `MarshalAsAttribute` does not support marshaling of generic types.
 internal class BoxedDouble : Boxed<double> {
   public static implicit operator BoxedDouble(double all) {
     return new BoxedDouble(all);
diff --git a/ksp_plugin_adapter/burn_editor.cs b/ksp_plugin_adapter/burn_editor.cs
index d674220065..99acb89f1a 100644
--- a/ksp_plugin_adapter/burn_editor.cs
+++ b/ksp_plugin_adapter/burn_editor.cs
@@ -96,7 +96,7 @@ public enum Event {
     Maximized,
   }
 
-  // Renders the |BurnEditor|.  Returns |Changed| if and only if the settings
+  // Renders the `BurnEditor`.  Returns `Changed` if and only if the settings
   // were changed.
   public Event Render(
       string header,
@@ -134,7 +134,7 @@ public Event Render(
       return Event.None;
     }
     using (new UnityEngine.GUILayout.VerticalScope()) {
-      // When we are first rendered, the |initial_mass_in_tonnes_| will just have
+      // When we are first rendered, the `initial_mass_in_tonnes_` will just have
       // been set.  If we have fallen back to instant impulse, we should use this
       // mass to set the thrust.
       if (first_time_rendering_) {
@@ -462,9 +462,9 @@ private string FormatΔvComponent(double metres_per_second) {
   private void UseTheForceLuke() {
     // The burn can last at most (9.80665 / scale) s.
     const double scale = 1;
-    // This, together with |scale = 1|, ensures that, when |initial_time| is
-    // less than 2 ** 32 s, |Δv(initial_time + duration)| does not overflow if
-    // Δv is less than 100 km/s, and that |initial_time + duration| does not
+    // This, together with `scale = 1`, ensures that, when `initial_time` is
+    // less than 2 ** 32 s, `Δv(initial_time + duration)` does not overflow if
+    // Δv is less than 100 km/s, and that `initial_time + duration` does not
     // fully cancel if Δv is more than 1 mm/s.
     // TODO(egg): Before the C* release, add a persisted flag to indicate to the
     // user that we are not using the craft's engines (we can also use that
diff --git a/ksp_plugin_adapter/config_node_extensions.cs b/ksp_plugin_adapter/config_node_extensions.cs
index 9aa1c4ed98..0030432ede 100644
--- a/ksp_plugin_adapter/config_node_extensions.cs
+++ b/ksp_plugin_adapter/config_node_extensions.cs
@@ -7,13 +7,13 @@ namespace ksp_plugin_adapter {
 // The Principia config nodes correspond to protocol buffers declared in
 // astronomy.proto.  The scalar (string or double) protobuf fields are string
 // values in a config node, the message fields are config nodes.
-// The |GetUniqueValue|, |GetUniqueNode| extension methods correspond to
+// The `GetUniqueValue`, `GetUniqueNode` extension methods correspond to
 // required fields.
-// The |GetAtMostOneValue|, |GetAtMostNode| extension methods correspond to
+// The `GetAtMostOneValue`, `GetAtMostNode` extension methods correspond to
 // optional fields.  Note that they are also used when a KSP-side default is
 // provided for a required field, e.g. using the stock values as defaults for
 // gravity models.
-// The KSP |GetValues|, |GetNodes| methods should be used directly for repeated
+// The KSP `GetValues`, `GetNodes` methods should be used directly for repeated
 // fields.
 internal static class ConfigNodeExtensions {
   public static ConfigNode GetAtMostOneNode(this ConfigNode node, string name) {
diff --git a/ksp_plugin_adapter/config_node_parsers.cs b/ksp_plugin_adapter/config_node_parsers.cs
index c6f4f9b94d..7d93804561 100644
--- a/ksp_plugin_adapter/config_node_parsers.cs
+++ b/ksp_plugin_adapter/config_node_parsers.cs
@@ -79,8 +79,8 @@ public static BodyParameters NewKeplerianBodyParameters(CelestialBody body,
         // than the y axis as is the case for Earth, so the right
         // ascension is -90 deg.
         // Note that once we set the positions and orientations of everything,
-        // that original x axis will become the y axis when |body| is the main
-        // body, and the |initialRotation| will be correspondingly increased by
+        // that original x axis will become the y axis when `body` is the main
+        // body, and the `initialRotation` will be correspondingly increased by
         // 90°.
         reference_instant       =
             node?.GetAtMostOneValue("reference_instant") ?? "JD2451545.0",
diff --git a/ksp_plugin_adapter/differential_slider.cs b/ksp_plugin_adapter/differential_slider.cs
index 7f9269f0da..57056ddb09 100644
--- a/ksp_plugin_adapter/differential_slider.cs
+++ b/ksp_plugin_adapter/differential_slider.cs
@@ -9,7 +9,7 @@ internal class DifferentialSlider : ScalingRenderer {
 
   public delegate bool ValueParser(string s, out double value);
 
-  // Rates are in units of |value| per real-time second.
+  // Rates are in units of `value` per real-time second.
   public DifferentialSlider(string label,
                             string unit,
                             double log10_lower_rate,
@@ -91,7 +91,7 @@ public void ResetValue(double new_value) {
     value = new_value;
   }
 
-  // Renders the |DifferentialSlider|.  Returns true if and only if |value|
+  // Renders the `DifferentialSlider`.  Returns true if and only if `value`
   // changed.
   public bool Render(bool enabled) {
     bool value_changed = false;
@@ -121,7 +121,7 @@ public bool Render(bool enabled) {
         bool text_field_has_focus =
             UnityEngine.GUI.GetNameOfFocusedControl() == text_field_name;
 
-        // Use up the vertical arrow keys before the |TextField| does (it
+        // Use up the vertical arrow keys before the `TextField` does (it
         // interprets up as home and down as end).
         bool event_was_arrow_key = false;
         if (text_field_has_focus &&
@@ -307,9 +307,9 @@ private double GetIncrement(bool event_was_arrow_key) {
     return increment;
   }
 
-  // If |formatted_value_[digit_index]| is a decimal place, returns true and
-  // sets |increment| to the value of a unit in that place.  Otherwise, returns
-  // false, setting |increment| to 0.
+  // If `formatted_value_[digit_index]` is a decimal place, returns true and
+  // sets `increment` to the value of a unit in that place.  Otherwise, returns
+  // false, setting `increment` to 0.
   private bool CanIncrementAt(int digit_index, out double increment) {
     increment = 0;
     // Cannot increment an ill-formed value.
@@ -373,8 +373,8 @@ private bool CanIncrementAt(int digit_index, out double increment) {
   private string formatted_value_;
   private readonly UnityEngine.TextAnchor alignment_;
 
-  // Represents a possible adjustment of the digit at |index| in
-  // |formatted_value_|.  The unit in that place is |increment|.
+  // Represents a possible adjustment of the digit at `index` in
+  // `formatted_value_`.  The unit in that place is `increment`.
   private struct DigitAdjustment {
     public DigitAdjustment(int index, double increment) {
       this.index = index;
diff --git a/ksp_plugin_adapter/flight_planner.cs b/ksp_plugin_adapter/flight_planner.cs
index f565f17b1d..5f2f7a656e 100644
--- a/ksp_plugin_adapter/flight_planner.cs
+++ b/ksp_plugin_adapter/flight_planner.cs
@@ -182,7 +182,7 @@ private void UpdateVesselAndBurnEditors() {
         for (int i = 0;
              i < plugin.FlightPlanNumberOfManoeuvres(vessel_guid);
              ++i) {
-          // Dummy initial time, we call |Reset| immediately afterwards.
+          // Dummy initial time, we call `Reset` immediately afterwards.
           burn_editors_.Add(new BurnEditor(adapter_,
                                            predicted_vessel,
                                            initial_time      : 0,
@@ -226,7 +226,7 @@ private void RenderFlightPlan(string vessel_guid) {
     using (new UnityEngine.GUILayout.VerticalScope()) {
       // A change of anomalous status "tickles" the flight plan.  Note that the
       // order of the terms in the || below matters, we always want to render
-      // the |final_time_|.
+      // the `final_time_`.
       if (final_time_.Render(enabled : true) || must_tickle_) {
         must_tickle_ = false;
         var status =
diff --git a/ksp_plugin_adapter/ksp_plugin_adapter.cs b/ksp_plugin_adapter/ksp_plugin_adapter.cs
index 9062368778..1605b0958b 100644
--- a/ksp_plugin_adapter/ksp_plugin_adapter.cs
+++ b/ksp_plugin_adapter/ksp_plugin_adapter.cs
@@ -216,14 +216,14 @@ private readonly Dictionary<Vessel, Vector3d>
 
   // Work around the launch backflip issue encountered while releasing
   // Frobenius.
-  // The issue is that the position of a  |ForceHolder| collected in
-  // |FashionablyLate| or constructed in |JaiFailliAttendre| is made invalid by
-  // changes to world coordinates in |FloatingOrigin| by the time it is used in
-  // |WaitForFixedUpdate|.
+  // The issue is that the position of a  `ForceHolder` collected in
+  // `FashionablyLate` or constructed in `JaiFailliAttendre` is made invalid by
+  // changes to world coordinates in `FloatingOrigin` by the time it is used in
+  // `WaitForFixedUpdate`.
   // TODO(egg): This should be cleaned up a bit, e.g., by making the plugin and
-  // interface take the |World| lever arm directly, since the lever arm is what
-  // we use in |principia::ksp_plugin::Part|, and it is what we compute below:
-  // this would obviate the need to keep track of the |Part| and to adjust its
+  // interface take the `World` lever arm directly, since the lever arm is what
+  // we use in `principia::ksp_plugin::Part`, and it is what we compute below:
+  // this would obviate the need to keep track of the `Part` and to adjust its
   // position.
   class PartCentredForceHolder {
     public static PartCentredForceHolder FromPartForceHolder(
@@ -415,7 +415,7 @@ private string TargetVesselGuid() {
 
   private delegate void VesselProcessor(Vessel vessel);
 
-  // Applies |process_body| to all bodies but the sun in the tree of celestial
+  // Applies `process_body` to all bodies but the sun in the tree of celestial
   // bodies, in topological order.
   private void ApplyToBodyTree(BodyProcessor process_body) {
     // Tree traversal (DFS, not that it matters).
@@ -433,7 +433,7 @@ private void ApplyToBodyTree(BodyProcessor process_body) {
   }
 
   private void ApplyToVesselsOnRails(VesselProcessor process_vessel) {
-    // |process_vessels| may touch |Transform|s, so disable syncing.
+    // `process_vessels` may touch `Transform`s, so disable syncing.
     UnityEngine.Physics.autoSyncTransforms = false;
     foreach (Vessel vessel in FlightGlobals.Vessels.Where(
         is_manageable_on_rails)) {
@@ -697,7 +697,7 @@ private void OverrideRSASTarget(FlightCtrlState state) {
     reset_rsas_target_ = false;
   }
 
-  // Returns false and nulls |texture| if the file does not exist.
+  // Returns false and nulls `texture` if the file does not exist.
   public static bool LoadTextureIfExists(out UnityEngine.Texture texture,
                                          string path) {
     string full_path =
@@ -763,10 +763,10 @@ public static void ValidateCelestialTerrain(CelestialBody centre,
 
   #region ScenarioModule lifecycle
 
-  // These functions override virtual ones from |ScenarioModule|, but it seems
+  // These functions override virtual ones from `ScenarioModule`, but it seems
   // that they're actually called by reflection, so that bad things happen
-  // if you don't have, e.g., a function called |OnAwake()| that calls
-  // |base.OnAwake()|.  It doesn't matter whether the functions are public or
+  // if you don't have, e.g., a function called `OnAwake()` that calls
+  // `base.OnAwake()`.  It doesn't matter whether the functions are public or
   // private, overriding or hiding though.
 
   public override void OnAwake() {
@@ -1128,11 +1128,11 @@ private void RenderNavballAndAccessories() {
               break;
             // NOTE(egg): For reasons that are unlikely to become clear again,
             // the button labeled with the radial in icon sets the autopilot
-            // mode to |RadialOut|, and vice-versa.  As a result, we must set
+            // mode to `RadialOut`, and vice-versa.  As a result, we must set
             // the target to the outwards radial (negative normal) vector if the
-            // mode is |RadialIn|.  Contrast with the navball vectors above,
+            // mode is `RadialIn`.  Contrast with the navball vectors above,
             // which do not exhibit this inconsistency (thus where
-            // |radialInVector| is set to |radial|).
+            // `radialInVector` is set to `radial`).
             case VesselAutopilot.AutopilotMode.RadialIn:
               rsas_target_ = -radial;
               break;
@@ -1182,7 +1182,7 @@ private void FixedUpdate() {
             vessel.rootPart.rb.angularVelocity);
       }
 
-      // TODO(egg): Set the degrees of freedom of the origin of |World| (by
+      // TODO(egg): Set the degrees of freedom of the origin of `World` (by
       // toying with Krakensbane and FloatingOrigin) here.
 
       // Now we let the game and Unity do their thing.  Among other things,
@@ -1238,7 +1238,7 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
         yield break;
       }
 
-      // We are going to touch plenty of |Transform|s, so we will prevent
+      // We are going to touch plenty of `Transform`s, so we will prevent
       // Unity from syncing with the physics system all the time.
       UnityEngine.Physics.autoSyncTransforms = false;
 
@@ -1252,7 +1252,7 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
       };
 
       // NOTE(egg): Inserting vessels and parts has to occur in
-      // |WaitForFixedUpdate|, since some may be destroyed (by collisions) during
+      // `WaitForFixedUpdate`, since some may be destroyed (by collisions) during
       // the physics step.  See also #1281.
       foreach (Vessel vessel in FlightGlobals.Vessels) {
         int main_body_index = vessel.mainBody.flightGlobalsIndex;
@@ -1295,8 +1295,8 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
             // In the first few frames after spawning a Kerbal, its physicsMass is
             // 0; we use its rb.mass instead.
             // NOTE(egg): the physics engine does not move the celestials, so it
-            // is fine to use |main_body_degrees_of_freedom| here rather than to
-            // store it during |FixedUpdate| or one of its timings.
+            // is fine to use `main_body_degrees_of_freedom` here rather than to
+            // store it during `FixedUpdate` or one of its timings.
             plugin_.InsertOrKeepLoadedPart(
                 part_id,
                 part.name,
@@ -1374,7 +1374,7 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
       // The collisions are reported by the
       // CollisionReporter.OnCollisionEnter|Stay events, which occurred while we
       // yielded.
-      // Here, the |CollisionReporter.collisions| are the collisions that occurred
+      // Here, the `CollisionReporter.collisions` are the collisions that occurred
       // in the physics simulation.
       foreach (Vessel vessel1 in FlightGlobals.Vessels.Where(
                    v => !v.packed && is_manageable(v))) {
@@ -1411,8 +1411,8 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
             var collision_reporter =
                 part1.gameObject.GetComponent<CollisionReporter>();
             if (collision_reporter == null) {
-              // This would only happen if |part1| had been added after
-              // |BetterLateThanNever|, but we never know what the game will throw
+              // This would only happen if `part1` had been added after
+              // `BetterLateThanNever`, but we never know what the game will throw
               // at us.
               continue;
             }
@@ -1420,7 +1420,7 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
               var collider = collision.collider;
               if (collider == null) {
                 // This happens, albeit quite rarely, see #1447.  When it happens,
-                // the null collider remains in |currentCollisions| until the next
+                // the null collider remains in `currentCollisions` until the next
                 // scene change, so we do not log, otherwise we would spam.
                 continue;
               }
@@ -1437,7 +1437,7 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
                 // point in reporting this collision; this also causes issues
                 // where disappearing kerbals collide with themselves.
                 // NOTE(egg): It is unclear whether this is needed now that we
-                // have the |CollisionReporter|.
+                // have the `CollisionReporter`.
                 continue;
               }
               if (part1.State == PartStates.DEAD ||
@@ -1447,7 +1447,7 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
               if (vessel2 != null) {
                 if (is_unready_kerbal(vessel2)) {
                   // A Kerbal that just started an EVA and is not ready yet.  If
-                  // we let it collide with |vessel1|, it will cause that vessel
+                  // we let it collide with `vessel1`, it will cause that vessel
                   // to become unmanageable and be removed from the plugin.  Of
                   // course, the vessel will come back once the Kerbal is ready,
                   // but at that point we'll have to trust the position given by
@@ -1558,7 +1558,7 @@ private System.Collections.IEnumerator WaitedForFixedUpdate() {
             // TODO(egg): use the centre of mass.  Here it's a bit tedious, some
             // transform nonsense must probably be done.
             // NOTE(egg): we must set the position and rotation of the
-            // |Transform| as well as that of the |RigidBody| because we are
+            // `Transform` as well as that of the `RigidBody` because we are
             // performing this correction after the physics step.
             // See https://github.com/mockingbirdnest/Principia/pull/1427,
             // https://github.com/mockingbirdnest/Principia/issues/1307#issuecomment-478337241.
@@ -1666,7 +1666,7 @@ private void Precalc() {
         continue;
       }
       vessel.precalc.enabled = true;
-      // In stock this is equivalent to |FixedUpdate()|.  With
+      // In stock this is equivalent to `FixedUpdate()`.  With
       // ModularFlightIntegrator's ModularVesselPrecalculate, which gets run
       // in TimingPre like us, this comes with a flag that ensures it only gets
       // run once.
@@ -1777,7 +1777,7 @@ select PartCentredForceHolder.
 
   private void JaiFailliAttendre() {
     // We fetch the forces from stock aerodynamics, which does not use
-    // |Part.AddForce| etc.
+    // `Part.AddForce` etc.
     if (PluginRunning()) {
       foreach (Vessel vessel in FlightGlobals.Vessels.Where(
           v => is_manageable(v) && !v.packed)) {
@@ -1823,12 +1823,12 @@ private void JaiFailliAttendre() {
                   });
           }
 
-          // KSP sets |part.rb.angularDrag| and lets Unity/PhysX compute a
+          // KSP sets `part.rb.angularDrag` and lets Unity/PhysX compute a
           // dampening torque.  However, it doesn't tell us about it so we end
           // up with uncontrolled oscillations.  Therefore, we must create that
           // torque out of thin air here.  Note that in FAR
-          // |part.rb.angularDrag| is 0 and we are properly given the torque
-          // through |Part.AddTorque| so this code has no effect.  See #3697 and
+          // `part.rb.angularDrag` is 0 and we are properly given the torque
+          // through `Part.AddTorque` so this code has no effect.  See #3697 and
           // https://documentation.help/NVIDIA-PhysX-SDK-Guide/RigidDynamics.html#damping.
           var drag_torque = -part.rb.angularDrag * part.rb.angularVelocity;
           if (drag_torque != UnityEngine.Vector3.zero) {
@@ -1884,7 +1884,7 @@ private void BetterLateThanNever() {
   private void BetterLateThanNeverLateUpdate() {
     // While we draw the trajectories directly (and thus do so after everything
     // else has been rendered), we rely on the game to render its map nodes.
-    // Since the screen position is determined in |MapNode.NodeUpdate|, it must
+    // Since the screen position is determined in `MapNode.NodeUpdate`, it must
     // be called before rendering occurs, but after the cameras have moved;
     // otherwise, the map nodes will lag behind when the camera is moved.
     // The only timing that satisfies these constraints is BetterLateThanNever
@@ -1905,7 +1905,7 @@ private void SetBodyFrames() {
       ApplyToBodyTree(body => UpdateBody(body, Planetarium.GetUniversalTime()));
 
       foreach (var body in FlightGlobals.Bodies) {
-        // TODO(egg): I have no idea why this |swizzle| thing makes things work.
+        // TODO(egg): I have no idea why this `swizzle` thing makes things work.
         // This probably really means something in terms of frames that should
         // be done in the C++ instead---once I figure out what it is.
         var swizzly_body_world_to_world =
@@ -2769,10 +2769,10 @@ private void ResetPlugin() {
         if (name_to_gravity_model == null) {
           Log.Fatal("Cartesian config without gravity models");
         }
-        // Note that |game_epoch| is not in the astronomy proto, as it is
-        // KSP-specific: it is the |Instant| corresponding to KSP's
+        // Note that `game_epoch` is not in the astronomy proto, as it is
+        // KSP-specific: it is the `Instant` corresponding to KSP's
         // UniversalTime 0.  It is passed as an argument to
-        // |generate_configuration|.
+        // `generate_configuration`.
         plugin_ = Interface.NewPlugin(
             initial_state.GetUniqueValue("game_epoch"),
             initial_state.GetUniqueValue("solar_system_epoch"),
@@ -2816,7 +2816,7 @@ private void ResetPlugin() {
         plugin_.EndInitialization();
       } else {
         // We create the plugin at J2000 (a.k.a. Instant{}), rather than
-        // |Planetarium.GetUniversalTime()|, in order to get a deterministic
+        // `Planetarium.GetUniversalTime()`, in order to get a deterministic
         // initial state.
         plugin_ = Interface.NewPlugin(game_epoch: "JD2451545",
                                       solar_system_epoch: "JD2451545",
diff --git a/ksp_plugin_adapter/loader.cs b/ksp_plugin_adapter/loader.cs
index 1b7fb92a4d..da4397233e 100644
--- a/ksp_plugin_adapter/loader.cs
+++ b/ksp_plugin_adapter/loader.cs
@@ -31,8 +31,8 @@ internal static string LoadPrincipiaDllAndInitGoogleLogging() {
         possible_dll_paths = new []
             { @"GameData\Principia\x64\" + dll_filename };
         break;
-      // Both Mac and Linux report |PlatformID.Unix|, so we treat them together
-      // (we probably don't actually encounter |PlatformID.MacOSX|).
+      // Both Mac and Linux report `PlatformID.Unix`, so we treat them together
+      // (we probably don't actually encounter `PlatformID.MacOSX`).
       case PlatformID.Unix:
       case PlatformID.MacOSX:
         dll_filename = "principia.so";
diff --git a/ksp_plugin_adapter/lru_cache.cs b/ksp_plugin_adapter/lru_cache.cs
index e603a7f216..673bc31672 100644
--- a/ksp_plugin_adapter/lru_cache.cs
+++ b/ksp_plugin_adapter/lru_cache.cs
@@ -15,7 +15,7 @@ public string Get(string name, Func<string> compute_value) {
   public string Get(string name, string[] args, Func<string> compute_value) {
     string key = MakeKey(name, args);
     if (cache_.TryGetValue(key, out Entry entry)) {
-      // Note that we must remove the entry from |cache_by_time_| before
+      // Note that we must remove the entry from `cache_by_time_` before
       // updating the timestamp, since the timestamp is the key there.
       cache_by_time_.Remove(entry);
       entry.timestamp =
diff --git a/ksp_plugin_adapter/main_window.cs b/ksp_plugin_adapter/main_window.cs
index 36a6acb8fe..0f986a5b6d 100644
--- a/ksp_plugin_adapter/main_window.cs
+++ b/ksp_plugin_adapter/main_window.cs
@@ -549,7 +549,7 @@ private void RenderToggleableSection(string name,
       {1e-3, 1e-2, 1e-1, 1e0, 1e1, 1e2, 1e3, 1e4};
   private static readonly string[] prediction_length_tolerance_names_ =
       {"1 mm", "1 cm", "10 cm", "1 m", "10 m", "100 m", "1 km", "10 km"};
-  // Keep this consistent with |max_steps_in_prediction| in |plugin.cpp|.
+  // Keep this consistent with `max_steps_in_prediction` in `plugin.cpp`.
   private static readonly long[] prediction_steps_ = {
       1 << 2, 1 << 4, 1 << 6, 1 << 8, 1 << 10, 1 << 12, 1 << 14, 1 << 16,
       1 << 18, 1 << 20, 1 << 22, 1 << 24
diff --git "a/ksp_plugin_adapter/man\305\223uvre_marker.cs" "b/ksp_plugin_adapter/man\305\223uvre_marker.cs"
index 210f7887eb..6bdb62f1c2 100644
--- "a/ksp_plugin_adapter/man\305\223uvre_marker.cs"
+++ "b/ksp_plugin_adapter/man\305\223uvre_marker.cs"
@@ -16,13 +16,13 @@ public static ManœuvreMarker Create(MainWindow main_window,
   public bool is_hovered { get; private set; } = false;
   public bool is_dragged { get; private set; } = false;
   public bool is_pinned { get; private set; } = false;
-  // Note that |is_hovered| is not a necessary condition for |is_interacting|:
+  // Note that `is_hovered` is not a necessary condition for `is_interacting`:
   // the cursor may move off the marker while still dragging.
   public bool is_interacting => is_hovered || is_dragged;
 
-  // As mouse events are sent before |Update|, we compute this state there.
-  // We clear it as late as possible, in |WaitForEndOfFrame|.
-  // In particular, the value is meaningful at |BetterLateThanNeverLateUpdate|,
+  // As mouse events are sent before `Update`, we compute this state there.
+  // We clear it as late as possible, in `WaitForEndOfFrame`.
+  // In particular, the value is meaningful at `BetterLateThanNeverLateUpdate`,
   // during which it is consumed by node markers.
   public static bool has_interacting_marker { get; private set; }
 
@@ -62,7 +62,7 @@ public void Awake() {
     Disable();
   }
 
-  // Call on each frame (at or later than |Update|) to set the state of the marker.
+  // Call on each frame (at or later than `Update`) to set the state of the marker.
   public void Render(int index,
                      Vector3d world_position,
                      Vector3d initial_plotted_velocity,
@@ -94,7 +94,7 @@ public void Render(int index,
     UpdateCaption(screen_position);
 
     gameObject.SetActive(true);
-    // |UpdateCaption| will have updated its activity state appropriately.
+    // `UpdateCaption` will have updated its activity state appropriately.
   }
 
   // Disable this marker and reset its user-interaction state so that it is
@@ -138,7 +138,7 @@ private void UpdateCaption(Vector3d screen_position) {
     ui_position.y += caption_position_y_offset;
     caption_.transform.position = ui_position;
 
-    // Note that we check for |is_interacting| rather than |is_pinned|; this is
+    // Note that we check for `is_interacting` rather than `is_pinned`; this is
     // so that the brighter hover colour is applied in the 'hovered and pinned'
     // state.
     if (is_interacting) {
@@ -295,7 +295,7 @@ private static UnityEngine.Vector3 ScaledToFlattenedScreenPosition(
     return position;
   }
 
-  // From |MapNode.OnUpdatePositionToUI|.
+  // From `MapNode.OnUpdatePositionToUI`.
   private static (UnityEngine.Vector3 position, bool visible) ScaledToUIPosition(
     Vector3d scaled_position) {
       bool visible = false;
diff --git a/ksp_plugin_adapter/orbit_analyser.cs b/ksp_plugin_adapter/orbit_analyser.cs
index 0a5286f806..4a77cd5a75 100644
--- a/ksp_plugin_adapter/orbit_analyser.cs
+++ b/ksp_plugin_adapter/orbit_analyser.cs
@@ -6,7 +6,7 @@ namespace ksp_plugin_adapter {
 // Miscellaneous formatting utilities; these are extension methods to make null
 // handling easier, thanks to null-coalescing operators.
 internal static class Formatters {
-  // Formats |value| in "N<fractional_digits>" using the Principia culture.
+  // Formats `value` in "N<fractional_digits>" using the Principia culture.
   public static string FormatN(this double value, int fractional_digits) {
     return value.ToString($"N{fractional_digits}", Culture.culture);
   }
@@ -15,7 +15,7 @@ public static string FormatN(this int value, int fractional_digits) {
     return value.ToString($"N{fractional_digits}", Culture.culture);
   }
 
-  // Formats |value| (given in metres) in kilometres or metres.
+  // Formats `value` (given in metres) in kilometres or metres.
   // TODO(egg): think about the threshold for metres.
   public static string FormatAltitude(this double value) {
     return $"{(value / 1000).FormatN(0)} km";
@@ -34,8 +34,8 @@ public static string FormatInterval(this Interval interval) {
 
   // Displays an interval of lengths as midpoint±half-width, in km if the
   // half-width is 100 m or more.  The midpoint is given with respect to
-  // |offset| (for instance, if |interval| is an interval of distances from the
-  // primary and |offset| is the radius of the primary, altitudes are shown).
+  // `offset` (for instance, if `interval` is an interval of distances from the
+  // primary and `offset` is the radius of the primary, altitudes are shown).
   public static string FormatLengthInterval(this Interval interval,
                                             double offset = 0) {
     double half_width = (interval.max - interval.min) / 2;
@@ -80,7 +80,7 @@ public static string FormatEquatorialAngle(this double angle,
     return $"{degrees}° ({kilometres} km)";
   }
 
-  // Similar to |FormatAngleInterval|, but annotated with the equivalent
+  // Similar to `FormatAngleInterval`, but annotated with the equivalent
   // of the half-width as a distance at the equator in parentheses.
   public static string FormatEquatorialAngleInterval(this Interval interval,
     CelestialBody primary) {
@@ -169,7 +169,7 @@ protected OrbitAnalyser(PrincipiaPluginAdapter adapter,
   protected abstract string ButtonText(string orbit_description);
   protected abstract string AnalysingText();
 
-  // Whether |RequestAnalysis()| needs to be called.
+  // Whether `RequestAnalysis()` needs to be called.
   protected abstract bool should_request_analysis { get; }
 
   public void RenderButton() {
diff --git a/ksp_plugin_adapter/planetarium_camera_adjuster.cs b/ksp_plugin_adapter/planetarium_camera_adjuster.cs
index 8c7125c181..61112efeb0 100644
--- a/ksp_plugin_adapter/planetarium_camera_adjuster.cs
+++ b/ksp_plugin_adapter/planetarium_camera_adjuster.cs
@@ -6,9 +6,9 @@
 namespace principia {
 namespace ksp_plugin_adapter {
 
-// Immediately after |PlanetariumCamera| (300).  In particular, before the next
-// one, |ScaledSpace| (500), which moves scaled space so that the camera is at
-// the origin.  If the adjustment is not performed before |ScaledSpace| runs,
+// Immediately after `PlanetariumCamera` (300).  In particular, before the next
+// one, `ScaledSpace` (500), which moves scaled space so that the camera is at
+// the origin.  If the adjustment is not performed before `ScaledSpace` runs,
 // EnvironmentalVisualEnhancements will draw clouds on an incorrect hemisphere
 // (not the camera-facing one).
 // Note that KSP provides no timing between 300 and 500, so we have to do this
diff --git a/ksp_plugin_adapter/plotter.cs b/ksp_plugin_adapter/plotter.cs
index 6908fa32de..f5659c60ab 100644
--- a/ksp_plugin_adapter/plotter.cs
+++ b/ksp_plugin_adapter/plotter.cs
@@ -163,7 +163,7 @@ private void PlotCelestialTrajectories(DisposablePlanetarium planetarium,
                             Planetarium.fetch.Sun, tan_angular_resolution);
   }
 
-  // Plots the trajectories of |root| and its natural satellites.
+  // Plots the trajectories of `root` and its natural satellites.
   private void PlotSubtreeTrajectories(DisposablePlanetarium planetarium,
                                        string main_vessel_guid,
                                        double history_length,
@@ -258,7 +258,7 @@ private void DrawLineMesh(UnityEngine.Mesh mesh,
     if (style == GLLines.Style.Faded) {
       for (int i = 0; i < vertex_count; ++i) {
         var faded_colour = colour;
-        // Fade from the opacity of |colour| (when i = 0) down to 20% of that
+        // Fade from the opacity of `colour` (when i = 0) down to 20% of that
         // opacity.
         faded_colour.a *= 1 - 0.8f * (i / (float)vertex_count);
         colours[i] = faded_colour;
diff --git a/ksp_plugin_adapter/reference_frame_selector.cs b/ksp_plugin_adapter/reference_frame_selector.cs
index 630135f716..e52b9090a7 100644
--- a/ksp_plugin_adapter/reference_frame_selector.cs
+++ b/ksp_plugin_adapter/reference_frame_selector.cs
@@ -116,8 +116,8 @@ public void UnsetTargetFrame() {
     });
   }
 
-  // Sets the |frame_type| to |BODY_SURFACE| and sets |selected_celestial| to
-  // the given |celestial|.
+  // Sets the `frame_type` to `BODY_SURFACE` and sets `selected_celestial` to
+  // the given `celestial`.
   public void SetToSurfaceFrameOf(CelestialBody celestial) {
     EffectChange(() => {
       frame_type = FrameType.BODY_SURFACE;
@@ -486,7 +486,7 @@ public ReferenceFrameParameters FrameParameters() {
       case FrameType.BODY_CENTRED_PARENT_DIRECTION:
         // We put the primary body as secondary, because the one we want fixed
         // is the secondary body (which means it has to be the primary in the
-        // terminology of |BodyCentredBodyDirection|).
+        // terminology of `BodyCentredBodyDirection`).
         return new ReferenceFrameParameters{
             Extension = frame_type,
             PrimaryIndices =
diff --git a/ksp_plugin_adapter/window_renderer.cs b/ksp_plugin_adapter/window_renderer.cs
index 12bc68b2a2..dd9f395102 100644
--- a/ksp_plugin_adapter/window_renderer.cs
+++ b/ksp_plugin_adapter/window_renderer.cs
@@ -132,7 +132,7 @@ public void RenderWindow() {
     }
     UnityEngine.GUI.skin = skin_;
     if (show_) {
-      // NOTE: Calling |Shrink| here (in a Layout, before drawing the window)
+      // NOTE: Calling `Shrink` here (in a Layout, before drawing the window)
       // satisfies the conditions noted in its doc comment and is safe.
       Shrink();
       rectangle_ = UnityEngine.GUILayout.Window(
@@ -146,7 +146,7 @@ public void RenderWindow() {
       // the centre of the screen.  This is tricky because we don't know its
       // width.  So we go through this method until the width has been
       // determined, and we update the window based on the width.  Note that
-      // |must_centre_| has to be persisted because there can be multiple
+      // `must_centre_` has to be persisted because there can be multiple
       // scene changes before a window is shown for the first time.  Also note
       // the conversion to float to avoid losing decimals and to avoid double
       // rounding.
@@ -221,7 +221,7 @@ public void ScheduleShrink() {
   }
 
   // NOTE(al2me6): Empirical observation led to the following conclusions:
-  // In each frame, |OnGUI| (from whence this method is ultimately called)
+  // In each frame, `OnGUI` (from whence this method is ultimately called)
   // is called at least twice, with the following order of event types:
   // 1. Layout
   // 2. For each interaction during that frame (e.g., mouse event):
@@ -230,7 +230,7 @@ public void ScheduleShrink() {
   // 3. Repaint
   // cf. <https://docs.unity3d.com/ScriptReference/Event.html>.
   // Furthermore, this function is not safe to call between the call to
-  // |GUILayout.Window| in the last Layout of the frame and the subsequent
+  // `GUILayout.Window` in the last Layout of the frame and the subsequent
   // Repaint; doing so may cause the window to become blank for one frame.
   private void Shrink() {
     if (shrink_scheduled_
diff --git a/ksp_plugin_test/fake_plugin.hpp b/ksp_plugin_test/fake_plugin.hpp
index 579a011005..e77e185067 100644
--- a/ksp_plugin_test/fake_plugin.hpp
+++ b/ksp_plugin_test/fake_plugin.hpp
@@ -25,12 +25,12 @@ using namespace principia::physics::_solar_system;
 
 class FakePlugin : public Plugin {
  public:
-  // Creates a test plugin with the bodies of the given |solar_system|.  The
+  // Creates a test plugin with the bodies of the given `solar_system`.  The
   // system must be the Sol system.
   explicit FakePlugin(SolarSystem<ICRS> const& solar_system);
 
   // Adds an unloaded vessel with a single part with the given osculating
-  // elements around the Earth at |CurrentTime()|.
+  // elements around the Earth at `CurrentTime()`.
   Vessel& AddVesselInEarthOrbit(GUID const& vessel_id,
                                 std::string const& vessel_name,
                                 PartId part_id,
diff --git a/ksp_plugin_test/flight_plan_test.cpp b/ksp_plugin_test/flight_plan_test.cpp
index ff0f95d480..fc6d3eb0fb 100644
--- a/ksp_plugin_test/flight_plan_test.cpp
+++ b/ksp_plugin_test/flight_plan_test.cpp
@@ -405,8 +405,8 @@ TEST_F(FlightPlanTest, SetAdaptiveStepParameter) {
   auto const generalized_adaptive_step_parameters =
       flight_plan_->generalized_adaptive_step_parameters();
 
-  // Reduce |max_steps|.  This causes many segments to become truncated so the
-  // call to |SetAdaptiveStepParameters| returns false and the flight plan is
+  // Reduce `max_steps`.  This causes many segments to become truncated so the
+  // call to `SetAdaptiveStepParameters` returns false and the flight plan is
   // unaffected.
   EXPECT_THAT(flight_plan_->SetAdaptiveStepParameters(
         Ephemeris<Barycentric>::AdaptiveStepParameters(
@@ -433,7 +433,7 @@ TEST_F(FlightPlanTest, SetAdaptiveStepParameter) {
   segment4 = flight_plan_->GetSegment(4);
   EXPECT_EQ(t0_ + 42 * Second, segment4->back().time);
 
-  // Increase |max_steps|.  It works.
+  // Increase `max_steps`.  It works.
   EXPECT_OK(flight_plan_->SetAdaptiveStepParameters(
       Ephemeris<Barycentric>::AdaptiveStepParameters(
           EmbeddedExplicitRungeKuttaNyströmIntegrator<
diff --git a/ksp_plugin_test/interface_flight_plan_test.cpp b/ksp_plugin_test/interface_flight_plan_test.cpp
index b210e845b1..3e498076bf 100644
--- a/ksp_plugin_test/interface_flight_plan_test.cpp
+++ b/ksp_plugin_test/interface_flight_plan_test.cpp
@@ -270,7 +270,7 @@ TEST_F(InterfaceFlightPlanTest, FlightPlan) {
   MockContinuousTrajectory<Barycentric> centre_trajectory;
   EXPECT_CALL(ephemeris, trajectory(check_not_null(&centre)))
       .WillOnce(Return(&centre_trajectory));
-  // Cannot use a mock here since we use |dynamic_cast| to find the type of the
+  // Cannot use a mock here since we use `dynamic_cast` to find the type of the
   // actual frame.
   BodyCentredNonRotatingReferenceFrame<Barycentric, Navigation> const* const
       navigation_manœuvre_frame =
diff --git a/ksp_plugin_test/orbit_analyser_test.cpp b/ksp_plugin_test/orbit_analyser_test.cpp
index b8b6ce7828..36541a88ba 100644
--- a/ksp_plugin_test/orbit_analyser_test.cpp
+++ b/ksp_plugin_test/orbit_analyser_test.cpp
@@ -134,7 +134,7 @@ TEST_F(OrbitAnalyserTest, TOPEXPoséidon) {
   while (analyser.progress_of_next_analysis() != 1) {
     absl::SleepFor(absl::Milliseconds(10));
   }
-  // Since |progress_of_next_analysis| only tracks the integration, not the
+  // Since `progress_of_next_analysis` only tracks the integration, not the
   // analysis, we have no guarantee that an analysis is available immediately.
   do {
     absl::SleepFor(absl::Milliseconds(10));
diff --git a/ksp_plugin_test/pile_up_test.cpp b/ksp_plugin_test/pile_up_test.cpp
index 2566a6b4e0..bc8fb65b36 100644
--- a/ksp_plugin_test/pile_up_test.cpp
+++ b/ksp_plugin_test/pile_up_test.cpp
@@ -182,7 +182,7 @@ class PileUpTest : public testing::Test {
                                         10.0 * Metre / Second,
                                         10.0 / 3.0 * Metre / Second}), 17)));
 
-    // Centre of mass of |p1_| and |p2_| in |Apparent|, in SI units:
+    // Centre of mass of `p1_` and `p2_` in `Apparent`, in SI units:
     //   {1 / 9, -1 / 3, -2 / 9} {10 / 9, -10 / 3, -20 / 9}
     DegreesOfFreedom<Apparent> const p1_dof(
         Apparent::origin +
@@ -269,7 +269,7 @@ class PileUpTest : public testing::Test {
   InertiaTensor<RigidPart> inertia_tensor1_;
   InertiaTensor<RigidPart> inertia_tensor2_;
 
-  // Centre of mass of |p1_| and |p2_| in |Barycentric|, in SI units:
+  // Centre of mass of `p1_` and `p2_` in `Barycentric`, in SI units:
   //   {13 / 3, 4, 11 / 3} {130 / 3, 40, 110 / 3}
   DegreesOfFreedom<Barycentric> const p1_dof_ = DegreesOfFreedom<Barycentric>(
       Barycentric::origin +
@@ -288,7 +288,7 @@ class PileUpTest : public testing::Test {
 
 #if 0
 
-// Exercises the entire lifecycle of a |PileUp| that is subject to an intrinsic
+// Exercises the entire lifecycle of a `PileUp` that is subject to an intrinsic
 // force.
 TEST_F(PileUpTest, LifecycleWithIntrinsicForce) {
   MockEphemeris<Barycentric> ephemeris;
@@ -589,7 +589,7 @@ TEST_F(PileUpTest, LifecycleWithoutIntrinsicForce) {
 TEST_F(PileUpTest, MidStepIntrinsicForce) {
   // An empty ephemeris; the parameters don't matter, since there are no bodies
   // to integrate.
-  // NOTE(egg): ... except we have to put a body because |Ephemeris| doesn't
+  // NOTE(egg): ... except we have to put a body because `Ephemeris` doesn't
   // want to be empty.  We put a tiny one very far.
   std::vector<not_null<std::unique_ptr<MassiveBody const>>> bodies;
   bodies.emplace_back(make_not_null_unique<MassiveBody>(1 * Kilogram));
diff --git a/ksp_plugin_test/plugin_integration_test.cpp b/ksp_plugin_test/plugin_integration_test.cpp
index e34ee4681f..7aa9a6f176 100644
--- a/ksp_plugin_test/plugin_integration_test.cpp
+++ b/ksp_plugin_test/plugin_integration_test.cpp
@@ -246,7 +246,7 @@ TEST_F(PluginIntegrationTest, BodyCentredNonrotatingNavigationIntegration) {
                                 SolarSystemFactory::Earth,
                                 /*loaded=*/false,
                                 inserted);
-    // We give the sun an arbitrary nonzero velocity in |World|.
+    // We give the sun an arbitrary nonzero velocity in `World`.
     Position<World> const sun_world_position =
         World::origin + Velocity<World>(
             { 0.1 * AstronomicalUnit / Hour,
@@ -356,7 +356,7 @@ TEST_F(PluginIntegrationTest, BarycentricRotatingNavigationIntegration) {
                               SolarSystemFactory::Earth,
                               /*loaded=*/false,
                               inserted);
-  // We give the sun an arbitrary nonzero velocity in |World|.
+  // We give the sun an arbitrary nonzero velocity in `World`.
   Position<World> const sun_world_position =
       World::origin + Velocity<World>(
           { 0.1 * AstronomicalUnit / Hour,
@@ -664,7 +664,7 @@ TEST_F(PluginIntegrationTest, PhysicsBubble) {
 
 // Checks that we correctly predict a full circular orbit around a massive body
 // with unit gravitational parameter at unit distance.  Since predictions are
-// only computed on |AdvanceTime()|, we advance time by a small amount.
+// only computed on `AdvanceTime()`, we advance time by a small amount.
 TEST_F(PluginIntegrationTest, Prediction) {
   Index const celestial = 0;
   Plugin plugin("JD2451545.0", "JD2451545.0", 0 * Radian);
diff --git a/ksp_plugin_test/plugin_test.cpp b/ksp_plugin_test/plugin_test.cpp
index 6ef57a2ae8..0a0ae2e4ce 100644
--- a/ksp_plugin_test/plugin_test.cpp
+++ b/ksp_plugin_test/plugin_test.cpp
@@ -146,8 +146,8 @@ class TestablePlugin : public Plugin {
                  std::string const& solar_system_epoch,
                  Angle const& planetarium_rotation)
       : Plugin(game_epoch, solar_system_epoch, planetarium_rotation),
-        // The |mock_ephemeris_| has to be created early so that we can write
-        // expectations before |EndInitialization| has been called.
+        // The `mock_ephemeris_` has to be created early so that we can write
+        // expectations before `EndInitialization` has been called.
         owned_mock_ephemeris_(
             std::make_unique<MockEphemeris<Barycentric>>()),
         mock_ephemeris_(owned_mock_ephemeris_.get()) {}
@@ -170,7 +170,7 @@ class TestablePlugin : public Plugin {
   }
 
   // We override this part of initialization in order to create a
-  // |MockEphemeris| rather than an |Ephemeris|.
+  // `MockEphemeris` rather than an `Ephemeris`.
   void EndInitialization() override {
     Plugin::EndInitialization();
     // Extend the continuous trajectories of the ephemeris.
@@ -181,14 +181,14 @@ class TestablePlugin : public Plugin {
               &*ephemeris_->trajectory(body));
       trajectories_.emplace(name_to_index_[body->name()], trajectory);
 
-      // Make sure that the |trajectory| member does the right thing.  Note that
+      // Make sure that the `trajectory` member does the right thing.  Note that
       // the implicit conversion doesn't work too well in the matcher.
       ON_CALL(*mock_ephemeris_, trajectory(body))
           .WillByDefault(Return(trajectory));
     }
 
     // Replace the ephemeris with our mock, but keep the real thing as it owns
-    // the bodies.  We squirelled away a pointer in |mock_ephemeris_|.
+    // the bodies.  We squirelled away a pointer in `mock_ephemeris_`.
     owned_real_ephemeris_ = std::move(ephemeris_);
     ephemeris_ = std::move(owned_mock_ephemeris_);
   }
@@ -248,8 +248,8 @@ class PluginTest : public testing::Test {
     }
   }
 
-  // The time of the |step|th history step of |plugin_|.  |HistoryTime(0)| is
-  // |initial_time_|.
+  // The time of the `step`th history step of `plugin_`.  `HistoryTime(0)` is
+  // `initial_time_`.
   Instant HistoryTime(Instant const time, int const step) {
     return time + step * plugin_->Δt();
   }
@@ -304,8 +304,8 @@ TEST_F(PluginTest, Serialization) {
   GUID const satellite = "satellite";
   PartId const part_id = 666;
 
-  // We need an actual |Plugin| here rather than a |TestablePlugin|, since
-  // that's what |ReadFromMessage| returns.
+  // We need an actual `Plugin` here rather than a `TestablePlugin`, since
+  // that's what `ReadFromMessage` returns.
   auto plugin = make_not_null_unique<Plugin>(
                     initial_time_,
                     initial_time_,
diff --git a/ksp_plugin_test/renderer_test.cpp b/ksp_plugin_test/renderer_test.cpp
index c3ac129c4e..828a3a5eea 100644
--- a/ksp_plugin_test/renderer_test.cpp
+++ b/ksp_plugin_test/renderer_test.cpp
@@ -163,7 +163,7 @@ TEST_F(RendererTest, RenderBarycentricTrajectoryInPlottingWithTargetVessel) {
           /*t2=*/t0_ + 10 * Second),
       /*to=*/trajectory_to_render);
 
-  // The prediction is shorter than the |trajectory_to_render|.
+  // The prediction is shorter than the `trajectory_to_render`.
   MockVessel vessel;
   DiscreteTrajectory<Barycentric> vessel_trajectory;
   AppendTrajectoryTimeline(
diff --git a/mathematica/local_error_analysis.hpp b/mathematica/local_error_analysis.hpp
index 271d1ec659..92aaaeb08b 100644
--- a/mathematica/local_error_analysis.hpp
+++ b/mathematica/local_error_analysis.hpp
@@ -25,7 +25,7 @@ using namespace principia::quantities::_quantities;
 using namespace principia::quantities::_si;
 
 // A utility to compute the local errors in the numerical integration of a
-// |solar_system| with a given |integrator| and |step|.
+// `solar_system` with a given `integrator` and `step`.
 template<typename Frame>
 class LocalErrorAnalyser {
  public:
@@ -35,9 +35,9 @@ class LocalErrorAnalyser {
           Ephemeris<Frame>::NewtonianMotionEquation> const& integrator,
       Time const& step);
 
-  // Computes the error over |granularity| between the main integration and a
-  // fine integration forked off the main one, for |duration| from the solar
-  // system epoch.  Writes the errors to a file with the given |path|.
+  // Computes the error over `granularity` between the main integration and a
+  // fine integration forked off the main one, for `duration` from the solar
+  // system epoch.  Writes the errors to a file with the given `path`.
   void WriteLocalErrors(
       std::filesystem::path const& path,
       FixedStepSizeIntegrator<typename
diff --git a/mathematica/logger.hpp b/mathematica/logger.hpp
index ffa8785af8..f729b1dd34 100644
--- a/mathematica/logger.hpp
+++ b/mathematica/logger.hpp
@@ -41,21 +41,21 @@ class Logger final {
   // Flushes the logger and (atomically) clears its contents.
   void FlushAndClear();
 
-  // Appends an element to the list of values for the List variable |name|.  The
-  // |args...| are passed verbatim to ToMathematica for stringification.  When
+  // Appends an element to the list of values for the List variable `name`.  The
+  // `args...` are passed verbatim to ToMathematica for stringification.  When
   // this object is destroyed, an assignment is generated for each of the
   // variables named in a call to Append.
   template<typename... Args>
   void Append(std::string const& name, Args... args);
 
-  // Sets an element as the single value for the variable |name|.  The
-  // |args...| are passed verbatim to ToMathematica for stringification.  When
+  // Sets an element as the single value for the variable `name`.  The
+  // `args...` are passed verbatim to ToMathematica for stringification.  When
   // this object is destroyed, an assignment is generated for each of the
   // variables named in a call to Set.
   template<typename... Args>
   void Set(std::string const& name, Args const&... args);
 
-  // When a logger is disabled, the calls to |Append| and |Set| have no effect.
+  // When a logger is disabled, the calls to `Append` and `Set` have no effect.
   // Loggers are enabled at construction.
   void Enable();
   void Disable();
@@ -64,9 +64,9 @@ class Logger final {
   // construction of each logger.  This makes it possible for distant code to
   // perform operations on the logger, e.g., to disable it or log client-
   // specific data.  The path passed to the callback is the path passed to the
-  // constructor (i.e., before any alteration performed by |make_unique|).  The
-  // |id| is the uniquely-generated id for the logger (if |make_unique| is true)
-  // or nullopt (if |make_unique| is false).
+  // constructor (i.e., before any alteration performed by `make_unique`).  The
+  // `id` is the uniquely-generated id for the logger (if `make_unique` is true)
+  // or nullopt (if `make_unique` is false).
   using ConstructionCallback =
       std::function<void(std::filesystem::path const&,
                          std::optional<std::uint64_t> id,
diff --git a/mathematica/logger_test.cpp b/mathematica/logger_test.cpp
index 51e60c52ee..5a7f9f2fb5 100644
--- a/mathematica/logger_test.cpp
+++ b/mathematica/logger_test.cpp
@@ -27,7 +27,7 @@ class LoggerTest : public ::testing::Test {
 };
 
 // On macOS, std::filesystem is broken (prior to Catalina).  On Ubuntu, the
-// introduction of |Flush| caused the test to fail because apparently the file
+// introduction of `Flush` caused the test to fail because apparently the file
 // is never written to.  We don't really care, we only use the logger on
 // Windows.
 #if PRINCIPIA_COMPILER_MSVC
diff --git a/mathematica/retrobop_dynamical_stability.hpp b/mathematica/retrobop_dynamical_stability.hpp
index 2e1eec9fa3..b2a45dcbfe 100644
--- a/mathematica/retrobop_dynamical_stability.hpp
+++ b/mathematica/retrobop_dynamical_stability.hpp
@@ -6,18 +6,18 @@ namespace _retrobop_dynamical_stability {
 namespace internal {
 
 // Generates data for plotting the positions of the Joolian system over 5 years.
-// See |AnalyseGlobalError| for a motivation for that figure.
+// See `AnalyseGlobalError` for a motivation for that figure.
 void PlotPredictableYears();
 
 // Generates data for apsis plots of the Joolian moons over a century, as well
 // as various properties of Bop's orbit, and Bop's separations to Pol and Tylo.
 void PlotCentury();
 
-// Uses an integration of the system at the base |step|, and integration of the
-// system at |step / 2|, and a slew of integrations of millimetrically perturbed
-// systems at |step| to show that the error from numerical integration
-// (estimated in forward error as the error between the integration at |step|
-// and the one at |step / 2|) corresponds to a submillimetric backward error
+// Uses an integration of the system at the base `step`, and integration of the
+// system at `step / 2`, and a slew of integrations of millimetrically perturbed
+// systems at `step` to show that the error from numerical integration
+// (estimated in forward error as the error between the integration at `step`
+// and the one at `step / 2`) corresponds to a submillimetric backward error
 // (as the millimetrically perturbed cluster diverges much faster than the
 // refined integration does).
 // Moreover, shows that the forward error from millimetric perturbations is less
diff --git a/numerics/angle_reduction_test.cpp b/numerics/angle_reduction_test.cpp
index 91464385e3..540af371f9 100644
--- a/numerics/angle_reduction_test.cpp
+++ b/numerics/angle_reduction_test.cpp
@@ -7,8 +7,8 @@
 #include "quantities/si.hpp"
 #include "testing_utilities/almost_equals.hpp"
 
-// The test is in the |internal| namespace to get visibility to |one_π| and
-// |two_π|.
+// The test is in the `internal` namespace to get visibility to `one_π` and
+// `two_π`.
 namespace principia {
 namespace numerics {
 namespace _angle_reduction {
@@ -25,7 +25,7 @@ class AngleReductionTest : public testing::Test {};
 TYPED_TEST_SUITE_P(AngleReductionTest);
 
 // This test is not type-parameterized because the reduction algorithm only
-// works for |Angle|.
+// works for `Angle`.
 TEST(AngleReductionTest, ReduceMinusπOver2ToπOver2) {
   Angle fractional_part;
   std::int64_t integer_part;
diff --git a/numerics/approximation.hpp b/numerics/approximation.hpp
index 60205babfa..bbcf1b9800 100644
--- a/numerics/approximation.hpp
+++ b/numerics/approximation.hpp
@@ -22,8 +22,8 @@ template<typename Argument, typename Function>
 using Value = std::invoke_result_t<Function, Argument>;
 
 // A function that returns true iff the interpolation interval should be split
-// further.  It is only called if the |error_estimate| is larger than the
-// |max_error| given to |AdaptiveЧебышёвPolynomialInterpolant|.
+// further.  It is only called if the `error_estimate` is larger than the
+// `max_error` given to `AdaptiveЧебышёвPolynomialInterpolant`.
 template<typename Value, typename Argument>
 using SubdivisionPredicate = std::function<bool(
     PolynomialInЧебышёвBasis<Value, Argument> const& interpolant,
@@ -37,7 +37,7 @@ using TerminationPredicate = std::function<bool(
 
 // Returns a Чебышёв polynomial interpolant of f over
 // [lower_bound, upper_bound].  Stops if the absolute error is estimated to be
-// below |max_error| or if |max_degree| has been reached.  If |error_estimate|
+// below `max_error` or if `max_degree` has been reached.  If `error_estimate`
 // is nonnull, it receives the estimate of the L∞ error.
 template<int max_degree, typename Argument, typename Function>
 not_null<std::unique_ptr<
@@ -51,7 +51,7 @@ not_null<std::unique_ptr<
 
 // Returns an ordered vector of Чебышёв polynomial interpolants of f, which
 // together cover [lower_bound, upper_bound].  Subdivides the interval until the
-// error is below |max_error| or |subdivide| returns false.
+// error is below `max_error` or `subdivide` returns false.
 template<int max_degree, typename Argument, typename Function>
 std::vector<not_null<std::unique_ptr<
     PolynomialInЧебышёвBasis<Value<Argument, Function>, Argument>>>>
@@ -64,7 +64,7 @@ AdaptiveЧебышёвPolynomialInterpolant(
     Difference<Value<Argument, Function>>* error_estimate = nullptr);
 
 // A streaming version of the above: as each interpolant that is below
-// |max_error| is computed, it is passed to |stop|, which should return false
+// `max_error` is computed, it is passed to `stop`, which should return false
 // if the production of interpolants should continue and true if it should stop.
 template<int max_degree, typename Argument, typename Function>
 void StreamingAdaptiveЧебышёвPolynomialInterpolant(
diff --git a/numerics/approximation_body.hpp b/numerics/approximation_body.hpp
index 18dcbf8b51..c6c3c54887 100644
--- a/numerics/approximation_body.hpp
+++ b/numerics/approximation_body.hpp
@@ -65,12 +65,12 @@ not_null<std::unique_ptr<
 
   FixedVector<Value<Argument, Function>, N + 1> fₖ(uninitialized);
 
-  // Reuse the previous evaluations of |f|.
+  // Reuse the previous evaluations of `f`.
   for (std::int64_t k = 0; k <= N / 2; ++k) {
     fₖ[2 * k] = previous_fₖ[k];
   }
 
-  // Evaluate |f| for the new points.
+  // Evaluate `f` for the new points.
   for (std::int64_t k = 1; k < N; k += 2) {
     fₖ[k] = f(чебышёв_lobato_point(k));
   }
@@ -101,11 +101,11 @@ not_null<std::unique_ptr<
   }
 
   // Unlike [Boy13], section 4, we return the polynomial of the lower degree
-  // that is within the |max_error| bound (that is, the one of degree N / 2).
+  // that is within the `max_error` bound (that is, the one of degree N / 2).
   // Even though we computed the polynomial of degree N, returning it would
   // impose an unnecessary cost on the client (e.g., more costly evaluation). If
   // a client wants a more precise approximation, they just need to give a
-  // smaller |max_error|.
+  // smaller `max_error`.
   if (error_estimate != nullptr) {
     *error_estimate = current_error_estimate;
   }
@@ -132,7 +132,7 @@ bool StreamingAdaptiveЧебышёвPolynomialInterpolantImplementation(
   if (full_error_estimate <= max_error ||
       !subdivide(*full_interpolant, full_error_estimate)) {
     // If the interpolant over the entire interval is within the desired error
-    // bound, return it.  Same thing if |subdivide| tells us that we should not
+    // bound, return it.  Same thing if `subdivide` tells us that we should not
     // subdivide the interval.
     VLOG(1) << "Degree " << full_interpolant->degree() << " interpolant over ["
             << lower_bound << " (" << f(lower_bound) << "), " << upper_bound
diff --git a/numerics/double_precision.hpp b/numerics/double_precision.hpp
index f99c9eea45..8a03a181f8 100644
--- a/numerics/double_precision.hpp
+++ b/numerics/double_precision.hpp
@@ -37,8 +37,8 @@ struct DoublePrecision final {
   DoublePrecision<T>& operator-=(Difference<T> const& right);
 
   // Compensated summation.  This is less precise, but more efficient, than
-  // |operator-=| or |operator+=|.  Unlike |QuickTwoSum|, these functions don't
-  // DCHECK their argument, so the caller must ensure that |right| is small
+  // `operator-=` or `operator+=`.  Unlike `QuickTwoSum`, these functions don't
+  // DCHECK their argument, so the caller must ensure that `right` is small
   // enough.
   DoublePrecision<T>& Decrement(Difference<T> const& right);
   DoublePrecision<T>& Increment(Difference<T> const& right);
@@ -51,45 +51,45 @@ struct DoublePrecision final {
   Difference<T> error{};
 };
 
-// |scale| must be a signed power of two or zero.
+// `scale` must be a signed power of two or zero.
 template<typename T, typename U>
 DoublePrecision<Product<T, U>> Scale(T const& scale,
                                      DoublePrecision<U> const& right);
 
 // Returns the exact product of its arguments.  Note that this function checks
-// whether |UseHardwareFMA| is true.  If the value of that flag is already known
+// whether `UseHardwareFMA` is true.  If the value of that flag is already known
 // from context, it may be preferable to either:
 // — use VeltkampDekkerProduct(a, b) below;
 // — directly compute value = a * b, error = FusedMultiplySubtract(a, b, value).
 template<FMAPolicy fma_policy = FMAPolicy::Auto, typename T, typename U>
 DoublePrecision<Product<T, U>> TwoProduct(T const& a, U const& b);
 
-// Returns the exact value of |a * b + c|.
+// Returns the exact value of `a * b + c`.
 template<FMAPolicy fma_policy = FMAPolicy::Auto, typename T, typename U>
 DoublePrecision<Product<T, U>> TwoProductAdd(T const& a,
                                              U const& b,
                                              Product<T, U> const& c);
 
-// Returns the exact value of |a * b - c|.
+// Returns the exact value of `a * b - c`.
 template<FMAPolicy fma_policy = FMAPolicy::Auto, typename T, typename U>
 DoublePrecision<Product<T, U>> TwoProductSubtract(T const& a,
                                                   U const& b,
                                                   Product<T, U> const& c);
 
-// Returns the exact value of |-a * b + c|.
+// Returns the exact value of `-a * b + c`.
 template<FMAPolicy fma_policy = FMAPolicy::Auto, typename T, typename U>
 DoublePrecision<Product<T, U>> TwoProductNegatedAdd(T const& a,
                                                     U const& b,
                                                     Product<T, U> const& c);
 
-// Returns the exact value of |-a * b - c|.
+// Returns the exact value of `-a * b - c`.
 template<FMAPolicy fma_policy = FMAPolicy::Auto, typename T, typename U>
 DoublePrecision<Product<T, U>>
 TwoProductNegatedSubtract(T const& a,
                           U const& b,
                           Product<T, U> const& c);
 
-// Same as |TwoProduct|, but never uses FMA.
+// Same as `TwoProduct`, but never uses FMA.
 template<typename T, typename U>
 constexpr DoublePrecision<Product<T, U>> VeltkampDekkerProduct(T const& a,
                                                                U const& b);
@@ -103,7 +103,7 @@ constexpr DoublePrecision<Sum<T, U>> QuickTwoSum(T const& a, U const& b);
 template<typename T, typename U>
 constexpr DoublePrecision<Sum<T, U>> TwoSum(T const& a, U const& b);
 
-// |TwoDifference| may have any of the following signatures:
+// `TwoDifference` may have any of the following signatures:
 //   1. Point × Point → Vector;
 //   2. Point × Vector → Point;
 //   3. Vector × Vector → Vector;
@@ -120,11 +120,11 @@ template<typename T, typename U, typename = Difference<Difference<T, U>, T>>
 constexpr DoublePrecision<Difference<T, U>> TwoDifference(T const& a,
                                                           U const& b);
 
-// |T| must be a vector.
+// `T` must be a vector.
 template<typename T>
 DoublePrecision<Difference<T>> operator+(DoublePrecision<T> const& left);
 
-// |T| must be a vector.
+// `T` must be a vector.
 template<typename T>
 DoublePrecision<Difference<T>> operator-(DoublePrecision<T> const& left);
 
diff --git a/numerics/double_precision_body.hpp b/numerics/double_precision_body.hpp
index 9ca24f994a..2ddffcd1d9 100644
--- a/numerics/double_precision_body.hpp
+++ b/numerics/double_precision_body.hpp
@@ -143,7 +143,7 @@ DoublePrecision<T>& DoublePrecision<T>::operator-=(
 template <typename T>
 DoublePrecision<T>& DoublePrecision<T>::Decrement(Difference<T> const& right) {
   // See Higham, Accuracy and Stability of Numerical Algorithms, Algorithm 4.2.
-  // This is equivalent to |QuickTwoSum(value, error - right)|.
+  // This is equivalent to `QuickTwoSum(value, error - right)`.
   T const temp = value;
   Difference<T> const y = error - right;
   value = temp + y;
@@ -154,7 +154,7 @@ DoublePrecision<T>& DoublePrecision<T>::Decrement(Difference<T> const& right) {
 template <typename T>
 DoublePrecision<T>& DoublePrecision<T>::Increment(Difference<T> const& right) {
   // See Higham, Accuracy and Stability of Numerical Algorithms, Algorithm 4.2.
-  // This is equivalent to |QuickTwoSum(value, error + right)|.
+  // This is equivalent to `QuickTwoSum(value, error + right)`.
   T const temp = value;
   Difference<T> const y = error + right;
   value = temp + y;
@@ -369,7 +369,7 @@ constexpr DoublePrecision<Difference<T, U>> TwoDifference(T const& a,
   Vector& s = result.value;
   Vector& e = result.error;
   s = a - b;
-  // Corresponds to -v in |TwoSum|.
+  // Corresponds to -v in `TwoSum`.
   Point const w = a - s;
   e = (a - (s + w)) + (w - b);
   return result;
@@ -515,10 +515,10 @@ DoublePrecision<Quotient<T, U>> operator/(DoublePrecision<T> const& left,
 
 template<typename T>
 std::string DebugString(DoublePrecision<T> const& double_precision) {
-  // We use |DebugString| to get all digits when |T| is |double|.  In that case
-  // ADL will not find it, so we need the |using|.  For some values of |T|,
-  // |DebugString| will come from elsewhere, so we cannot directly call
-  // |quantities::Multivector|.
+  // We use `DebugString` to get all digits when `T` is `double`.  In that case
+  // ADL will not find it, so we need the `using`.  For some values of `T`,
+  // `DebugString` will come from elsewhere, so we cannot directly call
+  // `quantities::Multivector`.
   using quantities::_quantities::DebugString;
   return DebugString(double_precision.value) + "|" +
          DebugString(double_precision.error);
diff --git a/numerics/double_precision_test.cpp b/numerics/double_precision_test.cpp
index dbc2cb471d..20c9a41466 100644
--- a/numerics/double_precision_test.cpp
+++ b/numerics/double_precision_test.cpp
@@ -249,7 +249,7 @@ TEST_F(DoublePrecisionTest, Consistencies) {
   // DoublePrecision<Point> - DoublePrecision<Point>.
   EXPECT_THAT(DebugString(q1 - q2), Eq(DebugString(w1 + -w2)));
 
-  // We now showcase the difference between |Increment| and |operator+=|.
+  // We now showcase the difference between `Increment` and `operator+=`.
   auto compensated_accumulator = -w2;
   compensated_accumulator.Increment(v1);
   auto double_accumulator = -w2;
diff --git a/numerics/elliptic_integrals.cpp b/numerics/elliptic_integrals.cpp
index 517ba6c884..8631b5d17f 100644
--- a/numerics/elliptic_integrals.cpp
+++ b/numerics/elliptic_integrals.cpp
@@ -36,9 +36,9 @@ using namespace principia::quantities::_si;
 namespace {
 
 // The functions that compute elliptic integrals of multiple kinds may be called
-// without computing the integral of the third kind.  Passing |unused| bypasses
+// without computing the integral of the third kind.  Passing `unused` bypasses
 // the corresponding code path at compile time, passing a reference to an
-// |Angle| performs the computation.
+// `Angle` performs the computation.
 
 struct UnusedResult {
   constexpr UnusedResult(uninitialized_t) {}  // NOLINT(runtime/explicit)
@@ -115,8 +115,8 @@ Angle FukushimaEllipticJsMaclaurinSeries(double y, double n, double m);
 // Fukushima's T function [Fuk12b].
 Angle FukushimaT(double t, double h);
 
-// The common implementation underlying the functions |FukushimaEllipticBDJ| and
-// |FukushimaEllipticBD| declared in the header file.
+// The common implementation underlying the functions `FukushimaEllipticBDJ` and
+// `FukushimaEllipticBD` declared in the header file.
 template<typename ThirdKind, typename = EnableIfAngleResult<ThirdKind>>
 void FukushimaEllipticBDJ(Angle const& φ,
                           double n,
@@ -134,8 +134,8 @@ void FukushimaEllipticBDJReduced(Angle const& φ,
                                  Angle& D_φǀm,
                                  ThirdKind& J_φ_nǀm);
 
-// The common implementation underlying the functions |EllipticFEΠ| and
-// |EllipticFE| declared in the header file.
+// The common implementation underlying the functions `EllipticFEΠ` and
+// `EllipticFE` declared in the header file.
 template<typename ThirdKind, typename = EnableIfAngleResult<ThirdKind>>
 void EllipticFEΠ(Angle const& φ,
                  double n,
@@ -2024,7 +2024,7 @@ void EllipticFEΠ(Angle const& φ,
 // Note that the identifiers in the function definition are not the same as
 // those in the function declaration.
 // The notation here follows [Fuk09a], whereas the notation in the function
-// declaration uses |mc| for consistency with the other functions.
+// declaration uses `mc` for consistency with the other functions.
 Angle EllipticK(double const mʹ) {
   DCHECK_LE(0, mʹ);
   DCHECK_GE(1, mʹ);
diff --git a/numerics/fast_fourier_transform.hpp b/numerics/fast_fourier_transform.hpp
index a956e860b4..22136b5c1d 100644
--- a/numerics/fast_fourier_transform.hpp
+++ b/numerics/fast_fourier_transform.hpp
@@ -36,8 +36,8 @@ using namespace principia::quantities::_quantities;
 template<typename Value, typename Argument, std::size_t size_>
 class FastFourierTransform {
  public:
-  // This is only an actual angular frequency if |Argument| is time-like.
-  // If |Argument| is an angular frequency, this is a time.
+  // This is only an actual angular frequency if `Argument` is time-like.
+  // If `Argument` is an angular frequency, this is a time.
   using AngularFrequency = Derivative<Angle, Argument>;
 
   // The size must be a power of 2.
@@ -45,7 +45,7 @@ class FastFourierTransform {
   static constexpr int log2_size = FloorLog2(size);
   static_assert(size == 1 << log2_size);
 
-  // In the constructors, the container must have |size| elements.  For the
+  // In the constructors, the container must have `size` elements.  For the
   // purpose of expressing the frequencies, the values are assumed to be
   // sampled at intervals of Δt.
 
diff --git a/numerics/finite_difference.hpp b/numerics/finite_difference.hpp
index 452dd9f7bd..474f01ebd4 100644
--- a/numerics/finite_difference.hpp
+++ b/numerics/finite_difference.hpp
@@ -12,12 +12,12 @@ namespace internal {
 using namespace principia::quantities::_named_quantities;
 
 // Given n equally-spaced values f(xᵢ) = f(x₀ + i h),
-// approximates the derivative f′(xⱼ) at xⱼ for j = |offset|, where 0 ≤ j < n.
-// Special values of |offset| are:
-// — |offset = 0|: forward difference;
-// — |offset = (n - 1) / 2|, for odd n:
+// approximates the derivative f′(xⱼ) at xⱼ for j = `offset`, where 0 ≤ j < n.
+// Special values of `offset` are:
+// — `offset = 0`: forward difference;
+// — `offset = (n - 1) / 2`, for odd n:
 //   central difference—in this case, the middle value is unused;
-// — |offset = n - 1|: backward difference.
+// — `offset = n - 1`: backward difference.
 // The error on the derivative is 𝒪(hⁿ⁻¹) as h → 0.
 // If f is a polynomial of degree less than or equal to n - 1, the result is
 // exact up to rounding errors.
diff --git a/numerics/fit_hermite_spline.hpp b/numerics/fit_hermite_spline.hpp
index 00065c5682..41e6ea67cc 100644
--- a/numerics/fit_hermite_spline.hpp
+++ b/numerics/fit_hermite_spline.hpp
@@ -14,17 +14,17 @@ namespace internal {
 using namespace principia::geometry::_hilbert;
 using namespace principia::quantities::_named_quantities;
 
-// Given |samples| for which the arguments, values, and derivatives can be
+// Given `samples` for which the arguments, values, and derivatives can be
 // obtained via the given functors, returns a sequence of iterators
 // (it₀, it₁, it₂, ..., itᵣ) such that, with it₋₁ = samples.begin(),
-// for all integers it in [0, r], the |Hermite3| interpolation of
-// (*itᵢ₋₁, *itᵢ) fits |samples| within |tolerance|, but the interpolation
+// for all integers it in [0, r], the `Hermite3` interpolation of
+// (*itᵢ₋₁, *itᵢ) fits `samples` within `tolerance`, but the interpolation
 // of (*itᵢ₋₁, *(it + 1)ᵢ) does not, i.e., the iterators delimit "maximal"
 // fitting polynomials.
 // Note that it follows from the above that itᵣ < samples.end() - 1, so that at
-// not all of |samples| is fitted maximally.  This function further guarantees
-// that the |Hermite3| interpolation of (*itᵣ, *(samples.end() - 1)) fits
-// |samples| within |tolerance|.
+// not all of `samples` is fitted maximally.  This function further guarantees
+// that the `Hermite3` interpolation of (*itᵣ, *(samples.end() - 1)) fits
+// `samples` within `tolerance`.
 template<typename Value, typename Argument, typename Samples>
 absl::StatusOr<std::list<typename Samples::const_iterator>> FitHermiteSpline(
     Samples const& samples,
diff --git a/numerics/fit_hermite_spline_body.hpp b/numerics/fit_hermite_spline_body.hpp
index 2971df7853..77091f1377 100644
--- a/numerics/fit_hermite_spline_body.hpp
+++ b/numerics/fit_hermite_spline_body.hpp
@@ -51,9 +51,9 @@ absl::StatusOr<std::list<typename Samples::const_iterator>> FitHermiteSpline(
   Iterator const last = samples.end() - 1;
   while (last - begin + 1 >= 3 &&
          !interpolation_error_is_within_tolerance(begin, last)) {
-    // Look for a cubic that fits the beginning within |tolerance| and
+    // Look for a cubic that fits the beginning within `tolerance` and
     // such the cubic fitting one more sample would not fit the samples within
-    // |tolerance|.
+    // `tolerance`.
     // Note that there may be more than one cubic satisfying this property;
     // ideally we would like to find the longest one, but this would be costly,
     // and we do not expect significant gains from this in practice.
diff --git a/numerics/fit_hermite_spline_test.cpp b/numerics/fit_hermite_spline_test.cpp
index 277c6bccb8..24b27ab095 100644
--- a/numerics/fit_hermite_spline_test.cpp
+++ b/numerics/fit_hermite_spline_test.cpp
@@ -73,8 +73,8 @@ TEST_F(FitHermiteSplineTest, Sinusoid) {
           1 * Centi(Metre)).value();
 
   // Note that gmock doesn't do decltypes, so we can't pass a λ directly.
-  // Also note that |Pointee| doesn't work with iterators, so
-  // |Pointee(Field(&Sample::t, _))| is not an option.
+  // Also note that `Pointee` doesn't work with iterators, so
+  // `Pointee(Field(&Sample::t, _))` is not an option.
   std::function<Instant(std::vector<Sample>::const_iterator)> const get_time =
       [](auto const it) { return it->t; };
   EXPECT_THAT(interpolation_points,
diff --git a/numerics/fixed_arrays.hpp b/numerics/fixed_arrays.hpp
index 9f5212c399..ed1953205a 100644
--- a/numerics/fixed_arrays.hpp
+++ b/numerics/fixed_arrays.hpp
@@ -111,7 +111,7 @@ class FixedMatrix final {
   constexpr FixedMatrix();
   explicit FixedMatrix(uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   constexpr FixedMatrix(
       std::array<Scalar, size_> const& data);  // NOLINT(runtime/explicit)
   constexpr FixedMatrix(
@@ -126,8 +126,8 @@ class FixedMatrix final {
                          FixedMatrix const& right) = default;
 
   // For  0 < i < rows and 0 < j < columns, the entry a_ij is accessed as
-  // |a(i, j)|.  if i and j do not satisfy these conditions, the expression
-  // |a(i, j)| implies undefined behaviour.
+  // `a(i, j)`.  if i and j do not satisfy these conditions, the expression
+  // `a(i, j)` implies undefined behaviour.
   constexpr Scalar& operator()(std::int64_t row, std::int64_t column);
   constexpr Scalar const& operator()(std::int64_t row,
                                      std::int64_t column) const;
@@ -149,7 +149,7 @@ class FixedMatrix final {
   Scalar FrobeniusNorm() const;
 
   // Applies the matrix as a bilinear form.  Present for compatibility with
-  // |SymmetricBilinearForm|.  Prefer to use |TransposedView| and |operator*|.
+  // `SymmetricBilinearForm`.  Prefer to use `TransposedView` and `operator*`.
   template<typename LScalar, typename RScalar>
   Product<Scalar, Product<LScalar, RScalar>>
       operator()(FixedVector<LScalar, columns_> const& left,
@@ -178,7 +178,7 @@ class FixedStrictlyLowerTriangularMatrix final {
   constexpr FixedStrictlyLowerTriangularMatrix();
   explicit FixedStrictlyLowerTriangularMatrix(uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   constexpr FixedStrictlyLowerTriangularMatrix(
       std::array<Scalar, size_> const& data);
 
@@ -191,8 +191,8 @@ class FixedStrictlyLowerTriangularMatrix final {
                          FixedStrictlyLowerTriangularMatrix const& right) =
       default;
 
-  // For  0 ≤ j < i < rows, the entry a_ij is accessed as |a(i, j)|.
-  // if i and j do not satisfy these conditions, the expression |a(i, j)|
+  // For  0 ≤ j < i < rows, the entry a_ij is accessed as `a(i, j)`.
+  // if i and j do not satisfy these conditions, the expression `a(i, j)`
   // implies undefined behaviour.
   constexpr Scalar& operator()(std::int64_t row, std::int64_t column);
   constexpr Scalar const& operator()(std::int64_t row,
@@ -220,7 +220,7 @@ class FixedLowerTriangularMatrix final {
   constexpr FixedLowerTriangularMatrix();
   explicit FixedLowerTriangularMatrix(uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   constexpr FixedLowerTriangularMatrix(
       std::array<Scalar, size_> const& data);
 
@@ -234,8 +234,8 @@ class FixedLowerTriangularMatrix final {
   friend bool operator!=(FixedLowerTriangularMatrix const& left,
                          FixedLowerTriangularMatrix const& right) = default;
 
-  // For  0 ≤ j ≤ i < rows, the entry a_ij is accessed as |a(i, j)|.
-  // if i and j do not satisfy these conditions, the expression |a(i, j)|
+  // For  0 ≤ j ≤ i < rows, the entry a_ij is accessed as `a(i, j)`.
+  // if i and j do not satisfy these conditions, the expression `a(i, j)`
   // implies undefined behaviour.
   constexpr Scalar& operator()(std::int64_t row, std::int64_t column);
   constexpr Scalar const& operator()(std::int64_t row,
@@ -260,7 +260,7 @@ class FixedStrictlyUpperTriangularMatrix final {
   constexpr FixedStrictlyUpperTriangularMatrix();
   explicit FixedStrictlyUpperTriangularMatrix(uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   constexpr FixedStrictlyUpperTriangularMatrix(
       std::array<Scalar, size_> const& data);
 
@@ -277,8 +277,8 @@ class FixedStrictlyUpperTriangularMatrix final {
       FixedStrictlyUpperTriangularMatrix const& left,
       FixedStrictlyUpperTriangularMatrix const& right) = default;
 
-  // For  0 ≤ i < j < columns, the entry a_ij is accessed as |a(i, j)|.
-  // if i and j do not satisfy these conditions, the expression |a(i, j)|
+  // For  0 ≤ i < j < columns, the entry a_ij is accessed as `a(i, j)`.
+  // if i and j do not satisfy these conditions, the expression `a(i, j)`
   // implies undefined behaviour.
   constexpr Scalar& operator()(std::int64_t row, std::int64_t column);
   constexpr Scalar const& operator()(std::int64_t row,
@@ -308,7 +308,7 @@ class FixedUpperTriangularMatrix final {
   constexpr FixedUpperTriangularMatrix();
   explicit FixedUpperTriangularMatrix(uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   constexpr FixedUpperTriangularMatrix(
       std::array<Scalar, size_> const& data);
 
@@ -322,8 +322,8 @@ class FixedUpperTriangularMatrix final {
   friend bool operator!=(FixedUpperTriangularMatrix const& left,
                          FixedUpperTriangularMatrix const& right) = default;
 
-  // For  0 ≤ i ≤ j < columns, the entry a_ij is accessed as |a(i, j)|.
-  // if i and j do not satisfy these conditions, the expression |a(i, j)|
+  // For  0 ≤ i ≤ j < columns, the entry a_ij is accessed as `a(i, j)`.
+  // if i and j do not satisfy these conditions, the expression `a(i, j)`
   // implies undefined behaviour.
   constexpr Scalar& operator()(std::int64_t row, std::int64_t column);
   constexpr Scalar const& operator()(std::int64_t row,
diff --git a/numerics/fixed_arrays_body.hpp b/numerics/fixed_arrays_body.hpp
index 8df03030e5..9cf223245d 100644
--- a/numerics/fixed_arrays_body.hpp
+++ b/numerics/fixed_arrays_body.hpp
@@ -16,10 +16,10 @@ namespace internal {
 
 using namespace principia::quantities::_elementary_functions;
 
-// A helper class to compute the dot product of two arrays.  |LScalar| and
-// |RScalar| are the types of the elements of the arrays.  |Left| and |Right|
+// A helper class to compute the dot product of two arrays.  `LScalar` and
+// `RScalar` are the types of the elements of the arrays.  `Left` and `Right`
 // are the (deduced) types of the arrays.  They must both have an operator[].
-// The third argument must be |std::make_index_sequence<size>|.
+// The third argument must be `std::make_index_sequence<size>`.
 template<typename LScalar, typename RScalar, typename>
 struct DotProduct;
 
@@ -40,7 +40,7 @@ DotProduct<LScalar, RScalar, std::index_sequence<i...>>::Compute(
   return ((left[i] * right[i]) + ...);
 }
 
-// The |data_| member is aggregate-initialized with an empty list initializer,
+// The `data_` member is aggregate-initialized with an empty list initializer,
 // which performs value initialization on the components.  For quantities this
 // calls the default constructor, for non-class types this does
 // zero-initialization.
diff --git a/numerics/fma.hpp b/numerics/fma.hpp
index a9201412c2..2d236dde89 100644
--- a/numerics/fma.hpp
+++ b/numerics/fma.hpp
@@ -29,11 +29,11 @@ inline bool const UseHardwareFMA = false;
 // The policy used for emitting FMA instructions.  This type is not used by this
 // file, but is declared here for the convenience of the clients.  The intended
 // semantics are:
-// * |Auto|: FMA is used if supported by the processor, the decision must be
-//   made dynamically by calling |UseHardwareFMA|.
-// * |Disallow|: FMA is never used.
-// * |Force|: FMA is always used.  The caller is expected to determine upstream
-//   if FMA is supported by the processor by calling |UseHardwareFMA|.
+// * `Auto`: FMA is used if supported by the processor, the decision must be
+//   made dynamically by calling `UseHardwareFMA`.
+// * `Disallow`: FMA is never used.
+// * `Force`: FMA is always used.  The caller is expected to determine upstream
+//   if FMA is supported by the processor by calling `UseHardwareFMA`.
 enum class FMAPolicy {
   Auto = 0,
   Disallow = 1,
@@ -41,7 +41,7 @@ enum class FMAPolicy {
 };
 
 // The functions in this file unconditionally wrap the appropriate intrinsics.
-// The caller may only use them if |UseHardwareFMA| is true.
+// The caller may only use them if `UseHardwareFMA` is true.
 
 // ⟦ab + c⟧.
 inline double FusedMultiplyAdd(double a, double b, double c);
diff --git a/numerics/fma_test.cpp b/numerics/fma_test.cpp
index 391ac74890..477cd42397 100644
--- a/numerics/fma_test.cpp
+++ b/numerics/fma_test.cpp
@@ -16,7 +16,7 @@ using namespace principia::testing_utilities::_almost_equals;
 class FMATest : public testing::Test {
  protected:
   void SetUp() override {
-    // Note that we test even if |UseHardwareFMA| is false, i.e., even in debug.
+    // Note that we test even if `UseHardwareFMA` is false, i.e., even in debug.
     if (!CanEmitFMAInstructions || !CPUIDFeatureFlag::FMA.IsSet()) {
       GTEST_SKIP() << "Cannot test FMA on a machine without FMA";
     }
diff --git a/numerics/frequency_analysis.hpp b/numerics/frequency_analysis.hpp
index 4285fbd878..7424d742f2 100644
--- a/numerics/frequency_analysis.hpp
+++ b/numerics/frequency_analysis.hpp
@@ -20,9 +20,9 @@ using namespace principia::numerics::_poisson_series;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// Computes the precise mode of a quasi-periodic |function|, assuming that the
-// mode is over the interval |fft_mode| (so named because it has presumably been
-// obtained using FFT).  The |Function| must have a member |FourierTransform|
+// Computes the precise mode of a quasi-periodic `function`, assuming that the
+// mode is over the interval `fft_mode` (so named because it has presumably been
+// obtained using FFT).  The `Function` must have a member `FourierTransform`
 // that returns its spectrum.  See [Cha95].
 template<typename Function,
          int aperiodic_wdegree, int periodic_wdegree>
@@ -32,11 +32,11 @@ AngularFrequency PreciseMode(
     PoissonSeries<double,
                   aperiodic_wdegree, periodic_wdegree> const& weight);
 
-// In the projection functions the |Function| must have an |InnerProduct| with
-// |PoissonSeries| or |PiecewisePoissonSeries|.
+// In the projection functions the `Function` must have an `InnerProduct` with
+// `PoissonSeries` or `PiecewisePoissonSeries`.
 
-// Computes the Кудрявцев projection of |function| on a basis with angular
-// frequency ω and maximum degrees |aperiodic_ldegree| and |periodic_ldegree|.
+// Computes the Кудрявцев projection of `function` on a basis with angular
+// frequency ω and maximum degrees `aperiodic_ldegree` and `periodic_ldegree`.
 // See [Kud07].
 template<int aperiodic_degree, int periodic_degree,
          typename Function,
@@ -64,8 +64,8 @@ Projection(Function const& function,
 //};
 //
 // Where Residual is a functor that takes an Instant and returns an element of a
-// vector space.  The first call to the calculator is with the |function| passed
-// to |IncrementalProjection|.
+// vector space.  The first call to the calculator is with the `function` passed
+// to `IncrementalProjection`.
 // If the calculator cannot find a suitable frequency, or if it wants to stop
 // the algorithm, it does so by returning std::nullopt.
 template<int aperiodic_degree, int periodic_degree,
diff --git a/numerics/frequency_analysis_body.hpp b/numerics/frequency_analysis_body.hpp
index 80f877a988..506b35bcc0 100644
--- a/numerics/frequency_analysis_body.hpp
+++ b/numerics/frequency_analysis_body.hpp
@@ -38,7 +38,7 @@ using namespace principia::numerics::_root_finders;
 using namespace principia::numerics::_unbounded_arrays;
 using namespace principia::quantities::_elementary_functions;
 
-// Appends basis elements for |ω| to |basis| and |basis_subspaces|.  Returns the
+// Appends basis elements for `ω` to `basis` and `basis_subspaces`.  Returns the
 // number of elements that were appended.
 template<int aperiodic_degree, int periodic_degree,
          typename BasisSeries>
@@ -69,11 +69,11 @@ int MakeBasis(std::optional<AngularFrequency> const& ω,
   }
 }
 
-// Given a column |aₘ| of a matrix (or quasimatrix in our case, see [Tre10])
-// this function produces the columns |qₘ|, |rₘ| of its QR decomposition.  The
-// inner product is defined by |weight|, |t_min| and |t_max|.  |q| is the Q
-// quasimatrix constructed so far, and |subspaces| specify the subspaces spanned
-// by the |q|s and by |aₘ|.
+// Given a column `aₘ` of a matrix (or quasimatrix in our case, see [Tre10])
+// this function produces the columns `qₘ`, `rₘ` of its QR decomposition.  The
+// inner product is defined by `weight`, `t_min` and `t_max`.  `q` is the Q
+// quasimatrix constructed so far, and `subspaces` specify the subspaces spanned
+// by the `q`s and by `aₘ`.
 template<typename BasisSeries,
          int aperiodic_wdegree, int periodic_wdegree>
 absl::Status NormalGramSchmidtStep(
@@ -149,12 +149,12 @@ absl::Status NormalGramSchmidtStep(
 }
 
 // This function performs the augmented QR decomposition step described in
-// [Hig02] section 20.3.  Note that as an optimization in updates |b|, because
-// the computation of |z| for larger and larger R would perform the exact same
-// inner products for the range [0, m_begin[.  The range of |q| to process (and
-// the range of |z| to update is at indices [m_begin, m_end[.  This function
-// doesn't return |qₘ₊₁| because it's not needed for the solution.  It also
-// doesn't return |ρ|.
+// [Hig02] section 20.3.  Note that as an optimization in updates `b`, because
+// the computation of `z` for larger and larger R would perform the exact same
+// inner products for the range [0, m_begin[.  The range of `q` to process (and
+// the range of `z` to update is at indices [m_begin, m_end[.  This function
+// doesn't return `qₘ₊₁` because it's not needed for the solution.  It also
+// doesn't return `ρ`.
 template<typename Function, typename BasisSeries, typename Norm,
          int aperiodic_wdegree, int periodic_wdegree>
 absl::Status AugmentedGramSchmidtStep(
@@ -180,7 +180,7 @@ absl::Status AugmentedGramSchmidtStep(
     b -= z[k] * q[k];
   }
 
-  // We do not compute the norm of |b| here (named |ρ| in [Hig02] section 20.3)
+  // We do not compute the norm of `b` here (named `ρ` in [Hig02] section 20.3)
   // because it's an additional cost: the client can compute the norm of the
   // residual however they want anyway.
 
diff --git a/numerics/frequency_analysis_test.cpp b/numerics/frequency_analysis_test.cpp
index a45760737e..f85f552d45 100644
--- a/numerics/frequency_analysis_test.cpp
+++ b/numerics/frequency_analysis_test.cpp
@@ -55,7 +55,7 @@ using namespace principia::testing_utilities::_is_near;
 using namespace principia::testing_utilities::_numerics_matchers;
 
 // Constructs a piecewise Poisson series that has the given number of pieces
-// covering [t_min, t_max] and that matches |series| over that interval.
+// covering [t_min, t_max] and that matches `series` over that interval.
 template<typename Piecewise>
 Piecewise Slice(typename Piecewise::Series const& series,
                 int const pieces,
@@ -357,7 +357,7 @@ TEST_F(FrequencyAnalysisTest, PiecewisePoissonSeriesProjection) {
       Series4::AperiodicPolynomial({}, t_mid),
       {{ω, Series4::Polynomials{sin, cos}}});
 
-  // Build a series that is based on |series| with different perturbations over
+  // Build a series that is based on `series` with different perturbations over
   // different intervals.
   PiecewiseSeries4 piecewise_series({t_min, t_min + 1 * Second}, series);
   for (int i = 1; i < 10; ++i) {
diff --git a/numerics/global_optimization.hpp b/numerics/global_optimization.hpp
index 9066713db3..320bb5adc1 100644
--- a/numerics/global_optimization.hpp
+++ b/numerics/global_optimization.hpp
@@ -23,7 +23,7 @@ using namespace principia::numerics::_nearest_neighbour;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// In this file |Argument| must be such that its difference belongs to a Hilbert
+// In this file `Argument` must be such that its difference belongs to a Hilbert
 // space.
 
 template<typename Scalar, typename Argument>
@@ -36,9 +36,9 @@ using Gradient =
                      typename Hilbert<Difference<Argument>>::Norm²Type>>;
 
 // NOTE(phl): This could nearly be a self-standing function (it doesn't have
-// much state) but having the type |Box| floating around would be unpleasant.
+// much state) but having the type `Box` floating around would be unpleasant.
 // Plus, that would be too many parameters in that function.
-// The parameter |dimensions| may be used to specify the dimension of the
+// The parameter `dimensions` may be used to specify the dimension of the
 // problem.  It it is 1 or 2, the box is 1- or 2-dimensional and the computation
 // of rₖ is adjusted accordingly.  In all cases, the dimensions of the box must
 // be nonzero.
@@ -64,10 +64,10 @@ class MultiLevelSingleLinkage {
       Field<Scalar, Argument> f,
       Field<Gradient<Scalar, Argument>, Argument> grad_f);
 
-  // If |number_of_rounds| is given, the algorithm does |number_of_rounds|
-  // iterations, each time adding |points_per_round| to the sample.
-  // If |number_of_rounds| is omitted, the first iteration uses
-  // |points_per_round| points, and subsequent iterations adjust the number of
+  // If `number_of_rounds` is given, the algorithm does `number_of_rounds`
+  // iterations, each time adding `points_per_round` to the sample.
+  // If `number_of_rounds` is omitted, the first iteration uses
+  // `points_per_round` points, and subsequent iterations adjust the number of
   // points (or the decision to terminate) based on the optimal Bayesian
   // stopping rule.
   // Beware!  The Bayesian stopping rule is typically more efficient, but it is
@@ -88,11 +88,11 @@ class MultiLevelSingleLinkage {
   using Norm²Type = typename Hilbert<Difference<Argument>>::Norm²Type;
 
   // We need pointer stability for the arguments as we store pointers, e.g., in
-  // PCP trees.  We generally cannot |reserve| because we don't know the final
-  // size of the vector, hence the |unique_ptr|s.
+  // PCP trees.  We generally cannot `reserve` because we don't know the final
+  // size of the vector, hence the `unique_ptr`s.
   using Arguments = std::vector<not_null<std::unique_ptr<Argument>>>;
 
-  // Implementation method for |FindGlobalMaxima| and |FindGlobalMinima|.
+  // Implementation method for `FindGlobalMaxima` and `FindGlobalMinima`.
   std::vector<Argument> FindGlobalMinima(
       std::int64_t points_per_round,
       std::optional<std::int64_t> number_of_rounds,
@@ -100,19 +100,19 @@ class MultiLevelSingleLinkage {
       Field<Scalar, Argument> const& f,
       Field<Gradient<Scalar, Argument>, Argument> const& grad_f);
 
-  // Returns true iff the given |stationary_point| is sufficiently far from the
-  // ones already in |stationary_point_neighbourhoods|.
+  // Returns true iff the given `stationary_point` is sufficiently far from the
+  // ones already in `stationary_point_neighbourhoods`.
   static bool IsNewStationaryPoint(
       Argument const& stationary_point,
       PrincipalComponentPartitioningTree<Argument> const&
           stationary_point_neighbourhoods,
       NormType local_search_tolerance);
 
-  // Returns a vector of size |values_per_round|.  The points are in |box_|.
+  // Returns a vector of size `values_per_round`.  The points are in `box_`.
   Arguments RandomArguments(std::int64_t values_per_round);
 
   // Returns the square of the radius rₖ from [RT87a], eqn. 35, specialized for
-  // |dimensions|.
+  // `dimensions`.
   Norm²Type CriticalRadius²(double σ, std::int64_t kN);
 
   Box const box_;
diff --git a/numerics/global_optimization_body.hpp b/numerics/global_optimization_body.hpp
index c47bf62ede..7940c99b9f 100644
--- a/numerics/global_optimization_body.hpp
+++ b/numerics/global_optimization_body.hpp
@@ -24,8 +24,8 @@ using namespace principia::geometry::_grassmann;
 using namespace principia::numerics::_gradient_descent;
 using namespace principia::quantities::_elementary_functions;
 
-// Values that are too small cause extra activity in |Add| and deeper recursion
-// in |FindNearestNeighbour|.  Values that are too large cause extra function
+// Values that are too small cause extra activity in `Add` and deeper recursion
+// in `FindNearestNeighbour`.  Values that are too large cause extra function
 // evaluations in the leaf search.
 constexpr int64_t pcp_tree_max_values_per_cell = 20;
 
@@ -114,7 +114,7 @@ MultiLevelSingleLinkage<Scalar, Argument, dimensions>::FindGlobalMinima(
   // This is the set X* from [RT87b].
   Arguments stationary_points;
 
-  // The sample points.  We'll have at least |points_per_round| points.
+  // The sample points.  We'll have at least `points_per_round` points.
   Arguments points;
   points.reserve(points_per_round);
 
@@ -134,8 +134,8 @@ MultiLevelSingleLinkage<Scalar, Argument, dimensions>::FindGlobalMinima(
 
   // This structure corresponds to the list T in [RT87b].  Points are ordered
   // based on their distance to their nearest neighbour that has a lower value
-  // of |f|.  When new points are added to the map, they are initially given the
-  // key |Infinity|, which is then refined when the nearest neighbour search
+  // of `f`.  When new points are added to the map, they are initially given the
+  // key `Infinity`, which is then refined when the nearest neighbour search
   // happens.  Each time through the outer loop, only the points in the upper
   // half of the map (distance greater than rₖ) are considered, and they are
   // moved down if a "too close" neighbour is found.
@@ -148,9 +148,9 @@ MultiLevelSingleLinkage<Scalar, Argument, dimensions>::FindGlobalMinima(
   // [RT87b]; or we can use the optimal Bayesian stopping rule described in
   // proposition 2 of [RT87a] and equations (3) and (4) of [RT87b].  For
   // consistency with most of the description in [RT87a] and [RT87b], we call
-  // |N| the number of points added in a particular iteration and |kN| the total
-  // number of sampling points so far, even if |N| varies from one iteration to
-  // the next and |kN| is not necessarily |k * N|.
+  // `N` the number of points added in a particular iteration and `kN` the total
+  // number of sampling points so far, even if `N` varies from one iteration to
+  // the next and `kN` is not necessarily `k * N`.
   std::int64_t number_of_points_all_rounds;
   std::int64_t number_of_points_this_round;
   std::int64_t round = 1;
@@ -169,7 +169,7 @@ MultiLevelSingleLinkage<Scalar, Argument, dimensions>::FindGlobalMinima(
       }
     } else {
       std::int64_t const w = stationary_points.size();
-      // Note that |w| may be 0 here if the stationary points were all outside
+      // Note that `w` may be 0 here if the stationary points were all outside
       // the local search radius.
       DCHECK_GT(kN, w + 2);
       // [RT87b] equation 3.
@@ -188,7 +188,7 @@ MultiLevelSingleLinkage<Scalar, Argument, dimensions>::FindGlobalMinima(
     }
 
     // Generate N new random points and add them to the PCP tree and to the
-    // |schedule| map.  Note that while [RT87b] tells us in the description of
+    // `schedule` map.  Note that while [RT87b] tells us in the description of
     // algorithm A that "it is no longer necessary to reduce the sample" they
     // also tell us in section 4 that they reduce the sample using γ = 0.1.
     // Also, [KS05] reduce the sample, but they don't seem to agree on whether
@@ -246,12 +246,12 @@ MultiLevelSingleLinkage<Scalar, Argument, dimensions>::FindGlobalMinima(
         // it again.
         it = schedule.erase(it);
       } else {
-        // Move the point xᵢ "down" in the |schedule| map, based on the distance
+        // Move the point xᵢ "down" in the `schedule` map, based on the distance
         // to its nearest neighbour.
         auto const distance²_to_xⱼ = (xᵢ - *xⱼ).Norm²();
         DCHECK_LE(distance²_to_xⱼ, rₖ²);
         it = schedule.erase(it);
-        // This insertion take places below |schedule.upper_bound(rₖ²)|, so it
+        // This insertion take places below `schedule.upper_bound(rₖ²)`, so it
         // doesn't affect the current iteration.
         schedule.emplace(distance²_to_xⱼ, &xᵢ);
       }
diff --git a/numerics/gradient_descent.hpp b/numerics/gradient_descent.hpp
index 677905ca9e..afa2750355 100644
--- a/numerics/gradient_descent.hpp
+++ b/numerics/gradient_descent.hpp
@@ -16,10 +16,10 @@ using namespace principia::geometry::_hilbert;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// In this file |Argument| must be such that its difference belongs to a Hilbert
+// In this file `Argument` must be such that its difference belongs to a Hilbert
 // space.
 
-// A helper for generating declarations derived from |Scalar| and |Argument|.
+// A helper for generating declarations derived from `Scalar` and `Argument`.
 // It must declare the type of the gradient and a function returning the inner
 // product form thus:
 //   using Gradient = ...;
@@ -45,9 +45,9 @@ constexpr absl::StatusCode Done = absl::StatusCode::kOk;
 constexpr absl::StatusCode NoMinimum = absl::StatusCode::kNotFound;
 }  // namespace termination_condition
 
-// Stops when the search displacement is smaller than |tolerance|.  Returns
-// |NoMinimum| if no minimum is found within distance |radius| of
-// |start_argument|.  The first step size defaults to the tolerance.  The
+// Stops when the search displacement is smaller than `tolerance`.  Returns
+// `NoMinimum` if no minimum is found within distance `radius` of
+// `start_argument`.  The first step size defaults to the tolerance.  The
 // assumption is that, if the caller provides a reasonable value then (1) we
 // won't miss "interesting features" of f; (2) the finite differences won't
 // underflow or have other unpleasant properties.
diff --git a/numerics/hermite3.hpp b/numerics/hermite3.hpp
index dedc7c205e..95a9ce9f15 100644
--- a/numerics/hermite3.hpp
+++ b/numerics/hermite3.hpp
@@ -40,11 +40,11 @@ class Hermite3 final {
   // The result is sorted.
   BoundedArray<Argument, 2> FindExtrema() const;
 
-  // |samples| must be a container; |get_argument| and |get_value| on the
-  // elements of |samples| must return |Argument| and |Value| respectively
+  // `samples` must be a container; `get_argument` and `get_value` on the
+  // elements of `samples` must return `Argument` and `Value` respectively
   // (possibly by reference or const-reference)
-  // Returns the largest error (in the given |norm|) between this polynomial and
-  // the given |samples|.
+  // Returns the largest error (in the given `norm`) between this polynomial and
+  // the given `samples`.
   template<typename Samples>
   NormType LInfinityError(
       Samples const& samples,
@@ -53,7 +53,7 @@ class Hermite3 final {
       std::function<Value const&(typename Samples::value_type const&)> const&
           get_value) const;
 
-  // Returns true if the |LInfinityError| is less than |tolerance|.  More
+  // Returns true if the `LInfinityError` is less than `tolerance`.  More
   // efficient than the above function in the case where it returns false.
   template<typename Samples>
   bool LInfinityErrorIsWithin(
@@ -70,7 +70,7 @@ class Hermite3 final {
 
   std::pair<Argument, Argument> const arguments_;
 
-  // The coefficients are relative to |argements.first|.
+  // The coefficients are relative to `arguments.first`.
   Value a0_;
   Derivative1 a1_;
   Derivative2 a2_;
diff --git a/numerics/hermite3_test.cpp b/numerics/hermite3_test.cpp
index 06f141e6b9..30b6bc1625 100644
--- a/numerics/hermite3_test.cpp
+++ b/numerics/hermite3_test.cpp
@@ -100,7 +100,7 @@ TEST_F(Hermite3Test, OneDimensionalInterpolationError) {
       Hermite3<double, double>(/*arguments=*/{0, 1},
                                /*values=*/{0, 1},
                                /*derivatives=*/{0, 4});
-  // |not_a_quartic| has a root at 1/2, where the error is maximal.
+  // `not_a_quartic` has a root at 1/2, where the error is maximal.
   EXPECT_THAT(not_a_quartic.LInfinityError(
       samples,
       /*get_argument=*/[](auto&& pair) -> auto&& { return pair.first; },
diff --git a/numerics/lattices_body.hpp b/numerics/lattices_body.hpp
index 170397c643..6894cba5cf 100644
--- a/numerics/lattices_body.hpp
+++ b/numerics/lattices_body.hpp
@@ -33,8 +33,8 @@ using namespace principia::quantities::_concepts;
 using namespace principia::quantities::_elementary_functions;
 using namespace principia::quantities::_named_quantities;
 
-// In the terminology of [NS09], our vectors are in columns, so |d| is |columns|
-// and |n| is |rows|.
+// In the terminology of [NS09], our vectors are in columns, so `d` is `columns`
+// and `n` is `rows`.
 template<typename Matrix>
 struct GramGenerator;
 
diff --git a/numerics/matrix_computations.hpp b/numerics/matrix_computations.hpp
index c113c56128..2dd3aef27f 100644
--- a/numerics/matrix_computations.hpp
+++ b/numerics/matrix_computations.hpp
@@ -68,7 +68,7 @@ struct RealSchurDecompositionGenerator;
 //     ⟨matrix⟩ rotation;
 //     ⟨vector⟩ eigenvalues;
 //   };
-// Note that in |rotation| the eigenvectors appear in column.  They are
+// Note that in `rotation` the eigenvectors appear in column.  They are
 // normalized.
 template<typename M>
 struct ClassicalJacobiGenerator;
diff --git a/numerics/matrix_computations_body.hpp b/numerics/matrix_computations_body.hpp
index 428e2bc10c..70a0f1c25a 100644
--- a/numerics/matrix_computations_body.hpp
+++ b/numerics/matrix_computations_body.hpp
@@ -161,8 +161,8 @@ template<typename Matrix>
 absl::btree_set<typename Matrix::Scalar> Compute2By2Eigenvalues(
     BlockView<Matrix> const& block) {
   static constexpr typename Matrix::Scalar zero{};
-  // TODO(phl): Would |SymmetricSchurDecomposition2By2| work to shoot one zero
-  // (even though the |block| is not symmetric)?
+  // TODO(phl): Would `SymmetricSchurDecomposition2By2` work to shoot one zero
+  // (even though the `block` is not symmetric)?
   auto const& a = block(0, 0);
   auto const& b = block(0, 1);
   auto const& c = block(1, 0);
@@ -332,8 +332,8 @@ struct UnitriangularGramSchmidtGenerator<FixedMatrix<Scalar, rows, columns>> {
   static Result Uninitialized(FixedMatrix<Scalar, rows, columns> const& m);
 };
 
-// A specialization for |cpp_rational|, which is used for lattice reduction.
-// |double| is not appropriate for the element of |R| in this case.
+// A specialization for `cpp_rational`, which is used for lattice reduction.
+// `double` is not appropriate for the element of `R` in this case.
 template<std::int64_t rows, std::int64_t columns>
 struct UnitriangularGramSchmidtGenerator<
     FixedMatrix<cpp_rational, rows, columns>> {
diff --git a/numerics/matrix_views.hpp b/numerics/matrix_views.hpp
index eb0a31216e..5a37c8b87e 100644
--- a/numerics/matrix_views.hpp
+++ b/numerics/matrix_views.hpp
@@ -16,7 +16,7 @@ using namespace principia::numerics::_concepts;
 using namespace principia::numerics::_transposed_view;
 using namespace principia::quantities::_named_quantities;
 
-// A view of a rectangular block of a matrix.  This view is |two_dimensional|.
+// A view of a rectangular block of a matrix.  This view is `two_dimensional`.
 template<typename Matrix>
   requires two_dimensional<Matrix>
 struct BlockView {
@@ -50,7 +50,7 @@ struct BlockView {
   constexpr std::int64_t columns() const;
 };
 
-// A view of a column of a matrix.  This view is |one_dimensional|.
+// A view of a column of a matrix.  This view is `one_dimensional`.
 template<typename Matrix>
   requires two_dimensional<Matrix>
 struct ColumnView {
@@ -84,7 +84,7 @@ struct ColumnView {
   constexpr std::int64_t size() const;
 };
 
-// TODO(phl): This should probably be just |swap|.  The semantics of BlockView
+// TODO(phl): This should probably be just `swap`.  The semantics of BlockView
 // and ColumnView do imply an implicit dereferencing, so swapping should work
 // the same.
 template<typename Matrix>
diff --git a/numerics/nearest_neighbour.hpp b/numerics/nearest_neighbour.hpp
index 5e5d24ec60..ec9e389eec 100644
--- a/numerics/nearest_neighbour.hpp
+++ b/numerics/nearest_neighbour.hpp
@@ -36,11 +36,11 @@ class PrincipalComponentPartitioningTree {
 
   using Filter = std::function<bool(Value const*)>;
 
-  // We stop subdividing a cell when it contains |max_values_per_cell| or fewer
+  // We stop subdividing a cell when it contains `max_values_per_cell` or fewer
   // values.  This API takes (non-owning) pointers so that the client can relate
-  // the values given here to the ones it gets from |FindNearestNeighbour|.  The
-  // vector |values| may be empty, in which case the object is not usable until
-  // the first value has been |Add|ed.
+  // the values given here to the ones it gets from `FindNearestNeighbour`.  The
+  // vector `values` may be empty, in which case the object is not usable until
+  // the first value has been `Add`ed.
   PrincipalComponentPartitioningTree(
       std::vector<not_null<Value const*>> const& values,
       std::int64_t max_values_per_cell);
@@ -48,8 +48,8 @@ class PrincipalComponentPartitioningTree {
   // Adds a new value to the tree, restructuring it as needed.
   void Add(not_null<Value const*> value);
 
-  // Finds the nearest neighbour of the given |value|.  Returns nullptr if the
-  // tree is empty.  Only the values for which |filter| returns true are
+  // Finds the nearest neighbour of the given `value`.  Returns nullptr if the
+  // tree is empty.  Only the values for which `filter` returns true are
   // considered.
   Value const* FindNearestNeighbour(Value const& value,
                                     Filter const& filter = nullptr) const;
@@ -62,14 +62,14 @@ class PrincipalComponentPartitioningTree {
   // A displacement from the centroid.
   using Displacement = Difference<Value>;
 
-  // The type of the norm (and its square) of |Displacement|.
+  // The type of the norm (and its square) of `Displacement`.
   using Norm = typename Hilbert<Displacement>::NormType;
   using Norm² = typename Hilbert<Displacement>::Norm²Type;
 
-  // A unit vector corresponding to |Displacement|.
+  // A unit vector corresponding to `Displacement`.
   using Axis = typename Hilbert<Displacement>::NormalizedType;
 
-  // A form that operates on |Displacement|s.
+  // A form that operates on `Displacement`s.
   // NOTE(phl): We don't have SymmetricSquare for Bivector, so this effectively
   // means that Displacement is a Vector.
   using DisplacementSymmetricBilinearForm =
@@ -88,7 +88,7 @@ class PrincipalComponentPartitioningTree {
   // The declarations of the tree structure.
   struct Internal;
 
-  using Leaf = std::vector<std::int32_t>;  // Indices in |displacements_|.
+  using Leaf = std::vector<std::int32_t>;  // Indices in `displacements_`.
 
   using Node = std::variant<Internal, Leaf>;
 
@@ -102,8 +102,8 @@ class PrincipalComponentPartitioningTree {
   };
 
   // The construction of the tree uses this type, which contains an index in the
-  // |displacements_| array and storage for the projection of the corresponding
-  // |Displacement| on the current principal axis.  We use 32-bit integers
+  // `displacements_` array and storage for the projection of the corresponding
+  // `Displacement` on the current principal axis.  We use 32-bit integers
   // because these objects will be swapped a lot, so the less memory we touch
   // the better.
   struct Index {
@@ -113,11 +113,11 @@ class PrincipalComponentPartitioningTree {
   using Indices = std::vector<Index>;
 
   // Called when the first point is added to the tree to initialize the
-  // |centroid_| and the |root_|.
+  // `centroid_` and the `root_`.
   void Initialize();
 
   // Constructs a tree for the displacements given by the index range
-  // [begin, end[.  |size| must be equal to |std::distance(begin, end)|, but is
+  // [begin, end[.  `size` must be equal to `std::distance(begin, end)`, but is
   // passed by the caller for efficiency.
   not_null<std::unique_ptr<Node>> BuildTree(typename Indices::iterator begin,
                                             typename Indices::iterator end,
@@ -129,8 +129,8 @@ class PrincipalComponentPartitioningTree {
       typename Indices::iterator begin,
       typename Indices::iterator end) const;
 
-  // Adds the value at the given |index| by first finding the location in the
-  // subtree rooted at |node| where it would be located, and then adding it to
+  // Adds the value at the given `index` by first finding the location in the
+  // subtree rooted at `node` where it would be located, and then adding it to
   // the leaf (if there is room) or splitting the leaf (if not).
   void Add(std::int32_t index, Node& node);
 
@@ -138,11 +138,11 @@ class PrincipalComponentPartitioningTree {
   void Add(std::int32_t index, Internal const& internal);
   void Add(std::int32_t index, Leaf& leaf, Node& node);
 
-  // Finds the point closest to |displacement| in the |node| and its children,
-  // and returns its index and its (squared) distance.  If |displacement| is
-  // close to the separator plane of |parent|, sets |must_check_other_side| to
+  // Finds the point closest to `displacement` in the `node` and its children,
+  // and returns its index and its (squared) distance.  If `displacement` is
+  // close to the separator plane of `parent`, sets `must_check_other_side` to
   // true.  That pointer may be null if the client doesn't want to check this
-  // condition.  |parent| should be null for the root of the tree.
+  // condition.  `parent` should be null for the root of the tree.
   void Find(Displacement const& displacement,
             Filter const& filter,
             Internal const* parent,
@@ -172,11 +172,11 @@ class PrincipalComponentPartitioningTree {
   std::int64_t const max_values_per_cell_;
 
   // The centroid of the values passed at construction, or the first value
-  // passed to |Add| if no value is passed at construction.
+  // passed to `Add` if no value is passed at construction.
   Value centroid_;
 
   // The displacements from the centroid.  The indices are the same as for
-  // |values_|.
+  // `values_`.
   std::vector<Displacement> displacements_;
 
   std::unique_ptr<Node> root_;
diff --git a/numerics/nearest_neighbour_body.hpp b/numerics/nearest_neighbour_body.hpp
index de68ccfa48..2e2f23599a 100644
--- a/numerics/nearest_neighbour_body.hpp
+++ b/numerics/nearest_neighbour_body.hpp
@@ -131,7 +131,7 @@ PrincipalComponentPartitioningTree<Value_>::BuildTree(
   auto const principal_axis =
       eigensystem.rotation(PrincipalComponentsAxis({0, 0, 1}));
 
-  // Project the |vectors| on the principal axis.
+  // Project the `vectors` on the principal axis.
   for (auto it = begin; it != end; ++it) {
     auto const& displacement = displacements_[it->index];
     it->projection = InnerProduct(principal_axis, displacement);
@@ -146,7 +146,7 @@ PrincipalComponentPartitioningTree<Value_>::BuildTree(
   auto const mid_upper = begin + size / 2;
   std::nth_element(begin, mid_upper, end, projection_less);
 
-  // Here |mid_upper| denotes an index that denotes the point that is "in the
+  // Here `mid_upper` denotes an index that denotes the point that is "in the
   // middle" of the projections on the principal axis.  We do not wish to anchor
   // our separator plane on a point, because that would make it more likely that
   // queries have to dig into two branches of the tree.  Instead, we look for
@@ -264,8 +264,8 @@ void PrincipalComponentPartitioningTree<Value_>::Find(
       InnerProduct(internal.principal_axis, displacement - internal.anchor);
 
   // We first search on the "preferred" side of the separator plane, i.e., the
-  // one where |displacement| is located.  We may have to look at the "other"
-  // side, if |displacement| is too close to that plane.
+  // one where `displacement` is located.  We may have to look at the "other"
+  // side, if `displacement` is too close to that plane.
   Node const* preferred_side;
   if (projection < Norm{}) {
     preferred_side = internal.children.first.get();
@@ -291,7 +291,7 @@ void PrincipalComponentPartitioningTree<Value_>::Find(
       other_side = internal.children.first.get();
     }
 
-    // We omit |must_check_other_side| because there is no point in checking the
+    // We omit `must_check_other_side` because there is no point in checking the
     // other side again.
     // « Maintenant, rien qu'en traversant, j'ai fait qu'en face soit en face.
     // L'autre côté a changé de côté! » [GT71]
@@ -316,7 +316,7 @@ void PrincipalComponentPartitioningTree<Value_>::Find(
     min_index = preferred_min_index;
   }
 
-  // Finally, check if we are close to the separator plane of the |parent|, in
+  // Finally, check if we are close to the separator plane of the `parent`, in
   // which case *it* will need to check the other side of its plane.
   if (parent != nullptr && must_check_other_side != nullptr) {
     Norm² const projection² = Pow<2>(
@@ -336,7 +336,7 @@ void PrincipalComponentPartitioningTree<Value_>::Find(
     bool* const must_check_other_side) const {
   CHECK(!leaf.empty());
 
-  // Find the point in this leaf which is the closest to |displacement|.
+  // Find the point in this leaf which is the closest to `displacement`.
   min_distance² = Infinity<Norm²>;
   min_index = no_min_index;
   for (auto const index : leaf) {
@@ -350,7 +350,7 @@ void PrincipalComponentPartitioningTree<Value_>::Find(
     }
   }
 
-  // If there is a parent node, and |displacement| is very close to the
+  // If there is a parent node, and `displacement` is very close to the
   // separator plane, we'll need to check the other side of the plane.
   if (parent != nullptr && must_check_other_side != nullptr) {
     Norm² const projection² = Pow<2>(
diff --git a/numerics/nearest_neighbour_test.cpp b/numerics/nearest_neighbour_test.cpp
index 3d739cfdd1..9c401e56e6 100644
--- a/numerics/nearest_neighbour_test.cpp
+++ b/numerics/nearest_neighbour_test.cpp
@@ -44,7 +44,7 @@ class PrincipalComponentPartitioningTreeTest : public ::testing::Test {
     return nearest;
   }
 
-  // Fills the vectors with |number_of_values| randomly generated values.
+  // Fills the vectors with `number_of_values` randomly generated values.
   void MakeValues(
       int const number_of_values,
       std::vector<V>& values,
@@ -91,7 +91,7 @@ TEST_F(PrincipalComponentPartitioningTreeTest, XYPlaneConstructor) {
 }
 
 // Same as the previous test, but the tree is initially empty and points are
-// added using |Add|.
+// added using `Add`.
 TEST_F(PrincipalComponentPartitioningTreeTest, XYPlaneAdd) {
   V const v1({-1, -1, 0});
   V const v2({-1, 1, 0});
@@ -152,7 +152,7 @@ TEST_F(PrincipalComponentPartitioningTreeTest, RandomConstructor) {
 }
 
 // Same as the previous test, but the trees are initially empty and points are
-// added using |Add|.
+// added using `Add`.
 TEST_F(PrincipalComponentPartitioningTreeTest, RandomAdd) {
   static constexpr int points_in_tree = 100;
   static constexpr int points_to_test = 100;
diff --git a/numerics/newhall.hpp b/numerics/newhall.hpp
index e03482aa6d..2bad919b56 100644
--- a/numerics/newhall.hpp
+++ b/numerics/newhall.hpp
@@ -22,9 +22,9 @@ using namespace principia::numerics::_polynomial_in_monomial_basis;
 using namespace principia::numerics::_polynomial_in_чебышёв_basis;
 using namespace principia::quantities::_named_quantities;
 
-// Computes a Newhall approximation of the given |degree| in the Чебышёв basis.
-// |q| and |v| are the positions and velocities over a constant division of
-// [t_min, t_max].  |error_estimate| gives an estimate of the error between the
+// Computes a Newhall approximation of the given `degree` in the Чебышёв basis.
+// `q` and `v` are the positions and velocities over a constant division of
+// [t_min, t_max].  `error_estimate` gives an estimate of the error between the
 // approximation the input data.  The client probably wants to compute some
 // norm of that estimate.
 template<typename Value, int degree>
@@ -35,7 +35,7 @@ NewhallApproximationInЧебышёвBasis(std::vector<Value> const& q,
                                    Instant const& t_max,
                                    Value& error_estimate);
 
-// Same as above but the |degree| is not a constant expression.
+// Same as above but the `degree` is not a constant expression.
 template<typename Value>
 not_null<std::unique_ptr<PolynomialInЧебышёвBasis<Value, Instant>>>
 NewhallApproximationInЧебышёвBasis(int degree,
@@ -45,9 +45,9 @@ NewhallApproximationInЧебышёвBasis(int degree,
                                    Instant const& t_max,
                                    Value& error_estimate);
 
-// Computes a Newhall approximation of the given |degree| in the monomial basis.
+// Computes a Newhall approximation of the given `degree` in the monomial basis.
 // The parameters have the same meaning as in the preceding function.  The
-// result is a polynomial of |Time| valid around |(t_min + t_max) / 2| with
+// result is a polynomial of `Time` valid around `(t_min + t_max) / 2` with
 // an argument in the range [(t_min - t_max) / 2, (t_max - t_min) / 2].  The
 // polynomial is created using the given evaluator policy.
 template<typename Value, int degree>
@@ -59,7 +59,7 @@ NewhallApproximationInMonomialBasis(std::vector<Value> const& q,
                                     Policy const& policy,
                                     Difference<Value>& error_estimate);
 
-// Same as above but the |degree| is not a constant expression.
+// Same as above but the `degree` is not a constant expression.
 template<typename Value>
 not_null<std::unique_ptr<Polynomial<Value, Instant>>>
 NewhallApproximationInMonomialBasis(int degree,
diff --git a/numerics/newhall_body.hpp b/numerics/newhall_body.hpp
index c1c3707c71..c0d7178a92 100644
--- a/numerics/newhall_body.hpp
+++ b/numerics/newhall_body.hpp
@@ -24,7 +24,7 @@ using namespace principia::quantities::_quantities;
 // Only supports 8 divisions for now.
 constexpr int divisions = 8;
 
-// Logically |QV| should be heterogeneous, as it contains positions (or
+// Logically `QV` should be heterogeneous, as it contains positions (or
 // displacements) and velocities.  However, this would require giving dimensions
 // to the derivatives of the Чебышёв polynomials.  Let's no go there, let's do a
 // bit of type decay instead.
@@ -32,7 +32,7 @@ template<typename Value>
 using QV = std::array<Value, 2 * divisions + 2>;
 
 // A helper to unroll the dot product between an array-like object (which must
-// have an operator[]) and a |QV|.
+// have an operator[]) and a `QV`.
 template<int index = 2 * divisions + 1>
 struct DotProduct {
   template<typename Left, typename RightElement>
@@ -59,8 +59,8 @@ RightElement DotProduct<0>::Compute(Left const& left,
   return left[0] * right[0];
 }
 
-// Fills |result| (which must be array-like) with the result of multiplying a
-// matrix with a |QV|.
+// Fills `result` (which must be array-like) with the result of multiplying a
+// matrix with a `QV`.
 template<int degree, typename RightElement, typename Result>
 void Multiply(FixedMatrix<double, degree + 1, 2 * divisions + 2> const& left,
               QV<RightElement> const& right,
diff --git a/numerics/piecewise_poisson_series.hpp b/numerics/piecewise_poisson_series.hpp
index 5c0969673c..a3515e8547 100644
--- a/numerics/piecewise_poisson_series.hpp
+++ b/numerics/piecewise_poisson_series.hpp
@@ -103,9 +103,9 @@ class PiecewisePoissonSeries {
   // Gauss-Legendre quadrature on each subinterval, where the number of points
   // is chosen assuming that the periods of periodic terms are all large
   // compared to the subintervals.
-  // If apodization is desired, |*this| should be multiplied by an apodization
-  // function, and |FourierTransform| should be called on the product.
-  // |*this| must outlive the resulting function.
+  // If apodization is desired, `*this` should be multiplied by an apodization
+  // function, and `FourierTransform` should be called on the product.
+  // `*this` must outlive the resulting function.
   Spectrum FourierTransform() const;
 
   template<int aperiodic_wdegree, int periodic_wdegree>
diff --git a/numerics/poisson_series.hpp b/numerics/poisson_series.hpp
index c20b76d028..1d99ffbbd1 100644
--- a/numerics/poisson_series.hpp
+++ b/numerics/poisson_series.hpp
@@ -77,7 +77,7 @@ class PoissonSeries {
   using PolynomialsByAngularFrequency =
       std::vector<std::pair<AngularFrequency, Polynomials>>;
 
-  // The |periodic| vector may contain frequencies that are negative or zero, as
+  // The `periodic` vector may contain frequencies that are negative or zero, as
   // well as repeated frequencies.  It is not expected to be ordered.
   PoissonSeries(AperiodicPolynomial const& aperiodic,
                 PolynomialsByAngularFrequency const& periodic);
@@ -131,7 +131,7 @@ class PoissonSeries {
                 AperiodicPolynomial aperiodic,
                 PolynomialsByAngularFrequency periodic);
 
-  // Similar to the previous constructor, except that the |periodic| vector is
+  // Similar to the previous constructor, except that the `periodic` vector is
   // used verbatim, without sorting or normalization, which is useful for
   // internal algorithms which produce positive, ordered frequencies.
   struct TrustedPrivateConstructor {};
diff --git a/numerics/poisson_series_basis.hpp b/numerics/poisson_series_basis.hpp
index f4b56c323a..139c580c87 100644
--- a/numerics/poisson_series_basis.hpp
+++ b/numerics/poisson_series_basis.hpp
@@ -17,14 +17,14 @@ using namespace principia::geometry::_hilbert;
 using namespace principia::geometry::_instant;
 using namespace principia::quantities::_named_quantities;
 
-// A |PoissonSeriesSubspace| represents a linear subspace of the space of
+// A `PoissonSeriesSubspace` represents a linear subspace of the space of
 // Poisson series.
-// The type |PoissonSeriesSubspace| defines an orthogonal decomposition of the
+// The type `PoissonSeriesSubspace` defines an orthogonal decomposition of the
 // space of Poisson series, i.e., The space of Poisson series is the orthogonal
-// sum of all values of |PoissonSeriesSubspace|.
+// sum of all values of `PoissonSeriesSubspace`.
 class PoissonSeriesSubspace {
  public:
-  // Whether the subspaces |v| and |w| are orthogonal.
+  // Whether the subspaces `v` and `w` are orthogonal.
   // TODO(egg): When we take parity into account, orthogonality will be defined
   // with respect to an inner product over an interval centred on the origin of
   // the Poisson series, with an even apodization.
@@ -50,7 +50,7 @@ class PoissonSeriesSubspace {
 
 // A generator for the Кудрявцев basis, i.e., functions of the
 // form tⁿ sin ω t and tⁿ cos ω t properly ordered.  The basis elements have
-// type |Series|, which must be free from Quantity.  |degree| is the maximum
+// type `Series`, which must be free from Quantity.  `degree` is the maximum
 // degree of tⁿ.  The basis elements are valid over the interval [t_min, t_max]
 // and symmetrical (odd, even) around the midpoint of that interval.
 template<typename Series, int degree>
diff --git a/numerics/poisson_series_basis_body.hpp b/numerics/poisson_series_basis_body.hpp
index 01235a97fd..159d3887c6 100644
--- a/numerics/poisson_series_basis_body.hpp
+++ b/numerics/poisson_series_basis_body.hpp
@@ -16,8 +16,8 @@ using namespace principia::geometry::_barycentre_calculator;
 using namespace principia::quantities::_elementary_functions;
 
 
-// A helper to build unit quantities or multivector.  |Coefficient| must be a
-// member of a Hilbert space with |dimension| dimensions, and must be free from
+// A helper to build unit quantities or multivector.  `Coefficient` must be a
+// member of a Hilbert space with `dimension` dimensions, and must be free from
 // Quantity.
 template<typename Coefficient,
          int dimension,
@@ -30,7 +30,7 @@ template<typename Coefficient, int dimension, std::size_t... ds>
 struct CoefficientGenerator<Coefficient,
                             dimension,
                             std::index_sequence<ds...>> {
-  // Returns a unit multivector in the direction given by |d|, for instance,
+  // Returns a unit multivector in the direction given by `d`, for instance,
   // a multivector with coordinates {1, 0, 0}.
   template<int d>
   static Coefficient Unit();
@@ -42,7 +42,7 @@ struct CoefficientGenerator<double,
                             /*dimension=*/1,
                             std::index_sequence<ds...>> {
   // Returns a unit quantity.  This function is templated for consistency with
-  // the preceeding specialization; |d| must be 0.
+  // the preceeding specialization; `d` must be 0.
   template<int d>
   static double Unit();
 };
@@ -65,22 +65,22 @@ double CoefficientGenerator<double,
 }
 
 
-// In the following classes |index| and |indices...| encode the coordinate, the
+// In the following classes `index` and `indices...` encode the coordinate, the
 // degree and the parity (Sin or Cos) of a series.  How this encoding is
 // performed determines the order of the series in the basis.
 
-// A helper to build unit polynomials.  |Polynomial| must be a polynomial with
-// values in a |dimension|-dimensional Hilbert space.
+// A helper to build unit polynomials.  `Polynomial` must be a polynomial with
+// values in a `dimension`-dimensional Hilbert space.
 template<typename Polynomial, int dimension>
 struct PolynomialGenerator {
-  // Returns a polynomial whose coordinate and degree are encoded in |index|.
+  // Returns a polynomial whose coordinate and degree are encoded in `index`.
   template<int index>
   static Polynomial UnitPolynomial(Instant const& t_min,
                                    Instant const& t_mid,
                                    Instant const& t_max);
 
   // Returns a pair of polynomials (for Sin and Cos) whose parity, coordinate
-  // and degree are encoded in |index|.
+  // and degree are encoded in `index`.
   template<typename Polynomials, int index>
   static Polynomials UnitPolynomials(Instant const& t_min,
                                      Instant const& t_mid,
@@ -93,7 +93,7 @@ Polynomial PolynomialGenerator<Polynomial, dimension>::UnitPolynomial(
     Instant const& t_min,
     Instant const& t_mid,
     Instant const& t_max) {
-  // Extract the coordinate and the degree from |index|.  The coordinate varies
+  // Extract the coordinate and the degree from `index`.  The coordinate varies
   // faster, so terms of the same degree but different coordinates are
   // consecutive when this function is called from a template pack expansion.
   static constexpr int coordinate = index % dimension;
@@ -116,7 +116,7 @@ Polynomials PolynomialGenerator<Polynomial, dimension>::UnitPolynomials(
     Instant const& t_min,
     Instant const& t_mid,
     Instant const& t_max) {
-  // Extract the parity, coordinate and the degree from |index|.  The coordinate
+  // Extract the parity, coordinate and the degree from `index`.  The coordinate
   // varies faster, so terms of the same parity and degree but different
   // coordinates are consecutive when this function is called from a template
   // pack expansion.  The parity varies next, so Sin and Cos terms alternate for
diff --git a/numerics/poisson_series_body.hpp b/numerics/poisson_series_body.hpp
index 153aa7072b..5f50e62d76 100644
--- a/numerics/poisson_series_body.hpp
+++ b/numerics/poisson_series_body.hpp
@@ -434,7 +434,7 @@ PoissonSeries(PrivateConstructor,
     : origin_(aperiodic.origin()),
       aperiodic_(std::move(aperiodic)),
       periodic_(std::move(periodic)) {
-  // The |periodic| vector may have elements with positive or negative angular
+  // The `periodic` vector may have elements with positive or negative angular
   // frequencies.  Normalize our member variable to only have positive angular
   // frequencies.
 
diff --git a/numerics/polynomial.hpp b/numerics/polynomial.hpp
index b00108ff71..22d20ec12a 100644
--- a/numerics/polynomial.hpp
+++ b/numerics/polynomial.hpp
@@ -19,7 +19,7 @@ using namespace principia::base::_not_null;
 using namespace principia::numerics::_polynomial_evaluators;
 using namespace principia::quantities::_named_quantities;
 
-// |Value_| must belong to an affine space.  |Argument_| must belong to a ring
+// `Value_` must belong to an affine space.  `Argument_` must belong to a ring
 // or to Point based on a ring.
 template<typename Value_, typename Argument_>
 class Polynomial {
@@ -55,7 +55,7 @@ class Polynomial {
   static not_null<std::unique_ptr<Polynomial>> ReadFromMessage(
       serialization::Polynomial const& message);
   // Compatibility deserialization, when the evaluator is not present in
-  // |message|.
+  // `message`.
   template<template<typename, typename, int> typename Evaluator>
   static not_null<std::unique_ptr<Polynomial>> ReadFromMessage(
       serialization::Polynomial const& message);
diff --git a/numerics/polynomial_evaluators.hpp b/numerics/polynomial_evaluators.hpp
index cdd8eddc87..77c067a94a 100644
--- a/numerics/polynomial_evaluators.hpp
+++ b/numerics/polynomial_evaluators.hpp
@@ -27,7 +27,7 @@ static constexpr with_evaluator_t<Evaluator_> with_evaluator;
 template<typename Value, typename Argument, int degree>
   requires additive_group<Argument>
 struct Evaluator {
-  // This definition is replicated from |PolynomialInMonomialBasis| to avoid
+  // This definition is replicated from `PolynomialInMonomialBasis` to avoid
   // circular dependencies.
   using Coefficients = Derivatives<Value, Argument, degree + 1>;
 
diff --git a/numerics/polynomial_evaluators_body.hpp b/numerics/polynomial_evaluators_body.hpp
index 40107f27a8..a3d5a07633 100644
--- a/numerics/polynomial_evaluators_body.hpp
+++ b/numerics/polynomial_evaluators_body.hpp
@@ -17,10 +17,10 @@ using namespace principia::base::_bits;
 using namespace principia::quantities::_elementary_functions;
 
 
-// Internal helper for Estrin evaluation.  |degree| is the degree of the overall
-// polynomial, |low| and |subdegree| defines the subpolynomial that we currently
+// Internal helper for Estrin evaluation.  `degree` is the degree of the overall
+// polynomial, `low` and `subdegree` defines the subpolynomial that we currently
 // evaluate, i.e., the one with a constant term coefficient
-// |std::get<low>(coefficients)| and degree |subdegree|.
+// `std::get<low>(coefficients)` and degree `subdegree`.
 template<typename Value, typename Argument,
          int degree, bool fma, int low, int subdegree>
 struct InternalEstrinEvaluator {
@@ -170,9 +170,9 @@ EvaluateDerivative(Coefficients const& coefficients,
   return low * std::get<low>(coefficients);
 }
 
-// Internal helper for Horner evaluation.  |degree| is the degree of the overall
-// polynomial, |low| defines the subpolynomial that we currently evaluate, i.e.,
-// the one with a constant term coefficient |std::get<low>(coefficients)|.
+// Internal helper for Horner evaluation.  `degree` is the degree of the overall
+// polynomial, `low` defines the subpolynomial that we currently evaluate, i.e.,
+// the one with a constant term coefficient `std::get<low>(coefficients)`.
 template<typename Value, typename Argument, int degree, bool fma, int low>
 struct InternalHornerEvaluator {
   using Coefficients =
@@ -298,8 +298,8 @@ Evaluator<Value, Argument, degree>::EvaluateDerivative(
     Coefficients const& coefficients,
     Argument const& argument,
     not_null<Evaluator const*> const evaluator) {
-  // For some reason using a simpler control flow for |degree <= 3|, like we do
-  // above, degrades the performance of |Evaluate|.  So let's not do that.
+  // For some reason using a simpler control flow for `degree <= 3`, like we do
+  // above, degrades the performance of `Evaluate`.  So let's not do that.
   if (evaluator == Estrin<Value, Argument, degree>::Singleton()) {
     return Estrin<Value, Argument, degree>::EvaluateDerivative(
         coefficients, argument);
diff --git a/numerics/polynomial_evaluators_test.cpp b/numerics/polynomial_evaluators_test.cpp
index e49c96444e..5293c3dcf8 100644
--- a/numerics/polynomial_evaluators_test.cpp
+++ b/numerics/polynomial_evaluators_test.cpp
@@ -20,7 +20,7 @@ class PolynomialEvaluatorTest : public ::testing::Test {
   }
 
   // This test builds the binomial polynomial (1 + x)^degree and evaluates it
-  // using the |Evaluator| and directly using |std::pow|.
+  // using the `Evaluator` and directly using `std::pow`.
   template<template<typename Value, typename Argument, int degree>
            typename Evaluator,
            int degree>
diff --git a/numerics/polynomial_in_monomial_basis.hpp b/numerics/polynomial_in_monomial_basis.hpp
index f2346a5be9..d16652b6e3 100644
--- a/numerics/polynomial_in_monomial_basis.hpp
+++ b/numerics/polynomial_in_monomial_basis.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |Polynomial| must be
+// The files containing the tree of child classes of `Polynomial` must be
 // included in the order of inheritance to avoid circular dependencies.
 #ifndef PRINCIPIA_NUMERICS_POLYNOMIAL_HPP_
 #include "numerics/polynomial.hpp"
@@ -183,7 +183,7 @@ class PolynomialInMonomialBasis : public Polynomial<Value_, Argument_> {
   static PolynomialInMonomialBasis ReadFromMessage(
       serialization::Polynomial const& message);
   // Compatibility deserialization, when the evaluator is not present in
-  // |message|.
+  // `message`.
   template<template<typename, typename, int> typename Evaluator>
   static PolynomialInMonomialBasis ReadFromMessage(
       serialization::Polynomial const& message);
@@ -200,7 +200,7 @@ class PolynomialInMonomialBasis : public Polynomial<Value_, Argument_> {
 
   Coefficients coefficients_;
   Argument origin_;
-  // TODO(phl): The |Evaluator| class should be able to take a |Point|.
+  // TODO(phl): The `Evaluator` class should be able to take a `Point`.
   not_null<Evaluator<Value_, Difference<Argument_>, degree_> const*> evaluator_;
 
   template<typename V, typename A, int r>
diff --git a/numerics/polynomial_in_monomial_basis_body.hpp b/numerics/polynomial_in_monomial_basis_body.hpp
index 7403488ad8..4cae6cfbd1 100644
--- a/numerics/polynomial_in_monomial_basis_body.hpp
+++ b/numerics/polynomial_in_monomial_basis_body.hpp
@@ -190,7 +190,7 @@ struct TupleDropper;
 
 template<typename Tuple, int count, std::size_t... indices>
 struct TupleDropper<Tuple, count, std::index_sequence<indices...>> {
-  // Drops the first |count| elements of |tuple|.
+  // Drops the first `count` elements of `tuple`.
   static constexpr auto Drop(Tuple const& tuple);
 };
 
diff --git "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp" "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
index 20db1996c7..20196746ac 100644
--- "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
+++ "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |Polynomial| must be
+// The files containing the tree of child classes of `Polynomial` must be
 // included in the order of inheritance to avoid circular dependencies.
 #ifndef PRINCIPIA_NUMERICS_POLYNOMIAL_HPP_
 #include "numerics/polynomial.hpp"
@@ -79,10 +79,10 @@ class PolynomialInЧебышёвBasis<Value_, Argument_, std::nullopt>
 
   // Returns true if this polynomial may (but doesn't necessarily) have real
   // roots.  Returns false it is guaranteed not to have real roots.  This is
-  // significantly faster than calling |RealRoots|.  If |error_estimate| is
+  // significantly faster than calling `RealRoots`.  If `error_estimate` is
   // given, false is only returned if the envelope of the series at a distance
-  // of |error_estimate| has no real roots.  This is useful if the series is an
-  // approximation of some function with an L∞ error less than |error_estimate|.
+  // of `error_estimate` has no real roots.  This is useful if the series is an
+  // approximation of some function with an L∞ error less than `error_estimate`.
   bool MayHaveRealRoots(Value error_estimate = Value{}) const
     requires convertible_to_quantity<Value_>;
 
diff --git "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp" "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
index d5cecd533e..f6ab33ca03 100644
--- "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
+++ "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
@@ -137,10 +137,10 @@ template<typename Value_, typename Argument_, int degree_>
 Value_ PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::operator()(
     Argument const argument) const {
   // This formula ensures continuity at the edges by producing -1 or +1 within
-  // 2 ulps for |lower_bound_| and |upper_bound_|.
+  // 2 ulps for `lower_bound_` and `upper_bound_`.
   double const scaled_argument =
       ((argument - upper_bound_) + (argument - lower_bound_)) * one_over_width_;
-  // We have to allow |scaled_argument| to go slightly out of [-1, 1] because of
+  // We have to allow `scaled_argument` to go slightly out of [-1, 1] because of
   // computation errors.  But if it goes too far, something is broken.
   DCHECK_LE(scaled_argument, 1.1);
   DCHECK_GE(scaled_argument, -1.1);
@@ -247,8 +247,8 @@ template<typename Value_, typename Argument_, int degree_>
 void PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::WriteToMessage(
     not_null<serialization::Polynomial*> message) const {
   if constexpr (is_instance_of_v<R3Element, Value>) {
-    // |R3Element| is a low-level structure, so we don't want polynomials to use
-    // it directly: they should go through |Multivector|.  However, it's useful
+    // `R3Element` is a low-level structure, so we don't want polynomials to use
+    // it directly: they should go through `Multivector`.  However, it's useful
     // to be able to run benchmarks using them.
     LOG(FATAL) << "R3Element only supported for tests";
   } else {
diff --git a/numerics/quadrature.hpp b/numerics/quadrature.hpp
index 198f6e155f..7300644971 100644
--- a/numerics/quadrature.hpp
+++ b/numerics/quadrature.hpp
@@ -22,8 +22,8 @@ Primitive<std::invoke_result_t<Function, Argument>, Argument> GaussLegendre(
 
 // Computes a Clenshaw-Curtis quadrature on 2ᵖ + 1 points for successive p until
 // the tolerance is satisfied.  The client controls the accuracy of the result
-// using |max_relative_error| (returns when the relative error on the result is
-// estimated to be less that the specified value) and |max_points| (returns when
+// using `max_relative_error` (returns when the relative error on the result is
+// estimated to be less that the specified value) and `max_points` (returns when
 // the number of points would exceed the specified value).
 template<int initial_points = 3, typename Argument, typename Function>
 Primitive<std::invoke_result_t<Function, Argument>, Argument>
@@ -34,7 +34,7 @@ AutomaticClenshawCurtis(
     std::optional<double> max_relative_error,
     std::optional<int> max_points);
 
-// |points| must be of the form 2ᵖ + 1 for some p ∈ ℕ.  Returns the
+// `points` must be of the form 2ᵖ + 1 for some p ∈ ℕ.  Returns the
 // Clenshaw-Curtis quadrature of f with the given number of points.
 template<int points, typename Argument, typename Function>
 Primitive<std::invoke_result_t<Function, Argument>, Argument> ClenshawCurtis(
diff --git a/numerics/root_finders.hpp b/numerics/root_finders.hpp
index e9745508d8..92a3fba0dc 100644
--- a/numerics/root_finders.hpp
+++ b/numerics/root_finders.hpp
@@ -19,25 +19,25 @@ using namespace principia::numerics::_scale_b;
 using namespace principia::quantities::_elementary_functions;
 using namespace principia::quantities::_named_quantities;
 
-// Approximates a root of |f| between |lower_bound| and |upper_bound| by
+// Approximates a root of `f` between `lower_bound` and `upper_bound` by
 // bisection.  The result is less than one ULP from a root of any continuous
-// function agreeing with |f| on the values of |Argument|.
-// If |f(lower_bound)| and |f(upper_bound)| are both nonzero, they must be of
+// function agreeing with `f` on the values of `Argument`.
+// If `f(lower_bound)` and `f(upper_bound)` are both nonzero, they must be of
 // opposite signs.
 template<typename Argument, typename Function>
 Argument Bisect(Function f,
                 Argument const& lower_bound,
                 Argument const& upper_bound);
 
-// Performs Brent’s procedure |zero| from [Bre73], chapter 4, with an absolute
+// Performs Brent’s procedure `zero` from [Bre73], chapter 4, with an absolute
 // tolerance t=0.
 template<typename Argument, typename Function>
 Argument Brent(Function f,
                Argument const& lower_bound,
                Argument const& upper_bound);
 
-// Performs a golden-section search to find a local extremum of |f| between
-// |lower_bound| and |upper_bound|.
+// Performs a golden-section search to find a local extremum of `f` between
+// `lower_bound` and `upper_bound`.
 // The function searches for a minimum if compare is <, and a maximum if compare
 // is >.  Arbitrary order relations are allowed; in general, this function
 // searches for a value x such that compare(y, f(x)) is false for all y in some
@@ -48,13 +48,13 @@ Argument GoldenSectionSearch(Function f,
                              Argument const& upper_bound,
                              Compare compare);
 
-// Performs Brent’s procedure |localmin| from [Bre73], chapter 5, with an
+// Performs Brent’s procedure `localmin` from [Bre73], chapter 5, with an
 // absolute tolerance t set to the (subnormal) smallest strictly positive value
-// of |Difference<Argument>|.
+// of `Difference<Argument>`.
 // The function searches for a minimum if compare is <, and a maximum if compare
 // is >.  No values of Compare other than std::less<> and std::greater<> are
 // allowed.
-// The default value of |eps| is √ϵ, for ϵ as defined in [Bre73], chapter 4,
+// The default value of `eps` is √ϵ, for ϵ as defined in [Bre73], chapter 4,
 // (2.9).
 template<typename Argument, typename Function, typename Compare>
 Argument Brent(
diff --git a/numerics/root_finders_body.hpp b/numerics/root_finders_body.hpp
index ee48e6d8fd..c85fd2ef8e 100644
--- a/numerics/root_finders_body.hpp
+++ b/numerics/root_finders_body.hpp
@@ -69,7 +69,7 @@ Argument Brent(Function f,
   using Value = decltype(f(lower_bound));
   Value const zero{};
 
-  // We do not use |std::numeric_limits<double>::epsilon()|, because it is 2ϵ in
+  // We do not use `std::numeric_limits<double>::epsilon()`, because it is 2ϵ in
   // Brent’s notation: Brent uses ϵ = β^(1-τ) / 2 for rounded arithmetic, see
   // (2.9).
   constexpr double ϵ = ScaleB(0.5, 1 - std::numeric_limits<double>::digits);
@@ -236,7 +236,7 @@ Argument Brent(Function f,
   {
     auto const& f = minimized_f;
 
-    // We do not use |std::numeric_limits<double>::epsilon()|, because it is 2ϵ
+    // We do not use `std::numeric_limits<double>::epsilon()`, because it is 2ϵ
     // in Brent’s notation: Brent uses ϵ = β^(1-τ) / 2 for rounded arithmetic,
     // see [Bre73], chapter 4, (2.9).
     constexpr double ϵ = ScaleB(0.5, 1 - std::numeric_limits<double>::digits);
diff --git a/numerics/root_finders_test.cpp b/numerics/root_finders_test.cpp
index f0bda425da..0a40a74bc0 100644
--- a/numerics/root_finders_test.cpp
+++ b/numerics/root_finders_test.cpp
@@ -129,8 +129,8 @@ TEST_F(RootFindersTest, WilkinsGuFunction) {
   // Capture everything but the function itself by copy so we have some
   // confidence that the function is pure.
   // We capture f because it is defined recursively.
-  // If non-null, |*evaluations| is incremented when the function is called.
-  // If |expect_brent_calls| is true, this function checks that x is an element
+  // If non-null, `*evaluations` is incremented when the function is called.
+  // If `expect_brent_calls` is true, this function checks that x is an element
   // of the expected sequence X.
   // For x in X, this function returns f(x) as defined at the end of
   // section 4.2.
diff --git a/numerics/unbounded_arrays.hpp b/numerics/unbounded_arrays.hpp
index e4a4ada778..741b1727c8 100644
--- a/numerics/unbounded_arrays.hpp
+++ b/numerics/unbounded_arrays.hpp
@@ -113,7 +113,7 @@ class UnboundedMatrix final {
   UnboundedMatrix(std::int64_t rows, std::int64_t columns);
   UnboundedMatrix(std::int64_t rows, std::int64_t columns, uninitialized_t);
 
-  // The |data| must be in row-major format and must be for a square matrix.
+  // The `data` must be in row-major format and must be for a square matrix.
   UnboundedMatrix(std::initializer_list<Scalar> data);
 
   UnboundedMatrix(std::int64_t rows, std::int64_t columns,
@@ -127,13 +127,13 @@ class UnboundedMatrix final {
                          UnboundedMatrix const& right) = default;
 
   // For  0 ≤ i < rows and 0 ≤ j < columns, the entry a_ij is accessed as
-  // |a(i, j)|.  If i and j do not satisfy these conditions, the expression
-  // |a(i, j)| implies undefined behaviour.
+  // `a(i, j)`.  If i and j do not satisfy these conditions, the expression
+  // `a(i, j)` implies undefined behaviour.
   Scalar& operator()(std::int64_t row, std::int64_t column);
   Scalar const& operator()(std::int64_t row, std::int64_t column) const;
 
   // Applies the matrix as a bilinear form.  Present for compatibility with
-  // |SymmetricBilinearForm|.  Prefer to use |TransposedView| and |operator*|.
+  // `SymmetricBilinearForm`.  Prefer to use `TransposedView` and `operator*`.
   template<typename LScalar, typename RScalar>
   Product<Scalar, Product<LScalar, RScalar>>
       operator()(UnboundedVector<LScalar> const& left,
@@ -173,7 +173,7 @@ class UnboundedLowerTriangularMatrix final {
   explicit UnboundedLowerTriangularMatrix(std::int64_t rows);
   UnboundedLowerTriangularMatrix(std::int64_t rows, uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   UnboundedLowerTriangularMatrix(std::initializer_list<Scalar> data);
 
   explicit UnboundedLowerTriangularMatrix(
@@ -186,8 +186,8 @@ class UnboundedLowerTriangularMatrix final {
   friend bool operator!=(UnboundedLowerTriangularMatrix const& left,
                          UnboundedLowerTriangularMatrix const& right) = default;
 
-  // For  0 ≤ j ≤ i < rows, the entry a_ij is accessed as |a(i, j)|.
-  // If i and j do not satisfy these conditions, the expression |a(i, j)|
+  // For  0 ≤ j ≤ i < rows, the entry a_ij is accessed as `a(i, j)`.
+  // If i and j do not satisfy these conditions, the expression `a(i, j)`
   // implies undefined behaviour.
   Scalar& operator()(std::int64_t row, std::int64_t column);
   Scalar const& operator()(std::int64_t row, std::int64_t column) const;
@@ -198,7 +198,7 @@ class UnboundedLowerTriangularMatrix final {
   void Extend(std::int64_t extra_rows);
   void Extend(std::int64_t extra_rows, uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   void Extend(std::initializer_list<Scalar> data);
 
   void EraseToEnd(std::int64_t begin_row_index);
@@ -224,7 +224,7 @@ class UnboundedStrictlyUpperTriangularMatrix final {
   explicit UnboundedStrictlyUpperTriangularMatrix(std::int64_t columns);
   UnboundedStrictlyUpperTriangularMatrix(std::int64_t columns, uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   UnboundedStrictlyUpperTriangularMatrix(
       std::initializer_list<Scalar> const& data);
 
@@ -240,8 +240,8 @@ class UnboundedStrictlyUpperTriangularMatrix final {
       UnboundedStrictlyUpperTriangularMatrix const& left,
       UnboundedStrictlyUpperTriangularMatrix const& right) = default;
 
-  // For  0 ≤ i < j < columns, the entry a_ij is accessed as |a(i, j)|.
-  // If i and j do not satisfy these conditions, the expression |a(i, j)|
+  // For  0 ≤ i < j < columns, the entry a_ij is accessed as `a(i, j)`.
+  // If i and j do not satisfy these conditions, the expression `a(i, j)`
   // implies undefined behaviour.
   Scalar& operator()(std::int64_t row, std::int64_t column);
   Scalar const& operator()(std::int64_t row, std::int64_t column) const;
@@ -252,7 +252,7 @@ class UnboundedStrictlyUpperTriangularMatrix final {
   void Extend(std::int64_t extra_columns);
   void Extend(std::int64_t extra_columns, uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   void Extend(std::initializer_list<Scalar> const& data);
 
   void EraseToEnd(std::int64_t begin_column_index);
@@ -290,7 +290,7 @@ class UnboundedUpperTriangularMatrix final {
   explicit UnboundedUpperTriangularMatrix(std::int64_t columns);
   UnboundedUpperTriangularMatrix(std::int64_t columns, uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   UnboundedUpperTriangularMatrix(std::initializer_list<Scalar> const& data);
 
   explicit UnboundedUpperTriangularMatrix(
@@ -303,8 +303,8 @@ class UnboundedUpperTriangularMatrix final {
   friend bool operator!=(UnboundedUpperTriangularMatrix const& left,
                          UnboundedUpperTriangularMatrix const& right) = default;
 
-  // For  0 ≤ i ≤ j < columns, the entry a_ij is accessed as |a(i, j)|.
-  // If i and j do not satisfy these conditions, the expression |a(i, j)|
+  // For  0 ≤ i ≤ j < columns, the entry a_ij is accessed as `a(i, j)`.
+  // If i and j do not satisfy these conditions, the expression `a(i, j)`
   // implies undefined behaviour.
   Scalar& operator()(std::int64_t row, std::int64_t column);
   Scalar const& operator()(std::int64_t row, std::int64_t column) const;
@@ -315,7 +315,7 @@ class UnboundedUpperTriangularMatrix final {
   void Extend(std::int64_t extra_columns);
   void Extend(std::int64_t extra_columns, uninitialized_t);
 
-  // The |data| must be in row-major format.
+  // The `data` must be in row-major format.
   void Extend(std::initializer_list<Scalar> const& data);
 
   void EraseToEnd(std::int64_t begin_column_index);
diff --git a/numerics/unbounded_arrays_body.hpp b/numerics/unbounded_arrays_body.hpp
index ead6491e8c..ed7483e9ee 100644
--- a/numerics/unbounded_arrays_body.hpp
+++ b/numerics/unbounded_arrays_body.hpp
@@ -576,9 +576,9 @@ UnboundedStrictlyUpperTriangularMatrix<Scalar_>::Transpose(
     std::int64_t const current_columns,
     std::int64_t const extra_columns) ->
   std::vector<Scalar, uninitialized_allocator<Scalar>> {
-  // |data| is a trapezoidal slice at the end of the matrix.  This is
+  // `data` is a trapezoidal slice at the end of the matrix.  This is
   // inconvenient to index, so we start by constructing a rectangular array with
-  // |extra_columns| columns and |current_columns + extra_columns| rows padded
+  // `extra_columns` columns and `current_columns + extra_columns` rows padded
   // with junk.
   std::vector<Scalar, uninitialized_allocator<Scalar>> padded;
   {
@@ -746,9 +746,9 @@ UnboundedUpperTriangularMatrix<Scalar_>::Transpose(
     std::int64_t const current_columns,
     std::int64_t const extra_columns) ->
   std::vector<Scalar, uninitialized_allocator<Scalar>> {
-  // |data| is a trapezoidal slice at the end of the matrix.  This is
+  // `data` is a trapezoidal slice at the end of the matrix.  This is
   // inconvenient to index, so we start by constructing a rectangular array with
-  // |extra_columns| columns and |current_columns + extra_columns| rows padded
+  // `extra_columns` columns and `current_columns + extra_columns` rows padded
   // with junk.
   std::vector<Scalar, uninitialized_allocator<Scalar>> padded;
   {
diff --git a/physics/apsides.hpp b/physics/apsides.hpp
index 474a2f726e..6e7d9619a5 100644
--- a/physics/apsides.hpp
+++ b/physics/apsides.hpp
@@ -27,8 +27,8 @@ using namespace principia::physics::_rotating_body;
 using namespace principia::physics::_trajectory;
 using namespace principia::quantities::_quantities;
 
-// Computes the apsides with respect to |reference| for the section given by
-// |begin| and |end| of |trajectory|.  Appends to the given output trajectories
+// Computes the apsides with respect to `reference` for the section given by
+// `begin` and `end` of `trajectory`.  Appends to the given output trajectories
 // one point for each apsis.
 template<typename Frame>
 void ComputeApsides(Trajectory<Frame> const& reference,
@@ -41,7 +41,7 @@ void ComputeApsides(Trajectory<Frame> const& reference,
                     DiscreteTrajectory<Frame>& periapsides);
 
 // Returns the ordered time intervals where there can be a collision with the
-// |reference_body| because the |trajectory| is below its |max_radius|.
+// `reference_body` because the `trajectory` is below its `max_radius`.
 template<typename Frame>
 std::vector<Interval<Instant>> ComputeCollisionIntervals(
     RotatingBody<Frame> const& reference_body,
@@ -51,11 +51,11 @@ std::vector<Interval<Instant>> ComputeCollisionIntervals(
     DiscreteTrajectory<Frame> const& periapsides);
 
 // Computes the first collision between a vessel and a rotating body over the
-// given time |interval| with an accuracy better than |max_collision_error|.
-// Returns |nullopt| if there is no collision over the |interval|.  The
-// |interval| should have been obtained by |ComputeCollisionIntervals|. |radius|
+// given time `interval` with an accuracy better than `max_collision_error`.
+// Returns `nullopt` if there is no collision over the `interval`.  The
+// `interval` should have been obtained by `ComputeCollisionIntervals`. `radius`
 // must give the radius of the celestial at a particular position given by its
-// latitude and longitude.  It must never exceed the |max_radius| of the body.
+// latitude and longitude.  It must never exceed the `max_radius` of the body.
 template<typename Frame>
 std::optional<typename DiscreteTrajectory<Frame>::value_type>
 ComputeFirstCollision(
@@ -67,11 +67,11 @@ ComputeFirstCollision(
     std::function<Length(Angle const& latitude, Angle const& longitude)> const&
         radius);
 
-// Computes the crossings of the section given by |begin| and |end| of
-// |trajectory| with the xy plane.  Appends the crossings that go towards the
-// |north| side of the xy plane to |ascending|, and those that go away from the
-// |north| side to |descending|.
-// Nodes for which |predicate| returns false are excluded.
+// Computes the crossings of the section given by `begin` and `end` of
+// `trajectory` with the xy plane.  Appends the crossings that go towards the
+// `north` side of the xy plane to `ascending`, and those that go away from the
+// `north` side to `descending`.
+// Nodes for which `predicate` returns false are excluded.
 template<typename Frame, typename Predicate = ConstantFunction<bool>>
 absl::Status ComputeNodes(Trajectory<Frame> const& trajectory,
                           typename DiscreteTrajectory<Frame>::iterator begin,
@@ -83,8 +83,8 @@ absl::Status ComputeNodes(Trajectory<Frame> const& trajectory,
                           DiscreteTrajectory<Frame>& descending,
                           Predicate predicate = Identically(true));
 
-// TODO(egg): when we can usefully iterate over an arbitrary |Trajectory|, move
-// the following from |Ephemeris|.
+// TODO(egg): when we can usefully iterate over an arbitrary `Trajectory`, move
+// the following from `Ephemeris`.
 #if 0
 template<typename Frame>
 void ComputeApsides(Trajectory<Frame> const& trajectory1,
diff --git a/physics/apsides_body.hpp b/physics/apsides_body.hpp
index e3754d76f6..8e1ef71dfa 100644
--- a/physics/apsides_body.hpp
+++ b/physics/apsides_body.hpp
@@ -40,7 +40,7 @@ using namespace principia::quantities::_si;
 
 // This number was selected in game to obtain good performance without missing
 // collisions.  It was found that that one evaluation of
-// |height_above_terrain_at_time| costs around 15 µs, and that the number of
+// `height_above_terrain_at_time` costs around 15 µs, and that the number of
 // evaluations grows roughly linearly with the degree.  This is probably because
 // the terrain is very bumpy, so even a high degree doesn't approximate it well,
 // and the number of subdivisions end up being largely independent from the
@@ -48,7 +48,7 @@ using namespace principia::quantities::_si;
 // be evaluated 5 times per interval we could easily miss significant features
 // of the terrain.
 constexpr int max_чебышёв_degree = 8;
-// The error bound |max_collision_error| is guaranteed to be met if the vessel
+// The error bound `max_collision_error` is guaranteed to be met if the vessel
 // is slower than this.
 constexpr Speed max_collision_speed = 10'000 * Metre / Second;
 
@@ -82,7 +82,7 @@ void ComputeApsides(Trajectory<Frame> const& reference,
     RelativeDegreesOfFreedom<Frame> const relative =
         degrees_of_freedom - body_degrees_of_freedom;
     Square<Length> const squared_distance = relative.displacement().Norm²();
-    // This is the derivative of |squared_distance|.
+    // This is the derivative of `squared_distance`.
     Variation<Square<Length>> const squared_distance_derivative =
         2.0 * InnerProduct(relative.displacement(), relative.velocity());
 
@@ -93,8 +93,8 @@ void ComputeApsides(Trajectory<Frame> const& reference,
             previous_degrees_of_freedom &&
             previous_squared_distance);
 
-      // The derivative of |squared_distance| changed sign.  Construct a Hermite
-      // approximation of |squared_distance| and find its extrema.
+      // The derivative of `squared_distance` changed sign.  Construct a Hermite
+      // approximation of `squared_distance` and find its extrema.
       Hermite3<Square<Length>, Instant> const
           squared_distance_approximation(
               {*previous_time, time},
@@ -117,12 +117,12 @@ void ComputeApsides(Trajectory<Frame> const& reference,
       }
       if (valid_extrema != 1) {
         // Something went wrong when finding the extrema of
-        // |squared_distance_approximation|. Use a linear interpolation of
-        // |squared_distance_derivative| instead.
+        // `squared_distance_approximation`. Use a linear interpolation of
+        // `squared_distance_derivative` instead.
         apsis_time = Barycentre({time, *previous_time},
                                 {*previous_squared_distance_derivative,
                                  -squared_distance_derivative});
-        // This happens if |*previous_squared_distance_derivative| is 0.  It is
+        // This happens if `*previous_squared_distance_derivative` is 0.  It is
         // indicative of ill-conditioning, but not in and of itself a problem.
         LOG_IF(WARNING, apsis_time == previous_time)
             << "Suspicious apsis at the beginning of a time interval: "
@@ -137,10 +137,10 @@ void ComputeApsides(Trajectory<Frame> const& reference,
 
       // Now that we know the time of the apsis, use a Hermite approximation to
       // derive its degrees of freedom.  Note that an extremum of
-      // |squared_distance_approximation| is in general not an extremum for
-      // |position_approximation|: the distance computed using the latter is a
+      // `squared_distance_approximation` is in general not an extremum for
+      // `position_approximation`: the distance computed using the latter is a
       // 6th-degree polynomial.  However, approximating this polynomial using a
-      // 3rd-degree polynomial would yield |squared_distance_approximation|, so
+      // 3rd-degree polynomial would yield `squared_distance_approximation`, so
       // we shouldn't be far from the truth.
       DegreesOfFreedom<Frame> const apsis_degrees_of_freedom =
           trajectory.EvaluateDegreesOfFreedom(apsis_time);
@@ -195,8 +195,8 @@ std::vector<Interval<Instant>> ComputeCollisionIntervals(
     return {};
   }
 
-  // Initialize the iterators.  After this block |it| designates the first
-  // periapsis and |previous_it| designates the previous apoapsis, if there is
+  // Initialize the iterators.  After this block `it` designates the first
+  // periapsis and `previous_it` designates the previous apoapsis, if there is
   // one, or is past the end.
   absl::btree_set<Instant>::const_iterator it;
   absl::btree_set<Instant>::const_iterator previous_it;
@@ -255,12 +255,12 @@ std::vector<Interval<Instant>> ComputeCollisionIntervals(
 
   std::vector<Interval<Instant>> intervals;
   for (; it != apsides_times.end(); previous_it = it, ++it) {
-    // Here |it| designates a periapsis, and |previous_it| the previous
+    // Here `it` designates a periapsis, and `previous_it` the previous
     // apoapsis, or is past-the-end if there is no previous apoapsis (only the
     // first time through the outer loop).
     Instant const periapsis_time = *it;
 
-    // No collision is possible if the periapsis is above |max_radius|.
+    // No collision is possible if the periapsis is above `max_radius`.
     if (squared_distance_from_centre(periapsis_time) < max_radius²) {
       Interval<Instant> interval;
       if (previous_it == apsides_times.end()) {
@@ -273,7 +273,7 @@ std::vector<Interval<Instant>> ComputeCollisionIntervals(
         CHECK_LE(apoapsis_time, periapsis_time);
 
         if (squared_distance_from_centre(apoapsis_time) > max_radius²) {
-          // The periapsis is below |max_radius| and the preceding apoapsis is
+          // The periapsis is below `max_radius` and the preceding apoapsis is
           // above.  Find the intersection point.
           interval.min = Brent(
               [max_radius²,
@@ -283,28 +283,28 @@ std::vector<Interval<Instant>> ComputeCollisionIntervals(
               apoapsis_time,
               periapsis_time);
         } else {
-          // An apoapsis below |max_radius| can only happen the first time
+          // An apoapsis below `max_radius` can only happen the first time
           // through the loop because the nested loop below skips the other
           // ones.
           CHECK_EQ(apoapsis_time, trajectory.t_min());
           interval.min = apoapsis_time;
         }
       }
-      // Here |interval.min| has been computed and is the time where the
-      // trajectory descends below |max_radius|.
+      // Here `interval.min` has been computed and is the time where the
+      // trajectory descends below `max_radius`.
 
-      // Loop until we find an apoapsis above |max_radius|, or we reach the end
-      // of |apsides_time|.
+      // Loop until we find an apoapsis above `max_radius`, or we reach the end
+      // of `apsides_time`.
       do {
-        // Here |it| denotes a periapsis below |max_radius| and |previous_it|
+        // Here `it` denotes a periapsis below `max_radius` and `previous_it`
         // the preceding apoapsis or is past-the-end if there is no previous
         // apoapsis (only the first time through the outer and inner loops).
         Instant const periapsis_time = *it;
         previous_it = it;
         ++it;
 
-        // Here |it| denotes an apoapsis or is past-the-end.  |previous_it| is
-        // the previous periapsis, which is below |max_radius|.
+        // Here `it` denotes an apoapsis or is past-the-end.  `previous_it` is
+        // the previous periapsis, which is below `max_radius`.
         if (it == apsides_times.end()) {
           break;
         }
@@ -312,7 +312,7 @@ std::vector<Interval<Instant>> ComputeCollisionIntervals(
         CHECK_LE(periapsis_time, apoapsis_time);
 
         if (squared_distance_from_centre(apoapsis_time) > max_radius²) {
-          // The periapsis is below |max_radius| and the following apoapsis is
+          // The periapsis is below `max_radius` and the following apoapsis is
           // above.  Find the intersection point.
           interval.max = Brent(
               [max_radius²,
@@ -327,41 +327,41 @@ std::vector<Interval<Instant>> ComputeCollisionIntervals(
         previous_it = it;
         ++it;
 
-        // Here |it| denotes a periapsis or is past-the end.  |previous_it| is
-        // the previous apoapsis, which is below |max_radius|.  Therefore, the
-        // periapsis denoted by |it| is below |max_radius|.
+        // Here `it` denotes a periapsis or is past-the end.  `previous_it` is
+        // the previous apoapsis, which is below `max_radius`.  Therefore, the
+        // periapsis denoted by `it` is below `max_radius`.
       } while (it != apsides_times.end());
 
       if (it == apsides_times.end()) {
         // If we reach the end of the set, the last element, denoted by
-        // |previous_it|, may be a periapsis (first break in the loop above) or
-        // an apoapsis (while condition).  In both cases, |previous_it| denotes
+        // `previous_it`, may be a periapsis (first break in the loop above) or
+        // an apoapsis (while condition).  In both cases, `previous_it` denotes
         // the extremity of the trajectory.
         interval.max = *previous_it;
         intervals.push_back(interval);
         break;
       }
 
-      // |interval.max| has been computed using Brent (second break in the loop
+      // `interval.max` has been computed using Brent (second break in the loop
       // above).
       intervals.push_back(interval);
 
-      // Here |it| designates an apoapsis above |max_radius|.  |previous_it| is
-      // the previous periapsis, which is below |max_radius|.  The outer loop
-      // increment moves |previous_it| to denote the apoapsis and |it| to denote
+      // Here `it` designates an apoapsis above `max_radius`.  `previous_it` is
+      // the previous periapsis, which is below `max_radius`.  The outer loop
+      // increment moves `previous_it` to denote the apoapsis and `it` to denote
       // the next periapsis or to be past-the-end.
     } else {
-      // Here |it| designates a periapsis above |max_radius|, and |previous_it|
+      // Here `it` designates a periapsis above `max_radius`, and `previous_it`
       // the previous apoapsis, or is past-the-end if there is no previous
       // apoapsis (only the first time through the outer loop).
       previous_it = it;
       ++it;
-      // Here |it| denotes an apoapsis or is past-the-end.  |previous_it| is
-      // the previous periapsis, which is above |max_radius|.  Therefore, the
-      // apoapsis denoted by |it| is above |max_radius|.
+      // Here `it` denotes an apoapsis or is past-the-end.  `previous_it` is
+      // the previous periapsis, which is above `max_radius`.  Therefore, the
+      // apoapsis denoted by `it` is above `max_radius`.
       if (it == apsides_times.end()) {
-        // Reached the end of |apsides_times| with a periapsis above
-        // |max_radius|.  No interval to produce.
+        // Reached the end of `apsides_times` with a periapsis above
+        // `max_radius`.  No interval to produce.
         break;
       }
     }
@@ -430,8 +430,8 @@ ComputeFirstCollision(
        &number_of_evaluations](auto interpolant) -> bool {
     if (interpolant->MayHaveRealRoots()) {
       // The relative error on the roots is choosen so that it corresponds to an
-      // absolute error in distance similar to |max_collision_error|, assuming
-      // that the speed is below |max_collision_speed|.  We don't care too much
+      // absolute error in distance similar to `max_collision_error`, assuming
+      // that the speed is below `max_collision_speed`.  We don't care too much
       // about the performance of this computation, because the zero-free test
       // is very efficient.
       auto const& real_roots = interpolant->RealRoots(
@@ -509,7 +509,7 @@ absl::Status ComputeNodes(
     if (previous_z && Sign(z) != Sign(*previous_z)) {
       CHECK(previous_time && previous_z_speed);
 
-      // |z| changed sign.  Construct a Hermite approximation of |z| and find
+      // `z` changed sign.  Construct a Hermite approximation of `z` and find
       // its zeros.
       Hermite3<Length, Instant> const z_approximation(
           {*previous_time, time},
@@ -538,7 +538,7 @@ absl::Status ComputeNodes(
       if (predicate(node_degrees_of_freedom)) {
         if (Sign(InnerProduct(north, Vector<double, Frame>({0, 0, 1}))) ==
             Sign(z_speed)) {
-          // |north| is up and we are going up, or |north| is down and we are
+          // `north` is up and we are going up, or `north` is down and we are
           // going down.
           ascending.Append(node_time, node_degrees_of_freedom).IgnoreError();
         } else {
diff --git a/physics/apsides_test.cpp b/physics/apsides_test.cpp
index d9d0a24e17..bc74fe0298 100644
--- a/physics/apsides_test.cpp
+++ b/physics/apsides_test.cpp
@@ -250,7 +250,7 @@ TEST_F(ApsidesTest, ComputeFirstCollision) {
   DiscreteTrajectory<World> reference_trajectory;
   DiscreteTrajectory<World> vessel_trajectory;
 
-  // At |t0| the vessel is inside the celestial, so we expect the collision at a
+  // At `t0` the vessel is inside the celestial, so we expect the collision at a
   // negative time.
   AppendTrajectoryTimeline(
       NewLinearTrajectoryTimeline(
@@ -476,14 +476,14 @@ TEST_F(ApsidesTest, ComputeNodes) {
 
 #endif
 
-// A dedicated fixture for |ComputeCollisionIntervals| because we have many
+// A dedicated fixture for `ComputeCollisionIntervals` because we have many
 // tests for that function.
 class ApsidesTest_ComputeCollisionIntervals : public ::testing::Test {
  protected:
   using World = Frame<struct WorldTag, Inertial>;
 
   ApsidesTest_ComputeCollisionIntervals()
-      :  // Only |max_radius| matters for the body.
+      :  // Only `max_radius` matters for the body.
         body_(1 * Kilogram,
               RotatingBody<World>::Parameters(
                   /*min_radius=*/2 * Metre,
@@ -510,7 +510,7 @@ class ApsidesTest_ComputeCollisionIntervals : public ::testing::Test {
 };
 
 // A linear trajectory that intersects the body.  There is one periapsis below
-// |max_radius| and two sentinel apoapsides at the extremities of the
+// `max_radius` and two sentinel apoapsides at the extremities of the
 // trajectory.
 TEST_F(ApsidesTest_ComputeCollisionIntervals, OnePeriapsisBelowMaxRadius) {
   DiscreteTrajectory<World> vessel_trajectory;
@@ -552,7 +552,7 @@ TEST_F(ApsidesTest_ComputeCollisionIntervals, OnePeriapsisBelowMaxRadius) {
 }
 
 // A linear trajectory that does not intersect the body.  There is one periapsis
-// above |max_radius|.
+// above `max_radius`.
 TEST_F(ApsidesTest_ComputeCollisionIntervals, OnePeriapsisAboveMaxRadius) {
   DiscreteTrajectory<World> vessel_trajectory;
   AppendTrajectoryTimeline(
@@ -627,7 +627,7 @@ TEST_F(ApsidesTest_ComputeCollisionIntervals, NoPeriapsis) {
 }
 
 // Two perpendicular linear trajectory segments resulting in an apoapsis
-// below |max_radius| and two periapsides.
+// below `max_radius` and two periapsides.
 TEST_F(ApsidesTest_ComputeCollisionIntervals, OneApoapsisBelowMaxRadius) {
   DiscreteTrajectory<World> vessel_trajectory;
   AppendTrajectoryTimeline(
@@ -680,7 +680,7 @@ TEST_F(ApsidesTest_ComputeCollisionIntervals, OneApoapsisBelowMaxRadius) {
 }
 
 // Two linear trajectory segments at 45° resulting in an apoapsis above
-// |max_radius| and two periapsides.
+// `max_radius` and two periapsides.
 TEST_F(ApsidesTest_ComputeCollisionIntervals, OneApoapsisAboveMaxRadius) {
   DiscreteTrajectory<World> vessel_trajectory;
   AppendTrajectoryTimeline(
@@ -735,8 +735,8 @@ TEST_F(ApsidesTest_ComputeCollisionIntervals, OneApoapsisAboveMaxRadius) {
 }
 
 // Two linear trajectory segments at 45° resulting in an apoapsis above
-// |max_radius| followed by a periapsis below |max_radius|.  The initial point
-// acts as a periapsis below |max_radius|.
+// `max_radius` followed by a periapsis below `max_radius`.  The initial point
+// acts as a periapsis below `max_radius`.
 TEST_F(ApsidesTest_ComputeCollisionIntervals,
        InitialPeriapsisOneApoapsisOnePeriapsis) {
   DiscreteTrajectory<World> vessel_trajectory;
@@ -792,8 +792,8 @@ TEST_F(ApsidesTest_ComputeCollisionIntervals,
 }
 
 // Two linear trajectory segments at 45° resulting in a periapsis below
-// |max_radius| followed by an apoapsis above |max_radius|.  The final point
-// acts as a periapsis below |max_radius|.
+// `max_radius` followed by an apoapsis above `max_radius`.  The final point
+// acts as a periapsis below `max_radius`.
 TEST_F(ApsidesTest_ComputeCollisionIntervals,
        OnePeriapsisOneApoapsisFinalPeriapsis) {
   DiscreteTrajectory<World> vessel_trajectory;
@@ -850,7 +850,7 @@ TEST_F(ApsidesTest_ComputeCollisionIntervals,
 }
 
 // Two linear trajectory segments at 45° resulting in a periapsis below
-// |max_radius| followed by an apoapsis above |max_radius|.
+// `max_radius` followed by an apoapsis above `max_radius`.
 TEST_F(ApsidesTest_ComputeCollisionIntervals, OnePeriapsisOneApoapsis) {
   DiscreteTrajectory<World> vessel_trajectory;
   AppendTrajectoryTimeline(
@@ -902,8 +902,8 @@ TEST_F(ApsidesTest_ComputeCollisionIntervals, OnePeriapsisOneApoapsis) {
                   AlmostEquals(t0_ + (4 + Sqrt(3)) * Second, 1))));
 }
 
-// A linear trajectory with a periapsis below |max_radius|.  The initial point
-// acts as an apoapsis below |max_radius|.
+// A linear trajectory with a periapsis below `max_radius`.  The initial point
+// acts as an apoapsis below `max_radius`.
 TEST_F(ApsidesTest_ComputeCollisionIntervals, InitialApoapsisOnePeriapsis) {
   DiscreteTrajectory<World> vessel_trajectory;
   AppendTrajectoryTimeline(
@@ -943,8 +943,8 @@ TEST_F(ApsidesTest_ComputeCollisionIntervals, InitialApoapsisOnePeriapsis) {
                               AlmostEquals(t0_ + (1 + Sqrt(3)) * Second, 0))));
 }
 
-// A linear trajectory with a periapsis below |max_radius|.  The final point
-// acts as an apoapsis below |max_radius|.
+// A linear trajectory with a periapsis below `max_radius`.  The final point
+// acts as an apoapsis below `max_radius`.
 TEST_F(ApsidesTest_ComputeCollisionIntervals, OnePeriapsisFinalApoapsis) {
   DiscreteTrajectory<World> vessel_trajectory;
   AppendTrajectoryTimeline(
diff --git a/physics/barycentric_rotating_reference_frame.hpp b/physics/barycentric_rotating_reference_frame.hpp
index 65dbf1b2b0..d2064519fe 100644
--- a/physics/barycentric_rotating_reference_frame.hpp
+++ b/physics/barycentric_rotating_reference_frame.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |RigidReferenceFrame| must
+// The files containing the tree of child classes of `RigidReferenceFrame` must
 // be included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
@@ -51,7 +51,7 @@ using namespace principia::quantities::_tuples;
 // points to the barycentre of the secondaries.  The Y axis is in the direction
 // of the velocity of the barycentre of the secondaries with respect to the
 // primary.  The Z axis is in the direction of the angular momentum of the
-// system.  The basis has the same orientation as |InertialFrame|.
+// system.  The basis has the same orientation as `InertialFrame`.
 // Note that if the angular momentum of the system varies, the angular velocity
 // of the frame need not be along its Z axis.
 template<typename InertialFrame, typename ThisFrame>
@@ -139,7 +139,7 @@ class BarycentricRotatingReferenceFrame
   GravitationalParameter const primary_gravitational_parameter_;
   GravitationalParameter const secondary_gravitational_parameter_;
   mutable absl::Mutex lock_;
-  // These members optimize costly computations from |BarycentreDerivative| in
+  // These members optimize costly computations from `BarycentreDerivative` in
   // the frequent case where properties of the frame are repeatedly requested
   // for the same time.
   mutable CachedDerivatives last_evaluated_primary_derivatives_
diff --git a/physics/body.hpp b/physics/body.hpp
index fc32ca4e14..4e0c6b454f 100644
--- a/physics/body.hpp
+++ b/physics/body.hpp
@@ -43,8 +43,8 @@ class Body {
 
  private:
   // A helper struct which is here just so that we can specialize it on
-  // |is_inertial|.  This is necessary because we cannot dynamic cast to
-  // OblateBody<Frame> if |Frame| is not inertial.
+  // `is_inertial`.  This is necessary because we cannot dynamic cast to
+  // OblateBody<Frame> if `Frame` is not inertial.
   template<typename Frame, bool is_inertial>
   struct CompatibilityHelper : not_constructible {
      static bool is_compatible_with(not_null<Body const*> body);
diff --git a/physics/body_centred_body_direction_reference_frame.hpp b/physics/body_centred_body_direction_reference_frame.hpp
index c156bde7ff..89a7c7666e 100644
--- a/physics/body_centred_body_direction_reference_frame.hpp
+++ b/physics/body_centred_body_direction_reference_frame.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |RigidReferenceFrame| must
+// The files containing the tree of child classes of `RigidReferenceFrame` must
 // be included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
@@ -46,7 +46,7 @@ using namespace principia::quantities::_named_quantities;
 // axis points to the secondary.  The Y axis is in the direction of the velocity
 // of the secondary with respect to the primary.  The Z axis is in the direction
 // of the angular velocity of the system.  The basis has the same orientation as
-// |InertialFrame|.
+// `InertialFrame`.
 template<typename InertialFrame, typename ThisFrame>
 class BodyCentredBodyDirectionReferenceFrame
     : public RigidReferenceFrame<InertialFrame, ThisFrame> {
diff --git a/physics/body_centred_body_direction_reference_frame_test.cpp b/physics/body_centred_body_direction_reference_frame_test.cpp
index a7d018b74c..0aaa0fa0b7 100644
--- a/physics/body_centred_body_direction_reference_frame_test.cpp
+++ b/physics/body_centred_body_direction_reference_frame_test.cpp
@@ -261,7 +261,7 @@ TEST_F(BodyCentredBodyDirectionReferenceFrameTest, ConstructFromOneBody) {
     EXPECT_THAT(
         (dof_from_discrete.velocity() - dof_from_both_bodies.velocity()).Norm(),
         VanishesBefore(1 * Kilo(Metre) / Second, 0, 93));
-    // For the moment, the |BodyCentredBodyDirectionReferenceFrame| assumes that
+    // For the moment, the `BodyCentredBodyDirectionReferenceFrame` assumes that
     // its reference trajectories are free-falling, and gives us the wrong
     // geometric acceleration when this is not the case.
     auto const intrinsic_acceleration =
diff --git a/physics/body_centred_non_rotating_reference_frame.hpp b/physics/body_centred_non_rotating_reference_frame.hpp
index 660fa653d7..6471f7915f 100644
--- a/physics/body_centred_non_rotating_reference_frame.hpp
+++ b/physics/body_centred_non_rotating_reference_frame.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |RigidReferenceFrame| must
+// The files containing the tree of child classes of `RigidReferenceFrame` must
 // be included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
@@ -39,20 +39,20 @@ using namespace principia::physics::_rigid_reference_frame;
 using namespace principia::quantities::_named_quantities;
 
 // The origin of the frame is the centre of mass of the body.  The Y axis is at
-// the intersection of the equator and the XY plane of |InertialFrame|, in the
-// direction 90° + α from the X axis of |InertialFrame|, where α is the right
-// ascension of the |polar_axis|.  The Z axis is the |polar_axis|.  The X axis
+// the intersection of the equator and the XY plane of `InertialFrame`, in the
+// direction 90° + α from the X axis of `InertialFrame`, where α is the right
+// ascension of the `polar_axis`.  The Z axis is the `polar_axis`.  The X axis
 // in on the equator so that the frame has the same orientation as
-// |InertialFrame|.
-// For a non-rotating body, the axes are the same as those of |InertialFrame|.
-// With respect to figure 1 of the 2015 report of the IAU WGCCRE if |polar_axis|
-// is the north pole, or figure 2 if |polar_axis| is the positive pole,
+// `InertialFrame`.
+// For a non-rotating body, the axes are the same as those of `InertialFrame`.
+// With respect to figure 1 of the 2015 report of the IAU WGCCRE if `polar_axis`
+// is the north pole, or figure 2 if `polar_axis` is the positive pole,
 // - the Y axis is the node Q from the figure;
 // - the Z axis is the pole Z from the figure.
-// Note that, when |InertialFrame| is the ICRS, these axes make |ThisFrame| the
-// usual celestial reference frame (the GCRS) if |centre| is the Earth, as the X
-// axis will point towards ♈︎; however, if |centre| is another planet,
-// |ThisFrame| will not have the axes of its natural celestial reference frame,
+// Note that, when `InertialFrame` is the ICRS, these axes make `ThisFrame` the
+// usual celestial reference frame (the GCRS) if `centre` is the Earth, as the X
+// axis will point towards ♈︎; however, if `centre` is another planet,
+// `ThisFrame` will not have the axes of its natural celestial reference frame,
 // as the X axis will not point towards its equinox.
 template<typename InertialFrame, typename ThisFrame>
 class BodyCentredNonRotatingReferenceFrame
diff --git a/physics/body_centred_non_rotating_reference_frame_body.hpp b/physics/body_centred_non_rotating_reference_frame_body.hpp
index 7e203f272b..c9f674c805 100644
--- a/physics/body_centred_non_rotating_reference_frame_body.hpp
+++ b/physics/body_centred_non_rotating_reference_frame_body.hpp
@@ -31,9 +31,9 @@ BodyCentredNonRotatingReferenceFrame(
       centre_(std::move(centre)),
       centre_trajectory_(ephemeris_->trajectory(centre_)),
       orthogonal_map_([this]() {
-        // Note that we cannot do this by making |equatorial| and
-        // |biequatorial| virtual members of |MassiveBody|, because that
-        // class is not templatized on |InertialFrame|.
+        // Note that we cannot do this by making `equatorial` and
+        // `biequatorial` virtual members of `MassiveBody`, because that
+        // class is not templatized on `InertialFrame`.
         auto const rotating_body =
             dynamic_cast<RotatingBody<InertialFrame> const*>(&*centre_);
         if (rotating_body == nullptr) {
diff --git a/physics/body_surface_frame_field.hpp b/physics/body_surface_frame_field.hpp
index f6b19e672b..d9efcf38f4 100644
--- a/physics/body_surface_frame_field.hpp
+++ b/physics/body_surface_frame_field.hpp
@@ -23,9 +23,9 @@ using namespace principia::physics::_ephemeris;
 using namespace principia::physics::_frame_field;
 using namespace principia::physics::_rotating_body;
 
-// The z-axis goes from the point |q| to the centre of |body| at |t|  The
+// The z-axis goes from the point `q` to the centre of `body` at `t`  The
 // x-axis is orthogonal to the z-axis and in the plane defined by the z-axis and
-// the polar axis of |body|; its angle with the polar axis is less than π/2 in
+// the polar axis of `body`; its angle with the polar axis is less than π/2 in
 // absolute value.  The y-axis is chosen to form a direct basis.  In other
 // words, the frame field is (north, east, nadir).
 template<typename Frame, typename ThisFrame>
diff --git a/physics/body_surface_frame_field_body.hpp b/physics/body_surface_frame_field_body.hpp
index 93e62d07b5..809f26b93a 100644
--- a/physics/body_surface_frame_field_body.hpp
+++ b/physics/body_surface_frame_field_body.hpp
@@ -33,7 +33,7 @@ BodySurfaceFrameField<Frame, ThisFrame>::FromThisFrame(
       InnerProduct(zenith, body_axis_);
   double const axis_projection² = axis_projection * axis_projection;
 
-  // The unit vector |north| is directed along the polar axis.  Note that λ is
+  // The unit vector `north` is directed along the polar axis.  Note that λ is
   // positive.
   double const λ = 1 / Sqrt(1 - axis_projection²);
   auto const μ = -λ * axis_projection;
diff --git a/physics/body_surface_reference_frame.hpp b/physics/body_surface_reference_frame.hpp
index 04e27fd11d..4b86541998 100644
--- a/physics/body_surface_reference_frame.hpp
+++ b/physics/body_surface_reference_frame.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |RigidReferenceFrame| must
+// The files containing the tree of child classes of `RigidReferenceFrame` must
 // be included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
@@ -38,11 +38,11 @@ using namespace principia::quantities::_named_quantities;
 
 // The origin of the frame is the centre of mass of the body.  The X axis is at
 // the intersection of the equator and the prime meridian.  The Z axis is the
-// |polar_axis|.  The Y axis in on the equator so that the frame has the same
-// orientation as |InertialFrame|.
+// `polar_axis`.  The Y axis in on the equator so that the frame has the same
+// orientation as `InertialFrame`.
 // The X, Y, Z axes are the same as those shown on figure 1 of the 2015 report
-// of the IAU WGCCRE if |polar_axis| is the north pole, or figure 2 if
-// |polar_axis| is the positive pole.
+// of the IAU WGCCRE if `polar_axis` is the north pole, or figure 2 if
+// `polar_axis` is the positive pole.
 template<typename InertialFrame, typename ThisFrame>
 class BodySurfaceReferenceFrame : public RigidReferenceFrame<InertialFrame,
                                                              ThisFrame> {
diff --git a/physics/body_test.cpp b/physics/body_test.cpp
index ce411ff7e2..ada6461527 100644
--- a/physics/body_test.cpp
+++ b/physics/body_test.cpp
@@ -147,8 +147,8 @@ TEST_F(BodyTest, MasslessSerializationSuccess) {
   // No members to test in this class, we just check that it doesn't crash.
   massless_body_ = *MasslessBody::ReadFromMessage(message);
 
-  // Dispatching from |Body|.  Need two steps to add const and remove
-  // |not_null|.
+  // Dispatching from `Body`.  Need two steps to add const and remove
+  // `not_null`.
   not_null<std::unique_ptr<Body const>> body = Body::ReadFromMessage(message);
   cast_massless_body = dynamic_cast_not_null<MasslessBody const*>(body.get());
   EXPECT_THAT(cast_massless_body, NotNull());
@@ -171,7 +171,7 @@ TEST_F(BodyTest, MassiveSerializationSuccess) {
   EXPECT_EQ(massive_body_.gravitational_parameter(),
             massive_body.gravitational_parameter());
 
-  // Dispatching from |Body|.
+  // Dispatching from `Body`.
   not_null<std::unique_ptr<Body>> body = Body::ReadFromMessage(message);
   cast_massive_body = dynamic_cast_not_null<MassiveBody*>(body.get());
   EXPECT_THAT(cast_massive_body, NotNull());
@@ -207,7 +207,7 @@ TEST_F(BodyTest, RotatingSerializationSuccess) {
             Angle::ReadFromMessage(
                 rotating_body_extension.declination_of_pole()));
 
-  // Dispatching from |MassiveBody|.
+  // Dispatching from `MassiveBody`.
   not_null<std::unique_ptr<MassiveBody const>> const massive_body =
       MassiveBody::ReadFromMessage(message);
   EXPECT_EQ(rotating_body_.gravitational_parameter(),
@@ -222,7 +222,7 @@ TEST_F(BodyTest, RotatingSerializationSuccess) {
   EXPECT_EQ(rotating_body_.AngleAt(Instant()),
             cast_rotating_body->AngleAt(Instant()));
 
-  // Dispatching from |Body|.
+  // Dispatching from `Body`.
   not_null<std::unique_ptr<Body const>> const body =
       Body::ReadFromMessage(message);
   cast_rotating_body =
@@ -257,7 +257,7 @@ TEST_F(BodyTest, OblateSerializationSuccess) {
             oblate_body_extension.geopotential().row(2).column(0).cos() *
                 LegendreNormalizationFactor(2, 0));
 
-  // Dispatching from |MassiveBody|.
+  // Dispatching from `MassiveBody`.
   not_null<std::unique_ptr<MassiveBody const>> const massive_body =
       MassiveBody::ReadFromMessage(message);
   EXPECT_EQ(oblate_body_.gravitational_parameter(),
@@ -270,7 +270,7 @@ TEST_F(BodyTest, OblateSerializationSuccess) {
   EXPECT_EQ(oblate_body_.j2(), cast_oblate_body->j2());
   EXPECT_EQ(oblate_body_.polar_axis(), cast_oblate_body->polar_axis());
 
-  // Dispatching from |Body|.
+  // Dispatching from `Body`.
   not_null<std::unique_ptr<Body const>> const body =
       Body::ReadFromMessage(message);
   cast_oblate_body =
diff --git a/physics/checkpointer.hpp b/physics/checkpointer.hpp
index 3eaf5f7ddb..be75558145 100644
--- a/physics/checkpointer.hpp
+++ b/physics/checkpointer.hpp
@@ -33,9 +33,9 @@ using namespace principia::quantities::_quantities;
 // timeline may be reconstructed as needed based on the checkpoints.
 // Checkpoints must be created at regular intervals to ensure that the timeline
 // may be reconstructed fast enough.
-// The |Message| must declare a nested message named |Checkpoint|, which must
-// have a field named |time| of type |Point|.  There must be a repeated field of
-// |Checkpoint|s in |Message|.
+// The `Message` must declare a nested message named `Checkpoint`, which must
+// have a field named `time` of type `Point`.  There must be a repeated field of
+// `Checkpoint`s in `Message`.
 // This class is thread-safe.  The callbacks are not run under a lock.
 template<typename Message>
 class Checkpointer {
@@ -59,18 +59,18 @@ class Checkpointer {
   // ever created.
   Instant newest_checkpoint() const EXCLUDES(lock_);
 
-  // Returns the checkpoint at or immediately after |t|, or +∞ if no such
+  // Returns the checkpoint at or immediately after `t`, or +∞ if no such
   // checkpoint exists.
   Instant checkpoint_at_or_after(Instant const& t) const EXCLUDES(lock_);
 
-  // Returns the checkpoint at or immediately before |t|, or -∞ if no such
+  // Returns the checkpoint at or immediately before `t`, or -∞ if no such
   // checkpoint exists.
   Instant checkpoint_at_or_before(Instant const& t) const EXCLUDES(lock_);
 
   // Returns all the checkpoints in this object.
   absl::btree_set<Instant> all_checkpoints() const EXCLUDES(lock_);
 
-  // Returns all the checkpoints at or before |t|.
+  // Returns all the checkpoints at or before `t`.
   absl::btree_set<Instant> all_checkpoints_at_or_before(Instant const& t) const
       EXCLUDES(lock_);
 
@@ -79,36 +79,36 @@ class Checkpointer {
                                                    Instant const& t2) const
       EXCLUDES(lock_);
 
-  // Creates a checkpoint at time |t|, which will be used to recreate the
-  // timeline after |t|.  The checkpoint is constructed by calling the |Writer|
+  // Creates a checkpoint at time `t`, which will be used to recreate the
+  // timeline after `t`.  The checkpoint is constructed by calling the `Writer`
   // passed at construction.
   void WriteToCheckpoint(Instant const& t) EXCLUDES(lock_);
 
   // Same as above, but a checkpoint is only created if one was not created
-  // recently, as specified by |max_time_between_checkpoints|.  Returns true iff
+  // recently, as specified by `max_time_between_checkpoints`.  Returns true iff
   // a new checkpoint was created.
   bool WriteToCheckpointIfNeeded(Instant const& t,
                                  Time const& max_time_between_checkpoints)
       EXCLUDES(lock_);
 
-  // Calls the |Reader| passed at construction to reconstruct an object using
+  // Calls the `Reader` passed at construction to reconstruct an object using
   // the oldest checkpoint.  Returns an error if this object contains no
-  // checkpoint or if the |Reader| returns one.
+  // checkpoint or if the `Reader` returns one.
   absl::Status ReadFromOldestCheckpoint() const EXCLUDES(lock_);
 
-  // Calls the |Reader| passed at construction to reconstruct an object using
+  // Calls the `Reader` passed at construction to reconstruct an object using
   // the newest checkpoint.  Returns an error if this object contains no
-  // checkpoint or if the |Reader| returns one.
+  // checkpoint or if the `Reader` returns one.
   absl::Status ReadFromNewestCheckpoint() const EXCLUDES(lock_);
 
-  // Calls the |Reader| passed at construction to reconstruct an object using
-  // the checkpoint at or immediately before |t|.  Returns an error if no such
-  // checkpoint exists or if the |Reader| returns one.
+  // Calls the `Reader` passed at construction to reconstruct an object using
+  // the checkpoint at or immediately before `t`.  Returns an error if no such
+  // checkpoint exists or if the `Reader` returns one.
   absl::Status ReadFromCheckpointAtOrBefore(Instant const& t) const
       EXCLUDES(lock_);
 
-  // Calls |reader| on the checkpoint at |t|.  Returns an error if there is no
-  // such checkpoint or if |reader| returns one.
+  // Calls `reader` on the checkpoint at `t`.  Returns an error if there is no
+  // such checkpoint or if `reader` returns one.
   absl::Status ReadFromCheckpointAt(Instant const& t,
                                     Reader const& reader) const EXCLUDES(lock_);
 
diff --git a/physics/checkpointer_body.hpp b/physics/checkpointer_body.hpp
index 57c2e9dee5..881afe9fd3 100644
--- a/physics/checkpointer_body.hpp
+++ b/physics/checkpointer_body.hpp
@@ -38,7 +38,7 @@ Instant Checkpointer<Message>::newest_checkpoint() const {
 template<typename Message>
 Instant Checkpointer<Message>::checkpoint_at_or_after(Instant const& t) const {
   absl::ReaderMutexLock l(&lock_);
-  // |it| denotes an entry equal to or greater than |t| (or end).
+  // `it` denotes an entry equal to or greater than `t` (or end).
   auto const it = checkpoints_.lower_bound(t);
   if (it == checkpoints_.cend()) {
     return InfiniteFuture;
@@ -49,7 +49,7 @@ Instant Checkpointer<Message>::checkpoint_at_or_after(Instant const& t) const {
 template<typename Message>
 Instant Checkpointer<Message>::checkpoint_at_or_before(Instant const& t) const {
   absl::ReaderMutexLock l(&lock_);
-  // |it| denotes an entry strictly greater than |t| (or end).
+  // `it` denotes an entry strictly greater than `t` (or end).
   auto const it = checkpoints_.upper_bound(t);
   if (it == checkpoints_.cbegin()) {
     return InfinitePast;
@@ -75,7 +75,7 @@ template<typename Message>
 absl::btree_set<Instant> Checkpointer<Message>::all_checkpoints_at_or_before(
     Instant const& t) const {
   absl::ReaderMutexLock l(&lock_);
-  // |it| denotes an entry strictly greater than |t| (or end).
+  // `it` denotes an entry strictly greater than `t` (or end).
   auto const it = checkpoints_.upper_bound(t);
   absl::btree_set<Instant> result;
   std::transform(
@@ -97,9 +97,9 @@ absl::btree_set<Instant> Checkpointer<Message>::all_checkpoints_between(
   }
 
   absl::ReaderMutexLock l(&lock_);
-  // |it1| denotes an entry greater or equal to |t1| (or end).
+  // `it1` denotes an entry greater or equal to `t1` (or end).
   auto const it1 = checkpoints_.lower_bound(t1);
-  // |it2| denotes an entry strictly greater than |t2| (or end).
+  // `it2` denotes an entry strictly greater than `t2` (or end).
   auto const it2 = checkpoints_.upper_bound(t2);
   absl::btree_set<Instant> result;
   std::transform(
@@ -163,7 +163,7 @@ absl::Status Checkpointer<Message>::ReadFromCheckpointAtOrBefore(
   typename Message::Checkpoint const* checkpoint = nullptr;
   {
     absl::ReaderMutexLock l(&lock_);
-    // |it| denotes an entry strictly greater than |t| (or end).
+    // `it` denotes an entry strictly greater than `t` (or end).
     auto const it = checkpoints_.upper_bound(t);
     if (it == checkpoints_.cbegin()) {
       return absl::NotFoundError("No checkpoint");
diff --git a/physics/clientele.hpp b/physics/clientele.hpp
index f9d3f92875..da2800f350 100644
--- a/physics/clientele.hpp
+++ b/physics/clientele.hpp
@@ -12,15 +12,15 @@ namespace internal {
 using namespace principia::base::_not_null;
 
 // A helper class to manage a set of clients to a service.  Clients are ordered
-// based on the value of type |Key| passed when they join the |Clientele|.  A
-// |Clientele| may contain multiple clients with the same key.
+// based on the value of type `Key` passed when they join the `Clientele`.  A
+// `Clientele` may contain multiple clients with the same key.
 template<typename Key>
 class Clientele {
  public:
-  // The |default_key| is returned by |first| when the object is empty.
+  // The `default_key` is returned by `first` when the object is empty.
   explicit Clientele(Key const& default_key);
 
-  // Indicates that a client with the given |key| is joining or leaving the
+  // Indicates that a client with the given `key` is joining or leaving the
   // clientele.
   void Join(Key const& key);
   void Leave(Key const& key);
@@ -35,7 +35,7 @@ class Clientele {
   absl::btree_multiset<Key> clients_;
 };
 
-// An RAII object to manage clients that join and leave a |Clientele|.
+// An RAII object to manage clients that join and leave a `Clientele`.
 template<typename Key>
 class Client {
  public:
diff --git a/physics/continuous_trajectory.hpp b/physics/continuous_trajectory.hpp
index 6469ba9228..1de847e398 100644
--- a/physics/continuous_trajectory.hpp
+++ b/physics/continuous_trajectory.hpp
@@ -45,16 +45,16 @@ using namespace principia::quantities::_quantities;
 
 // This class is thread-safe, but the client must be aware that if, for
 // instance, the trajectory is appended to asynchronously, successive calls to
-// |t_max()| may return different values.
+// `t_max()` may return different values.
 template<typename Frame>
 class ContinuousTrajectory : public Trajectory<Frame> {
  public:
-  // Constructs a trajectory with the given time |step|.  Because the Чебышёв
+  // Constructs a trajectory with the given time `step`.  Because the Чебышёв
   // polynomials have values in the range [-1, 1], the error resulting of
   // truncating the infinite Чебышёв series to a finite degree are a small
   // multiple of the coefficient of highest degree (assuming that the series
   // converges reasonably well).  Thus, we pick the degree of the series so that
-  // the coefficient of highest degree is less than |tolerance|.
+  // the coefficient of highest degree is less than `tolerance`.
   ContinuousTrajectory(Time const& step,
                        Length const& tolerance);
 
@@ -70,26 +70,26 @@ class ContinuousTrajectory : public Trajectory<Frame> {
   // benchmarking or analyzing performance.  Do not use in real code.
   double average_degree() const EXCLUDES(lock_);
 
-  // Appends one point to the trajectory.  |time| must be after the last time
-  // passed to |Append| if the trajectory is not empty.  The |time|s passed to
-  // successive calls to |Append| must be equally spaced with the |step| given
+  // Appends one point to the trajectory.  `time` must be after the last time
+  // passed to `Append` if the trajectory is not empty.  The `time`s passed to
+  // successive calls to `Append` must be equally spaced with the `step` given
   // at construction.
   absl::Status Append(Instant const& time,
                       DegreesOfFreedom<Frame> const& degrees_of_freedom)
       EXCLUDES(lock_);
 
-  // Prepends the given |trajectory| to this one.  Ideally the last point of
-  // |trajectory| should match the first point of this object.
-  // Note the rvalue reference: |ContinuousTrajectory| is not moveable and not
-  // copyable, but the |InstantPolynomialPairs| are moveable and we really want
+  // Prepends the given `trajectory` to this one.  Ideally the last point of
+  // `trajectory` should match the first point of this object.
+  // Note the rvalue reference: `ContinuousTrajectory` is not moveable and not
+  // copyable, but the `InstantPolynomialPairs` are moveable and we really want
   // to move them.  We could pass by non-const lvalue reference, but we would
   // rather make it clear at the calling site that the object is consumed, so
   // we require the use of std::move.
   void Prepend(ContinuousTrajectory&& trajectory);
 
-  // Implementation of the interface |Trajectory|.
+  // Implementation of the interface `Trajectory`.
 
-  // |t_max| may be less than the last time passed to Append because the
+  // `t_max` may be less than the last time passed to Append because the
   // trajectory cannot be evaluated for the last points, for which no polynomial
   // was constructed.  For an empty trajectory, an infinity with the proper
   // sign is returned.
@@ -123,9 +123,9 @@ class ContinuousTrajectory : public Trajectory<Frame> {
 
   void WriteToMessage(not_null<serialization::ContinuousTrajectory*> message)
       const EXCLUDES(lock_);
-  // The parameter |desired_t_min| indicates that the trajectory must be
+  // The parameter `desired_t_min` indicates that the trajectory must be
   // restored at a checkpoint such that, once it is appended to, its t_min() is
-  // at or before |desired_t_min|.
+  // at or before `desired_t_min`.
   static not_null<std::unique_ptr<ContinuousTrajectory>> ReadFromMessage(
       Instant const& desired_t_min,
       serialization::ContinuousTrajectory const& message)
@@ -139,7 +139,7 @@ class ContinuousTrajectory : public Trajectory<Frame> {
       Checkpointer<serialization::ContinuousTrajectory>::Reader const& reader)
       const;
 
-  // Return functions that can be passed to a |Checkpointer| to write this
+  // Return functions that can be passed to a `Checkpointer` to write this
   // trajectory to a checkpoint or read it back.
   Checkpointer<serialization::ContinuousTrajectory>::Writer
   MakeCheckpointerWriter();
@@ -151,7 +151,7 @@ class ContinuousTrajectory : public Trajectory<Frame> {
   // function of this class) is responsible for synchronization, i.e., for
   // making sure that no mutators execute in parallel with any of the functions
   // having "locked" in their name.  The purpose of this API is to improve the
-  // performance of the |Ephemeris|.
+  // performance of the `Ephemeris`.
 
   Instant t_min_locked() const;
   Instant t_max_locked() const;
@@ -167,10 +167,10 @@ class ContinuousTrajectory : public Trajectory<Frame> {
 
  private:
   // Each polynomial is valid over an interval [t_min, t_max].  Polynomials are
-  // stored in this vector sorted by their |t_max|, as it turns out that we
-  // never need to extract their |t_min|.  Logically, the |t_min| for a
-  // polynomial is the |t_max| of the previous one.  The first polynomial has a
-  // |t_min| which is |*first_time_|.
+  // stored in this vector sorted by their `t_max`, as it turns out that we
+  // never need to extract their `t_min`.  Logically, the `t_min` for a
+  // polynomial is the `t_max` of the previous one.  The first polynomial has a
+  // `t_min` which is `*first_time_`.
   struct InstantPolynomialPair {
     InstantPolynomialPair(
         Instant t_max,
@@ -193,7 +193,7 @@ class ContinuousTrajectory : public Trajectory<Frame> {
       Displacement<Frame>& error_estimate) const;
 
   // Computes the best Newhall approximation based on the desired tolerance.
-  // Adjust the |degree_| and other member variables to stay within the
+  // Adjust the `degree_` and other member variables to stay within the
   // tolerance while minimizing the computational cost and avoiding numerical
   // instabilities.
   absl::Status ComputeBestNewhallApproximation(
@@ -201,9 +201,9 @@ class ContinuousTrajectory : public Trajectory<Frame> {
       std::vector<Position<Frame>> const& q,
       std::vector<Velocity<Frame>> const& v) REQUIRES(lock_);
 
-  // Returns an iterator to the polynomial applicable for the given |time|, or
-  // |begin| if |time| is before the first polynomial or |end| if |time| is
-  // after the last polynomial.  If |time| is the |t_max| of some polynomial,
+  // Returns an iterator to the polynomial applicable for the given `time`, or
+  // `begin` if `time` is before the first polynomial or `end` if `time` is
+  // after the last polynomial.  If `time` is the `t_max` of some polynomial,
   // that polynomial is returned.  Time complexity is O(N Log N).
   typename InstantPolynomialPairs::const_iterator
   FindPolynomialForInstantLocked(Instant const& time) const
@@ -232,7 +232,7 @@ class ContinuousTrajectory : public Trajectory<Frame> {
   InstantPolynomialPairs polynomials_ GUARDED_BY(lock_);
   Policy polynomial_evaluator_policy_;
 
-  // Lookups into |polynomials_| are expensive because they entail a binary
+  // Lookups into `polynomials_` are expensive because they entail a binary
   // search into a vector that grows over time.  In benchmarks, this can be as
   // costly as the polynomial evaluation itself.  The accesses are not random,
   // though, they are clustered in time and (slowly) increasing.  To take
@@ -244,7 +244,7 @@ class ContinuousTrajectory : public Trajectory<Frame> {
   // multithreading it may be that different threads would want to access
   // polynomials at different indices, but by and large the threads progress in
   // parallel, and benchmarks show that there is no adverse performance effects.
-  // Any value in the range of |polynomials_| or 0 is correct.
+  // Any value in the range of `polynomials_` or 0 is correct.
   mutable std::int64_t last_accessed_polynomial_ GUARDED_BY(lock_) = 0;
 
   // The time at which this trajectory starts.  Set for a nonempty trajectory.
@@ -252,7 +252,7 @@ class ContinuousTrajectory : public Trajectory<Frame> {
 
   // The points that have not yet been incorporated in a polynomial.  Nonempty
   // for a nonempty trajectory.
-  // |last_points_.begin()->first == polynomials_.back().t_max|
+  // `last_points_.begin()->first == polynomials_.back().t_max`
   std::vector<std::pair<Instant, DegreesOfFreedom<Frame>>> last_points_
       GUARDED_BY(lock_);
 
diff --git a/physics/continuous_trajectory_body.hpp b/physics/continuous_trajectory_body.hpp
index 26a8983efb..3ff1e7fbdb 100644
--- a/physics/continuous_trajectory_body.hpp
+++ b/physics/continuous_trajectory_body.hpp
@@ -136,7 +136,7 @@ void ContinuousTrajectory<Frame>::Prepend(ContinuousTrajectory&& prefix) {
   if (prefix.polynomials_.empty()) {
     // Nothing to do.
   } else if (polynomials_.empty()) {
-    // All the data comes from |prefix|.  This must set all the fields of
+    // All the data comes from `prefix`.  This must set all the fields of
     // this object that are not set at construction.
     adjusted_tolerance_ = prefix.adjusted_tolerance_;
     is_unstable_ = prefix.is_unstable_;
@@ -159,7 +159,7 @@ void ContinuousTrajectory<Frame>::Prepend(ContinuousTrajectory&& prefix) {
               std::back_inserter(prefix.polynomials_));
     polynomials_.swap(prefix.polynomials_);
     first_time_ = prefix.first_time_;
-    // Note that any |last_points_| in |prefix| are irrelevant because they
+    // Note that any `last_points_` in `prefix` are irrelevant because they
     // correspond to a time interval covered by the first polynomial of this
     // object.
   }
@@ -430,7 +430,7 @@ ContinuousTrajectory<Frame>::ReadFromMessage(
             mutable_coefficient(0)->mutable_point();
         *coefficient0_point->mutable_multivector() = coefficient0_multivector;
 
-        // Note the use of |EstrinWithoutFMA| below.  FMA was introduced in
+        // Note the use of `EstrinWithoutFMA` below.  FMA was introduced in
         // Grossmann, but unfortunately we didn't notice that it was affecting
         // existing flight plans, and we have no way to tell that a save is
         // exactly pre-Grossmann.  On the other hand, we are sure that pre-
@@ -450,7 +450,7 @@ ContinuousTrajectory<Frame>::ReadFromMessage(
                     serialization::PolynomialInMonomialBasis::extension)
                 .has_evaluator()) {
           // The post-Καραθεοδωρή path, do not specify an evaluator when calling
-          // |ReadFromMessage|.
+          // `ReadFromMessage`.
           continuous_trajectory->polynomials_.emplace_back(
               Instant::ReadFromMessage(pair.t_max()),
               Polynomial<Position<Frame>, Instant>::ReadFromMessage(
@@ -515,7 +515,7 @@ ContinuousTrajectory<Frame>::ReadFromMessage(
   // There should always be a checkpoint, either at the end of the trajectory,
   // in the pre-Grassmann compatibility case; or at the first point of the
   // trajectory, for modern saves (see the comment in WriteToMessage).  In the
-  // pre-Grassman case the (only) checkpoint may be after |desired_t_min|, but
+  // pre-Grassman case the (only) checkpoint may be after `desired_t_min`, but
   // then we should have polynomials covering that time, see #3039.
   auto const status =
       continuous_trajectory->checkpointer_->ReadFromCheckpointAtOrBefore(
@@ -735,8 +735,8 @@ absl::Status ContinuousTrajectory<Frame>::ComputeBestNewhallApproximation(
                                 last_points_.cbegin()->first, time,
                                 displacement_error_estimate));
 
-  // Estimate the error.  For initializing |previous_error_estimate|, any value
-  // greater than |error_estimate| will do.
+  // Estimate the error.  For initializing `previous_error_estimate`, any value
+  // greater than `error_estimate` will do.
   Length error_estimate = displacement_error_estimate.Norm();
   Length previous_error_estimate = error_estimate + error_estimate;
 
@@ -814,7 +814,7 @@ template<typename Frame>
 typename ContinuousTrajectory<Frame>::InstantPolynomialPairs::const_iterator
 ContinuousTrajectory<Frame>::FindPolynomialForInstantLocked(
     Instant const& time) const {
-  // This returns the first polynomial |p| such that |time <= p.t_max|.
+  // This returns the first polynomial `p` such that `time <= p.t_max`.
   {
     auto const begin = polynomials_.begin();
     auto const it = begin + last_accessed_polynomial_;
diff --git a/physics/discrete_trajectory.hpp b/physics/discrete_trajectory.hpp
index 9c33c333a0..3b20f611e1 100644
--- a/physics/discrete_trajectory.hpp
+++ b/physics/discrete_trajectory.hpp
@@ -104,7 +104,7 @@ class DiscreteTrajectory : public Trajectory<Frame> {
   absl::Status Append(Instant const& t,
                       DegreesOfFreedom<Frame> const& degrees_of_freedom);
 
-  // Merges |trajectory| (the source) into this object (the target).  The
+  // Merges `trajectory` (the source) into this object (the target).  The
   // operation processes pairs of segments taken from each trajectory and
   // proceeds as follows:
   // 1. If the source segment is empty (or missing), leave the target segment
@@ -125,8 +125,8 @@ class DiscreteTrajectory : public Trajectory<Frame> {
   DegreesOfFreedom<Frame> EvaluateDegreesOfFreedom(
       Instant const& t) const override;
 
-  // The segments in |tracked| are restored at deserialization.  The points
-  // denoted by |exact| are written and re-read exactly and are not affected by
+  // The segments in `tracked` are restored at deserialization.  The points
+  // denoted by `exact` are written and re-read exactly and are not affected by
   // any errors introduced by zfp compression.  The endpoints of each segment
   // are always exact.
   void WriteToMessage(
@@ -141,9 +141,9 @@ class DiscreteTrajectory : public Trajectory<Frame> {
       std::vector<SegmentIterator> const& tracked,
       std::vector<iterator> const& exact) const;
 
-  // |tracked| must have a size appropriate for the |message| being deserialized
-  // and the orders of the |tracked| iterators must be consistent during
-  // serialization and deserialization.  Upon return, the iterators in |tracked|
+  // `tracked` must have a size appropriate for the `message` being deserialized
+  // and the orders of the `tracked` iterators must be consistent during
+  // serialization and deserialization.  Upon return, the iterators in `tracked`
   // are past-the-end iff they were past-the-end at serialization time.
   static DiscreteTrajectory ReadFromMessage(
       serialization::DiscreteTrajectory const& message,
@@ -176,7 +176,7 @@ class DiscreteTrajectory : public Trajectory<Frame> {
   absl::Status ConsistencyStatus() const;
 
   // Updates the segments self-pointers and the time-to-segment mapping after
-  // segments have been spliced from |from| to |to|.  The iterator indicates the
+  // segments have been spliced from `from` to `to`.  The iterator indicates the
   // segments to fix-up.
   static void AdjustAfterSplicing(
       DiscreteTrajectory& from,
@@ -213,10 +213,10 @@ class DiscreteTrajectory : public Trajectory<Frame> {
   // DiscreteTrajectory moves.  This field is never null and never empty.
   not_null<std::unique_ptr<Segments>> segments_;
 
-  // Maps time |t| to the last segment that start at time |t|.  Does not contain
+  // Maps time `t` to the last segment that start at time `t`.  Does not contain
   // entries for empty segments (at the beginning of the trajectory) or for
   // 1-point segments that are not the last at their time.  Empty iff the entire
-  // trajectory is empty.  Always updated using |insert_or_assign| to override
+  // trajectory is empty.  Always updated using `insert_or_assign` to override
   // any preexisting segment with the same endpoint.
   SegmentByLeftEndpoint segment_by_left_endpoint_;
 };
diff --git a/physics/discrete_trajectory_body.hpp b/physics/discrete_trajectory_body.hpp
index d86f36ec7d..e06c5c146d 100644
--- a/physics/discrete_trajectory_body.hpp
+++ b/physics/discrete_trajectory_body.hpp
@@ -178,7 +178,7 @@ DiscreteTrajectory<Frame>::NewSegment() {
     // Duplicate the last point of the previous segment.
     auto const& [last_time, last_degrees_of_freedom] = *last_segment.rbegin();
     new_segment_sit->Append(last_time, last_degrees_of_freedom).IgnoreError();
-    // The use of |insert_or_assign| ensure that we override any entry with the
+    // The use of `insert_or_assign` ensure that we override any entry with the
     // same left endpoint.
     segment_by_left_endpoint_.insert_or_assign(
         segment_by_left_endpoint_.end(), last_time, new_segment_sit);
@@ -217,7 +217,7 @@ DiscreteTrajectory<Frame>::AttachSegments(DiscreteTrajectory trajectory) {
     CHECK_EQ(back().degrees_of_freedom, trajectory.front().degrees_of_freedom)
         << "Mismatching degrees of freedom when attaching segments";
   } else {
-    // If the points are not matching, prepend a matching point to |trajectory|
+    // If the points are not matching, prepend a matching point to `trajectory`
     // and update the time-to-segment map.
     CHECK_LT(back().time, trajectory.front().time)
         << "Mismatching times when attaching segments";
@@ -229,7 +229,7 @@ DiscreteTrajectory<Frame>::AttachSegments(DiscreteTrajectory trajectory) {
     trajectory.segment_by_left_endpoint_.emplace(back().time, sit);
   }
 
-  // The |end| iterator keeps pointing at the end after the splice.  Instead,
+  // The `end` iterator keeps pointing at the end after the splice.  Instead,
   // we track the iterator to the last segment.
   auto const last_before_splice = --segments_->end();
 
@@ -278,9 +278,9 @@ void DiscreteTrajectory<Frame>::ForgetAfter(Instant const& t) {
     return;
   }
 
-  // |FindSegment| gives us the most recent segment comprising |t|.  If |t| is
+  // `FindSegment` gives us the most recent segment comprising `t`.  If `t` is
   // exactly at the beginning of a segment, it is possible that there would be
-  // 1-point segments at |t| before that segment.  Let's find them and include
+  // 1-point segments at `t` before that segment.  Let's find them and include
   // them in the forgetting.
   auto sit = leit->second;
   while (sit != segments_->begin()) {
@@ -292,9 +292,9 @@ void DiscreteTrajectory<Frame>::ForgetAfter(Instant const& t) {
   }
   sit->ForgetAfter(t);
 
-  // Here |sit| designates a segment starting at or after |t|.  If |t| is
+  // Here `sit` designates a segment starting at or after `t`.  If `t` is
   // exactly at the beginning of the segment,
-  // |DiscreteTrajectorySegment::ForgetAfter| will leave it empty.  In that
+  // `DiscreteTrajectorySegment::ForgetAfter` will leave it empty.  In that
   // case we drop the segment entirely, unless it is the only one in the
   // trajectory.
   if (sit->empty()) {
@@ -327,24 +327,24 @@ void DiscreteTrajectory<Frame>::ForgetBefore(Instant const& t) {
     return;
   }
   auto const sit = leit->second;
-  // This call may make the segment |*sit| empty if |t| is after the end of
-  // |*sit|.
-  // NOTE(phl): This declaration is necessary because MSVC corrupts |t| during
+  // This call may make the segment `*sit` empty if `t` is after the end of
+  // `*sit`.
+  // NOTE(phl): This declaration is necessary because MSVC corrupts `t` during
   // the call below.
   Instant const t_saved = t;
   sit->ForgetBefore(t);
   for (auto s = segments_->begin(); s != sit; ++s) {
-    // This call may either make the segment |*s| empty or leave it with a
-    // single point matching |sit->front()|.
+    // This call may either make the segment `*s` empty or leave it with a
+    // single point matching `sit->front()`.
     s->ForgetBefore(t_saved);
   }
 
-  // Erase all the entries before and including |leit|.  These are entries for
+  // Erase all the entries before and including `leit`.  These are entries for
   // now-empty segments or for 1-point segments, and the segment which we may
   // just have truncated.
   segment_by_left_endpoint_.erase(segment_by_left_endpoint_.begin(),
                                   std::next(leit));
-  // It |*sit| is not empty, recreate an entry with its new left endpoint.
+  // It `*sit` is not empty, recreate an entry with its new left endpoint.
   if (!sit->empty()) {
     segment_by_left_endpoint_.insert_or_assign(
         segment_by_left_endpoint_.begin(),
@@ -406,7 +406,7 @@ void DiscreteTrajectory<Frame>::Merge(DiscreteTrajectory<Frame> trajectory) {
       // Merge corresponding segments.
       sit_t->Merge(std::move(*sit_s));
 
-      // If the left endpoint of |sit_t| has changed, remove its entry from the
+      // If the left endpoint of `sit_t` has changed, remove its entry from the
       // time-to-segment map, if any.
       if (left_endpoint.has_value() &&
           sit_t->front().time < left_endpoint.value()) {
@@ -427,7 +427,7 @@ void DiscreteTrajectory<Frame>::Merge(DiscreteTrajectory<Frame> trajectory) {
     } else if (sit_s != trajectory.segments_->end()) {
       // No more segments in the target.  We splice the segments of the source.
 
-      // The |end| iterator keeps pointing at the end after the splice.
+      // The `end` iterator keeps pointing at the end after the splice.
       // Instead, we track the iterator to the last segment.
       auto const last_before_splice = --segments_->end();
 
@@ -511,7 +511,7 @@ void DiscreteTrajectory<Frame>::WriteToMessage(
     std::vector<SegmentIterator> const& tracked,
     std::vector<iterator> const& exact) const {
   // Construct a map to efficiently find if a segment must be tracked.  The
-  // keys are pointers to segments in |tracked|, the values are the
+  // keys are pointers to segments in `tracked`, the values are the
   // corresponding indices.  Note that multiple tracked segments may turn out to
   // be identical.
   std::unordered_multimap<DiscreteTrajectorySegment<Frame> const*, int>
@@ -541,13 +541,13 @@ void DiscreteTrajectory<Frame>::WriteToMessage(
       DiscreteTrajectorySegment<Frame> const*> intersecting_segments;
   bool intersect_range = false;
 
-  // The position of a segment in the repeated field |segment|.
+  // The position of a segment in the repeated field `segment`.
   int segment_position = 0;
   for (auto sit = segments_->begin();
        sit != segments_->end();
        ++sit, ++segment_position) {
-    // Look up in |*sit| the instants that define the range to write.
-    // |lower_bound| returns the past-the-end-of-segment iterator if no point
+    // Look up in `*sit` the instants that define the range to write.
+    // `lower_bound` returns the past-the-end-of-segment iterator if no point
     // exists after the given time, i.e., for the segments that precede the
     // intersection.
     auto const begin_time_it = sit->lower_bound(begin_time);
@@ -560,7 +560,7 @@ void DiscreteTrajectory<Frame>::WriteToMessage(
       break;
     }
 
-    // If |*sit| contains a point at or after |begin_time|, it intersects the
+    // If `*sit` contains a point at or after `begin_time`, it intersects the
     // range to write.
     intersect_range = begin_time_it != sit->end();
     if (intersect_range) {
@@ -577,8 +577,8 @@ void DiscreteTrajectory<Frame>::WriteToMessage(
     for (auto position_it = position_begin;
          position_it != position_end;
          ++position_it) {
-      // The field |tracked_position| is indexed by the indices in |tracked|.
-      // Its value is the position of a tracked segment in the field |segment|.
+      // The field `tracked_position` is indexed by the indices in `tracked`.
+      // Its value is the position of a tracked segment in the field `segment`.
       message->set_tracked_position(position_it->second, segment_position);
     }
   }
@@ -634,7 +634,7 @@ DiscreteTrajectory<Frame>::ReadFromMessage(
     return trajectory;
   }
 
-  // First restore the segments themselves.  |segment_iterators| will be used to
+  // First restore the segments themselves.  `segment_iterators` will be used to
   // restore the tracked segments.
   std::vector<SegmentIterator> segment_iterators;
   segment_iterators.reserve(message.segment_size());
@@ -828,8 +828,8 @@ void DiscreteTrajectory<Frame>::AdjustAfterSplicing(
     sit->SetSelf(SegmentIterator(to.segments_.get(), sit));
   }
 
-  // Copy the time-to-segment entries on or after the time of |to_segment_begin|
-  // from |from| to |to|.  We are sure to copy all the entries we need because
+  // Copy the time-to-segment entries on or after the time of `to_segment_begin`
+  // from `from` to `to`.  We are sure to copy all the entries we need because
   // it includes the last segment that starts at that time.
   auto from_leit = from.FindSegment(to_segments_begin->front().time);
   for (auto leit = from_leit;
@@ -839,8 +839,8 @@ void DiscreteTrajectory<Frame>::AdjustAfterSplicing(
         to.segment_by_left_endpoint_.end(), leit->first, leit->second);
   }
 
-  // Erase from |from| the entries that we just copied.  We may erase too much
-  // if |from| now ends with a 1-point segment that was not in the map, so we
+  // Erase from `from` the entries that we just copied.  We may erase too much
+  // if `from` now ends with a 1-point segment that was not in the map, so we
   // insert it again.
   from.segment_by_left_endpoint_.erase(from_leit,
                                        from.segment_by_left_endpoint_.end());
@@ -988,8 +988,8 @@ void DiscreteTrajectory<Frame>::ReadFromPreHamiltonMessage(
 
   // Finally, set the time-to-segment map.
   if (!sit->empty()) {
-    // This is the *only* place where we must use |emplace|, not
-    // |insert_or_assign|.  The reason is that this happens when returning from
+    // This is the *only* place where we must use `emplace`, not
+    // `insert_or_assign`.  The reason is that this happens when returning from
     // the recursivity (see to the call to ReadFromPreHamiltonMessage) so
     // segments are processed in reverse order.  Therefore, a segment that is
     // the last at its time will be processed *before* any 1-point segments with
diff --git a/physics/discrete_trajectory_iterator.hpp b/physics/discrete_trajectory_iterator.hpp
index 37b856a972..49027c593b 100644
--- a/physics/discrete_trajectory_iterator.hpp
+++ b/physics/discrete_trajectory_iterator.hpp
@@ -81,8 +81,8 @@ class DiscreteTrajectoryIterator {
   static typename Timeline::const_iterator const& iterator(
       OptionalTimelineConstIterator const& point);
 
-  // |point_| is always an iterator in the timeline of the segment denoted by
-  // |segment_|.  When |segment_| is at the end of its list, |point_| is
+  // `point_` is always an iterator in the timeline of the segment denoted by
+  // `segment_`.  When `segment_` is at the end of its list, `point_` is
   // nullopt.  It is possible to have repeated times in a segment or across
   // segments and the iterator will skip them, so that they will appear as a
   // single point to clients.
diff --git a/physics/discrete_trajectory_iterator_body.hpp b/physics/discrete_trajectory_iterator_body.hpp
index 8ea8c0c1da..22d5366582 100644
--- a/physics/discrete_trajectory_iterator_body.hpp
+++ b/physics/discrete_trajectory_iterator_body.hpp
@@ -102,7 +102,7 @@ DiscreteTrajectoryIterator<Frame>::operator+=(difference_type const n) {
     while (m > 0) {
       CHECK(!is_at_end(point_));
       auto& point = iterator(point_);
-      // We know that operator++ never leaves |point_| at |timeline_begin()|.
+      // We know that operator++ never leaves `point_` at `timeline_begin()`.
       // Therefore, to detect that we are in a new segment, we must check for
       // the second point of the segment.
       if (segment_->timeline_size() > 2 &&
@@ -136,8 +136,8 @@ DiscreteTrajectoryIterator<Frame>::operator-=(difference_type const n) {
     // (it would fall back to vanilla decrements).
     while (m > 0) {
       auto& point = iterator(point_);
-      // We know that operator-- never leaves |point_| at
-      // |std::prev(timeline_end())|.  Therefore, to detect that we are in a new
+      // We know that operator-- never leaves `point_` at
+      // `std::prev(timeline_end())`.  Therefore, to detect that we are in a new
       // segment, we must check for the second-to-last point of the segment.
       if (segment_->timeline_size() > 2 &&
           segment_->timeline_size() <= m + 2 &&
diff --git a/physics/discrete_trajectory_iterator_test.cpp b/physics/discrete_trajectory_iterator_test.cpp
index 6b66f9eeb3..195feeebb9 100644
--- a/physics/discrete_trajectory_iterator_test.cpp
+++ b/physics/discrete_trajectory_iterator_test.cpp
@@ -78,7 +78,7 @@ class DiscreteTrajectoryIteratorTest : public ::testing::Test {
     return it->end();
   }
 
-  // Constructs a list of |n| segments which are properly initialized.
+  // Constructs a list of `n` segments which are properly initialized.
   // TODO(phl): Move to a central place.
   static not_null<std::unique_ptr<Segments>> MakeSegments(const int n) {
     auto segments = make_not_null_unique<Segments>(n);
diff --git a/physics/discrete_trajectory_segment.hpp b/physics/discrete_trajectory_segment.hpp
index 39b6b14ded..971a35ee55 100644
--- a/physics/discrete_trajectory_segment.hpp
+++ b/physics/discrete_trajectory_segment.hpp
@@ -111,7 +111,7 @@ class DiscreteTrajectorySegment : public Trajectory<Frame> {
       Instant const& t) const override;
 
   // This segment must have 0 or 1 points.  Occasionally removes intermediate
-  // points from the segment when |Append|ing, ensuring that positions remain
+  // points from the segment when `Append`ing, ensuring that positions remain
   // within the desired tolerance.
   void SetDownsampling(DownsamplingParameters const& downsampling_parameters);
 
@@ -125,11 +125,11 @@ class DiscreteTrajectorySegment : public Trajectory<Frame> {
   void ClearDownsampling();
 
   // Returns true iff this segment was downsampled at least once since its
-  // creation or the last call to |clear|.  Only use for optimization purposes,
+  // creation or the last call to `clear`.  Only use for optimization purposes,
   // not to depend on the actual structure of the timeline.
   bool was_downsampled() const;
 
-  // The points denoted by |exact| are written and re-read exactly and are not
+  // The points denoted by `exact` are written and re-read exactly and are not
   // affected by any errors introduced by zfp compression.  The endpoints of a
   // segment are always exact.
   void WriteToMessage(
@@ -155,32 +155,32 @@ class DiscreteTrajectorySegment : public Trajectory<Frame> {
   std::optional<iterator> LowerBoundOrNullopt(Instant const& t) const;
   std::optional<iterator> UpperBoundOrNullopt(Instant const& t) const;
 
-  // Changes the |self_| iterator.  Only for use when attaching/detaching
+  // Changes the `self_` iterator.  Only for use when attaching/detaching
   // segments.
   void SetSelf(DiscreteTrajectorySegmentIterator<Frame> self);
 
   void Prepend(Instant const& t,
                DegreesOfFreedom<Frame> const& degrees_of_freedom);
 
-  // Removes all points with a time greater than or equal to |t| (1st overload)
-  // or starting at |begin| (2nd overload).
+  // Removes all points with a time greater than or equal to `t` (1st overload)
+  // or starting at `begin` (2nd overload).
   void ForgetAfter(Instant const& t);
   void ForgetAfter(typename Timeline::const_iterator begin);
 
-  // Removes all points with a time strictly less than |t| (1st overload) or
-  // ending at |end| (2nd overload).
+  // Removes all points with a time strictly less than `t` (1st overload) or
+  // ending at `end` (2nd overload).
   void ForgetBefore(Instant const& t);
   void ForgetBefore(typename Timeline::const_iterator end);
 
   absl::Status Append(Instant const& t,
                       DegreesOfFreedom<Frame> const& degrees_of_freedom);
 
-  // Merges the points from the given |segment| into this object.  The two
+  // Merges the points from the given `segment` into this object.  The two
   // segments must have nonoverlapping times.  The downsampling state of the
   // result is that of the latest segment (with the largest times).
   void Merge(DiscreteTrajectorySegment<Frame> segment);
 
-  // Computes |number_of_dense_points_| based on the start of the dense
+  // Computes `number_of_dense_points_` based on the start of the dense
   // timeline.  Used for compatibility deserialization.
   void SetStartOfDenseTimeline(Instant const& t);
 
@@ -188,13 +188,13 @@ class DiscreteTrajectorySegment : public Trajectory<Frame> {
   // compatibility deserialization.
   void SetForkPoint(value_type const& point);
 
-  // Called by |Append| after appending a point to this segment.  If
+  // Called by `Append` after appending a point to this segment.  If
   // appropriate, performs downsampling and deletes some of the points of the
   // segment.
   absl::Status DownsampleIfNeeded();
 
   // Returns the Hermite interpolation for the left-open, right-closed
-  // trajectory segment bounded above by |upper|.
+  // trajectory segment bounded above by `upper`.
   Hermite3<Position<Frame>, Instant> GetInterpolation(
       typename Timeline::const_iterator upper) const;
 
@@ -204,10 +204,10 @@ class DiscreteTrajectorySegment : public Trajectory<Frame> {
   std::int64_t timeline_size() const;
 
   // Implementation of serialization.  The caller is expected to pass consistent
-  // parameters.  |timeline_begin| and |timeline_end| define the range to write.
-  // |timeline_size| is the distance from |timeline_begin| to |timeline_end|.
-  // |number_of_points_to_skip_at_end| is the distance between |timeline_end|
-  // and the true |end| of the timeline.
+  // parameters.  `timeline_begin` and `timeline_end` define the range to write.
+  // `timeline_size` is the distance from `timeline_begin` to `timeline_end`.
+  // `number_of_points_to_skip_at_end` is the distance between `timeline_end`
+  // and the true `end` of the timeline.
   void WriteToMessage(
       not_null<serialization::DiscreteTrajectorySegment*> message,
       typename Timeline::const_iterator timeline_begin,
diff --git a/physics/discrete_trajectory_segment_body.hpp b/physics/discrete_trajectory_segment_body.hpp
index 1109fbf91e..f78ea95a65 100644
--- a/physics/discrete_trajectory_segment_body.hpp
+++ b/physics/discrete_trajectory_segment_body.hpp
@@ -559,7 +559,7 @@ absl::Status DiscreteTrajectorySegment<Frame>::DownsampleIfNeeded() {
     }
 
     // Poke holes in the timeline at the places given by
-    // |right_endpoints_times|.  This requires one lookup per erasure.
+    // `right_endpoints_times`.  This requires one lookup per erasure.
     auto left_it = dense_iterators.front();
     for (Instant const& right : right_endpoints_times) {
       ++left_it;
@@ -632,7 +632,7 @@ void DiscreteTrajectorySegment<Frame>::WriteToMessage(
   }
   message->set_was_downsampled(was_downsampled_);
 
-  // Convert the |exact| vector into a set, and add the extremities.  This
+  // Convert the `exact` vector into a set, and add the extremities.  This
   // ensures that we don't have redundancies.  The set is sorted by time to
   // guarantee that serialization is reproducible.
   auto time_comparator = [](value_type const* const left,
diff --git a/physics/discrete_trajectory_segment_iterator_test.cpp b/physics/discrete_trajectory_segment_iterator_test.cpp
index fa7368cb91..70a106d3ea 100644
--- a/physics/discrete_trajectory_segment_iterator_test.cpp
+++ b/physics/discrete_trajectory_segment_iterator_test.cpp
@@ -61,7 +61,7 @@ class DiscreteTrajectorySegmentIteratorTest : public ::testing::Test {
     return DiscreteTrajectorySegmentIterator<World>(segments, iterator);
   }
 
-  // Constructs a list of |n| segments which are properly initialized.
+  // Constructs a list of `n` segments which are properly initialized.
   // TODO(phl): Move to a central place.
   static not_null<std::unique_ptr<Segments>> MakeSegments(const int n) {
     auto segments = make_not_null_unique<Segments>(n);
diff --git a/physics/discrete_trajectory_segment_range.hpp b/physics/discrete_trajectory_segment_range.hpp
index 82646df435..277c1b8676 100644
--- a/physics/discrete_trajectory_segment_range.hpp
+++ b/physics/discrete_trajectory_segment_range.hpp
@@ -7,7 +7,7 @@ namespace physics {
 namespace _discrete_trajectory_segment_range {
 namespace internal {
 
-// A range of segments in a DiscreteTrajectory, iterator upon using |Iterator|.
+// A range of segments in a DiscreteTrajectory, iterator upon using `Iterator`.
 // Convenient for range-based loops.
 // TODO(phl): Move to base or use the Ranges library if it turns out that this
 // class doesn't need to know more about trajectories.
diff --git a/physics/discrete_trajectory_segment_test.cpp b/physics/discrete_trajectory_segment_test.cpp
index 348d1cbbe3..4fc0d5a724 100644
--- a/physics/discrete_trajectory_segment_test.cpp
+++ b/physics/discrete_trajectory_segment_test.cpp
@@ -92,7 +92,7 @@ class DiscreteTrajectorySegmentTest : public ::testing::Test {
     return DiscreteTrajectorySegmentIterator<World>(segments, iterator);
   }
 
-  // Constructs a list of |n| segments which are properly initialized.
+  // Constructs a list of `n` segments which are properly initialized.
   // TODO(phl): Move to a central place.
   static not_null<std::unique_ptr<Segments>> MakeSegments(const int n) {
     auto segments = make_not_null_unique<Segments>(n);
diff --git a/physics/discrete_trajectory_test.cpp b/physics/discrete_trajectory_test.cpp
index 10ca8b2904..0f99b7d92f 100644
--- a/physics/discrete_trajectory_test.cpp
+++ b/physics/discrete_trajectory_test.cpp
@@ -65,8 +65,8 @@ class DiscreteTrajectoryTest : public ::testing::Test {
                       serialization::Frame::TEST>;
 
 
-  // Constructs a trajectory with three 5-second segments starting at |t0| and
-  // the given |degrees_of_freedom|.
+  // Constructs a trajectory with three 5-second segments starting at `t0` and
+  // the given `degrees_of_freedom`.
   DiscreteTrajectory<World> MakeTrajectory(
       Instant const& t0,
       DegreesOfFreedom<World> const& degrees_of_freedom) {
diff --git a/physics/discrete_trajectory_types.hpp b/physics/discrete_trajectory_types.hpp
index 8a61c567a5..40124a078f 100644
--- a/physics/discrete_trajectory_types.hpp
+++ b/physics/discrete_trajectory_types.hpp
@@ -25,9 +25,9 @@ using namespace principia::geometry::_instant;
 using namespace principia::physics::_degrees_of_freedom;
 using namespace principia::quantities::_quantities;
 
-// |max_dense_intervals| is the maximal number of dense intervals before
-// downsampling occurs.  |tolerance| is the tolerance for downsampling with
-// |FitHermiteSpline|.
+// `max_dense_intervals` is the maximal number of dense intervals before
+// downsampling occurs.  `tolerance` is the tolerance for downsampling with
+// `FitHermiteSpline`.
 struct DownsamplingParameters {
   std::int64_t max_dense_intervals;
   Length tolerance;
diff --git a/physics/ephemeris.hpp b/physics/ephemeris.hpp
index d810846541..28a45be293 100644
--- a/physics/ephemeris.hpp
+++ b/physics/ephemeris.hpp
@@ -78,7 +78,7 @@ class Ephemeris {
   static std::int64_t constexpr unlimited_max_ephemeris_steps =
       std::numeric_limits<std::int64_t>::max();
 
-  // The equations describing the motion of the |bodies_|.
+  // The equations describing the motion of the `bodies_`.
   using NewtonianMotionEquation =
       SpecialSecondOrderDifferentialEquation<Position<Frame>>;
   using GeneralizedNewtonianMotionEquation =
@@ -108,8 +108,8 @@ class Ephemeris {
     friend class Ephemeris<Frame>;
   };
 
-  // Constructs an Ephemeris that owns the |bodies|.  The elements of vectors
-  // |bodies| and |initial_state| correspond to one another.
+  // Constructs an Ephemeris that owns the `bodies`.  The elements of vectors
+  // `bodies` and `initial_state` correspond to one another.
   Ephemeris(std::vector<not_null<std::unique_ptr<MassiveBody const>>> bodies,
             std::vector<DegreesOfFreedom<Frame>> const& initial_state,
             Instant const& initial_time,
@@ -121,16 +121,16 @@ class Ephemeris {
   // Returns the bodies in the order in which they were given at construction.
   virtual std::vector<not_null<MassiveBody const*>> const& bodies() const;
 
-  // Returns the trajectory for the given |body|.
+  // Returns the trajectory for the given `body`.
   virtual not_null<ContinuousTrajectory<Frame> const*> trajectory(
       not_null<MassiveBody const*> body) const;
 
   // Returns true if at least one of the trajectories is empty.
   virtual bool empty() const;
 
-  // The maximum of the |t_min|s of the trajectories.
+  // The maximum of the `t_min`s of the trajectories.
   virtual Instant t_min() const EXCLUDES(lock_);
-  // The mimimum of the |t_max|s of the trajectories.
+  // The mimimum of the `t_max`s of the trajectories.
   virtual Instant t_max() const EXCLUDES(lock_);
 
   virtual FixedStepSizeIntegrator<NewtonianMotionEquation> const&
@@ -138,26 +138,26 @@ class Ephemeris {
 
   virtual absl::Status last_severe_integration_status() const;
 
-  // Prolongs the ephemeris up to at least |t|.  Returns an error iff the thread
+  // Prolongs the ephemeris up to at least `t`.  Returns an error iff the thread
   // is stopped.  After a successful call with the second parameter defaulted,
-  // |t_max() >= t|.
+  // `t_max() >= t`.
   virtual absl::Status Prolong(
       Instant const& t,
       std::int64_t max_ephemeris_steps = unlimited_max_ephemeris_steps)
       EXCLUDES(lock_);
 
   // Asks the reanimator thread to asynchronously reconstruct the past so that
-  // the |t_min()| of the ephemeris ultimately ends up at or before
-  // |desired_t_min|.
+  // the `t_min()` of the ephemeris ultimately ends up at or before
+  // `desired_t_min`.
   void RequestReanimation(Instant const& desired_t_min);
 
-  // Same as |RequestReanimation|, but synchronous.  This function blocks until
-  // the |t_min()| of the ephemeris is at or before |desired_t_min|.
+  // Same as `RequestReanimation`, but synchronous.  This function blocks until
+  // the `t_min()` of the ephemeris is at or before `desired_t_min`.
   void AwaitReanimation(Instant const& desired_t_min);
 
-  // Creates an instance suitable for integrating the given |trajectories| with
-  // their |intrinsic_accelerations| using a fixed-step integrator parameterized
-  // by |parameters|.
+  // Creates an instance suitable for integrating the given `trajectories` with
+  // their `intrinsic_accelerations` using a fixed-step integrator parameterized
+  // by `parameters`.
   virtual not_null<
       std::unique_ptr<typename Integrator<NewtonianMotionEquation>::Instance>>
   NewInstance(
@@ -173,11 +173,11 @@ class Ephemeris {
       IntrinsicAccelerations const& intrinsic_accelerations,
       FixedStepParameters const& parameters);
 
-  // Integrates, until exactly |t| (except for timeouts or singularities), the
-  // |trajectory| followed by a massless body in the gravitational potential
-  // described by |*this|.  If |t > t_max()|, calls |Prolong(t)| beforehand.
-  // Prolongs the ephemeris by at most |max_ephemeris_steps|.  Returns OK if and
-  // only if |*trajectory| was integrated until |t|.
+  // Integrates, until exactly `t` (except for timeouts or singularities), the
+  // `trajectory` followed by a massless body in the gravitational potential
+  // described by `*this`.  If `t > t_max()`, calls `Prolong(t)` beforehand.
+  // Prolongs the ephemeris by at most `max_ephemeris_steps`.  Returns OK if and
+  // only if `*trajectory` was integrated until `t`.
   virtual absl::Status FlowWithAdaptiveStep(
       not_null<DiscreteTrajectory<Frame>*> trajectory,
       IntrinsicAcceleration intrinsic_acceleration,
@@ -195,64 +195,64 @@ class Ephemeris {
       std::int64_t max_ephemeris_steps = unlimited_max_ephemeris_steps)
       EXCLUDES(lock_);
 
-  // Integrates, until at most |t|, the trajectories followed by massless
-  // bodies in the gravitational potential described by |*this|.  If
-  // |t > t_max()|, calls |Prolong(t)| beforehand.  The trajectories and
-  // integration parameters are given by the |instance|.
+  // Integrates, until at most `t`, the trajectories followed by massless
+  // bodies in the gravitational potential described by `*this`.  If
+  // `t > t_max()`, calls `Prolong(t)` beforehand.  The trajectories and
+  // integration parameters are given by the `instance`.
   virtual absl::Status FlowWithFixedStep(
       Instant const& t,
       typename Integrator<NewtonianMotionEquation>::Instance& instance)
       EXCLUDES(lock_);
 
-  // Returns the Jacobian of the acceleration field exerted on the given |body|
+  // Returns the Jacobian of the acceleration field exerted on the given `body`
   // by the rest of the system.
   JacobianOfAcceleration<Frame> ComputeJacobianOnMassiveBody(
       not_null<MassiveBody const*> body,
       Instant const& t) const EXCLUDES(lock_);
 
   // Returns the gravitational jerk on a massless body with the given
-  // |degrees_of_freedom| at time |t|.
+  // `degrees_of_freedom` at time `t`.
   Vector<Jerk, Frame> ComputeGravitationalJerkOnMasslessBody(
       DegreesOfFreedom<Frame> const& degrees_of_freedom,
       Instant const& t) const EXCLUDES(lock_);
 
-  // Returns the gravitational jerk on the massive |body| at time |t|.  |body|
+  // Returns the gravitational jerk on the massive `body` at time `t`.  `body`
   // must be one of the bodies of this object.
   Vector<Jerk, Frame> ComputeGravitationalJerkOnMassiveBody(
       not_null<MassiveBody const*> body,
       Instant const& t) const EXCLUDES(lock_);
 
   // Returns the gravitational acceleration on a massless body located at the
-  // given |position| at time |t|.
+  // given `position` at time `t`.
   virtual Vector<Acceleration, Frame>
   ComputeGravitationalAccelerationOnMasslessBody(
       Position<Frame> const& position,
       Instant const& t) const EXCLUDES(lock_);
 
   // Returns the gravitational acceleration on the massless body having the
-  // given |trajectory| at time |t|.  |t| must be one of the times of the
-  // |trajectory|.
+  // given `trajectory` at time `t`.  `t` must be one of the times of the
+  // `trajectory`.
   virtual Vector<Acceleration, Frame>
   ComputeGravitationalAccelerationOnMasslessBody(
       not_null<DiscreteTrajectory<Frame>*> trajectory,
       Instant const& t) const EXCLUDES(lock_);
 
-  // Returns the gravitational acceleration on the massive |body| at time |t|.
-  // |body| must be one of the bodies of this object.
+  // Returns the gravitational acceleration on the massive `body` at time `t`.
+  // `body` must be one of the bodies of this object.
   virtual Vector<Acceleration, Frame>
   ComputeGravitationalAccelerationOnMassiveBody(
       not_null<MassiveBody const*> body,
       Instant const& t) const EXCLUDES(lock_);
 
-  // Returns the potential at the given |position| at time |t|.
+  // Returns the potential at the given `position` at time `t`.
   SpecificEnergy ComputeGravitationalPotential(
       Position<Frame> const& position,
       Instant const& t) const EXCLUDES(lock_);
 
-  // Computes the apsides of the relative trajectory of |body1| and |body2}.
+  // Computes the apsides of the relative trajectory of `body1` and `body2`.
   // Appends to the given trajectories two points for each apsis, one for
-  // |body1| and one for |body2|.  The times of |apoapsides1| and |apoapsideds2|
-  // are identical (are similarly for |periapsides1| and |periapsides2|).
+  // `body1` and one for `body2`.  The times of `apoapsides1` and `apoapsides2`
+  // are identical (are similarly for `periapsides1` and `periapsides2`).
   virtual void ComputeApsides(not_null<MassiveBody const*> body1,
                               not_null<MassiveBody const*> body2,
                               DiscreteTrajectory<Frame>& apoapsides1,
@@ -261,7 +261,7 @@ class Ephemeris {
                               DiscreteTrajectory<Frame>& periapsides2);
 
   // Returns the index of the given body in the serialization produced by
-  // |WriteToMessage| and read by the |Read...| functions.  This index is not
+  // `WriteToMessage` and read by the `Read...` functions.  This index is not
   // suitable for other uses.
   virtual int serialization_index_for_body(
       not_null<MassiveBody const*> body) const;
@@ -271,9 +271,9 @@ class Ephemeris {
 
   virtual void WriteToMessage(
       not_null<serialization::Ephemeris*> message) const EXCLUDES(lock_);
-  // The parameter |desired_t_min| indicates that the ephemeris must be restored
-  // at a checkpoint such that, once the ephemeris is prolonged, its |t_min()|
-  // is at or before |desired_t_min|.
+  // The parameter `desired_t_min` indicates that the ephemeris must be restored
+  // at a checkpoint such that, once the ephemeris is prolonged, its `t_min()`
+  // is at or before `desired_t_min`.
   static not_null<std::unique_ptr<Ephemeris>> ReadFromMessage(
       Instant const& desired_t_min,
       serialization::Ephemeris const& message)
@@ -281,7 +281,7 @@ class Ephemeris {
 
  protected:
   // For mocking purposes, leaves everything uninitialized and uses the given
-  // |integrator|.
+  // `integrator`.
   explicit Ephemeris(FixedStepSizeIntegrator<typename Ephemeris<
                          Frame>::NewtonianMotionEquation> const& integrator);
 
@@ -293,13 +293,13 @@ class Ephemeris {
   Checkpointer<serialization::Ephemeris>::Reader MakeCheckpointerReader();
 
   // Called on a stoppable thread to reconstruct the past state of the ephemeris
-  // and its trajectories starting in such a way that |t_min()| is at or before
-  // |desired_t_min|.  The member variable |oldest_reanimated_checkpoint_| tells
+  // and its trajectories starting in such a way that `t_min()` is at or before
+  // `desired_t_min`.  The member variable `oldest_reanimated_checkpoint_` tells
   // the reanimator where to stop.
   absl::Status Reanimate(Instant const desired_t_min) EXCLUDES(lock_);
 
-  // Reconstructs the past state of the ephemeris between |t_initial| and
-  // |t_final| using the given checkpoint |message|.
+  // Reconstructs the past state of the ephemeris between `t_initial` and
+  // `t_final` using the given checkpoint `message`.
   absl::Status ReanimateOneCheckpoint(
       serialization::Ephemeris::Checkpoint const& message,
       Instant const& t_initial,
@@ -326,10 +326,10 @@ class Ephemeris {
   virtual Instant t_min_locked() const REQUIRES_SHARED(lock_);
   virtual Instant t_max_locked() const REQUIRES_SHARED(lock_);
 
-  // Computes the Jacobian of the acceleration field between one body, |body1|
-  // (with index |b1| in the |positions| and |jacobians| arrays) and the bodies
-  // |bodies2| (with indices [b2_begin, b2_end[ in the |bodies2|, |positions|
-  // and |jacobians| arrays).  This assumes that the bodies are point masses
+  // Computes the Jacobian of the acceleration field between one body, `body1`
+  // (with index `b1` in the `positions` and `jacobians` arrays) and the bodies
+  // `bodies2` (with indices [b2_begin, b2_end[ in the `bodies2`, `positions`
+  // and `jacobians` arrays).  This assumes that the bodies are point masses
   // (that is, it doesn't take the geopotential into account).
   template<typename MassiveBodyConstPtr>
   static void ComputeJacobianByMassiveBodyOnMassiveBodies(
@@ -341,10 +341,10 @@ class Ephemeris {
       std::vector<Position<Frame>> const& positions,
       std::vector<JacobianOfAcceleration<Frame>>& jacobians);
 
-  // Computes the jerk between one body, |body1| (with index |b1| in the
-  // |degrees_of_freedom| and |jerks| arrays) and the bodies |bodies2| (with
-  // indices [b2_begin, b2_end[ in the |bodies2|, |degrees_of_freedom| and
-  // |jerks| arrays).  This assumes that the bodies are point masses
+  // Computes the jerk between one body, `body1` (with index `b1` in the
+  // `degrees_of_freedom` and `jerks` arrays) and the bodies `bodies2` (with
+  // indices [b2_begin, b2_end[ in the `bodies2`, `degrees_of_freedom` and
+  // `jerks` arrays).  This assumes that the bodies are point masses
   // (that is, it doesn't take the geopotential into account).
   template<typename MassiveBodyConstPtr>
   static void ComputeGravitationalJerkByMassiveBodyOnMassiveBodies(
@@ -356,12 +356,12 @@ class Ephemeris {
       std::vector<DegreesOfFreedom<Frame>> const& degrees_of_freedom,
       std::vector<Vector<Jerk, Frame>>& jerks);
 
-  // Computes the accelerations between one body, |body1| (with index |b1| in
-  // the |positions| and |accelerations| arrays) and the bodies |bodies2| (with
-  // indices [b2_begin, b2_end[ in the |bodies2|, |positions| and
-  // |accelerations| arrays).  The template parameters specify what we know
+  // Computes the accelerations between one body, `body1` (with index `b1` in
+  // the `positions` and `accelerations` arrays) and the bodies `bodies2` (with
+  // indices [b2_begin, b2_end[ in the `bodies2`, `positions` and
+  // `accelerations` arrays).  The template parameters specify what we know
   // about the bodies, and therefore what forces apply.  Works for both owning
-  // and non-owning pointers thanks to the |MassiveBodyConstPtr| template
+  // and non-owning pointers thanks to the `MassiveBodyConstPtr` template
   // parameter.
   template<bool body1_is_oblate,
            bool body2_is_oblate,
@@ -377,9 +377,9 @@ class Ephemeris {
       std::vector<Vector<Acceleration, Frame>>& accelerations,
       std::vector<Geopotential<Frame>> const& geopotentials);
 
-  // Computes the accelerations due to one body, |body1| (with index |b1| in the
-  // |bodies_| and |trajectories_| arrays) on massless bodies at the given
-  // |positions|.  The template parameter specifies what we know about the
+  // Computes the accelerations due to one body, `body1` (with index `b1` in the
+  // `bodies_` and `trajectories_` arrays) on massless bodies at the given
+  // `positions`.  The template parameter specifies what we know about the
   // massive body, and therefore what forces apply.  Returns an integer for
   // efficiency.
   template<bool body1_is_oblate>
@@ -392,8 +392,8 @@ class Ephemeris {
       std::vector<Vector<Acceleration, Frame>>& accelerations) const
       REQUIRES_SHARED(lock_);
 
-  // Computes the potential resulting from one body, |body1| (with index |b1| in
-  // the |bodies_| and |trajectories_| arrays) at the given |positions|.  The
+  // Computes the potential resulting from one body, `body1` (with index `b1` in
+  // the `bodies_` and `trajectories_` arrays) at the given `positions`.  The
   // template parameter specifies what we know about the massive body, and
   // therefore what potential applies.
   template<bool body1_is_oblate>
@@ -405,16 +405,16 @@ class Ephemeris {
       std::vector<SpecificEnergy>& potentials) const
       REQUIRES_SHARED(lock_);
 
-  // Computes the accelerations between all the massive bodies in |bodies_|.
+  // Computes the accelerations between all the massive bodies in `bodies_`.
   absl::Status ComputeGravitationalAccelerationBetweenAllMassiveBodies(
       Instant const& t,
       std::vector<Position<Frame>> const& positions,
       std::vector<Vector<Acceleration, Frame>>& accelerations) const;
 
-  // Computes the acceleration exerted by the massive bodies in |bodies_| on
-  // massless bodies.  The massless bodies are at the given |positions|.
+  // Computes the acceleration exerted by the massive bodies in `bodies_` on
+  // massless bodies.  The massless bodies are at the given `positions`.
   // Returns an error iff a collision occurred, i.e., the massless body is
-  // inside one of the |bodies_|.
+  // inside one of the `bodies_`.
   absl::StatusCode
   ComputeGravitationalAccelerationByAllMassiveBodiesOnMasslessBodies(
       Instant const& t,
@@ -422,8 +422,8 @@ class Ephemeris {
       std::vector<Vector<Acceleration, Frame>>& accelerations) const
       EXCLUDES(lock_);
 
-  // Computes the potential resulting from the massive bodies in |bodies_|.  The
-  // potentials are computed at the given |positions|.
+  // Computes the potential resulting from the massive bodies in `bodies_`.  The
+  // potentials are computed at the given `positions`.
   void ComputeGravitationalPotentialsOfAllMassiveBodies(
       Instant const& t,
       std::vector<Position<Frame>> const& positions,
@@ -439,7 +439,7 @@ class Ephemeris {
       _integration_parameters::AdaptiveStepParameters<ODE> const& parameters,
       std::int64_t max_ephemeris_steps) EXCLUDES(lock_);
 
-  // Computes an estimate of the ratio |tolerance / error|.
+  // Computes an estimate of the ratio `tolerance / error`.
   static double ToleranceToErrorRatio(
       Length const& length_integration_tolerance,
       Speed const& speed_integration_tolerance,
@@ -450,17 +450,17 @@ class Ephemeris {
   // The bodies in the order in which they were given at construction.
   std::vector<not_null<MassiveBody const*>> unowned_bodies_;
 
-  // The indices of bodies in |unowned_bodies_|.
+  // The indices of bodies in `unowned_bodies_`.
   std::map<not_null<MassiveBody const*>, int> unowned_bodies_indices_;
 
   // The oblate bodies precede the spherical bodies in this vector.  The system
   // state is indexed in the same order.
   std::vector<not_null<std::unique_ptr<MassiveBody const>>> bodies_;
 
-  // Only has entries for the oblate bodies, at the same indices as |bodies_|.
+  // Only has entries for the oblate bodies, at the same indices as `bodies_`.
   std::vector<Geopotential<Frame>> geopotentials_;
 
-  // The indices in |bodies_| correspond to those in |trajectories_|.
+  // The indices in `bodies_` correspond to those in `trajectories_`.
   std::vector<not_null<ContinuousTrajectory<Frame>*>> trajectories_;
 
   std::map<not_null<MassiveBody const*>,
@@ -476,8 +476,8 @@ class Ephemeris {
   not_null<
       std::unique_ptr<Checkpointer<serialization::Ephemeris>>> checkpointer_;
 
-  // This member must only be accessed by the |reanimator_| thread, or before
-  // the |reanimator_| thread is started.  An ephemeris that is constructed de
+  // This member must only be accessed by the `reanimator_` thread, or before
+  // the `reanimator_` thread is started.  An ephemeris that is constructed de
   // novo won't ever need reanimation, so all the checkpoints are animate at
   // birth.
   Instant oldest_reanimated_checkpoint_ = InfinitePast;
@@ -487,12 +487,12 @@ class Ephemeris {
   Clientele<Instant> reanimator_clientele_;
 
   // The fields above this line are fixed at construction and therefore not
-  // protected.  Note that |ContinuousTrajectory| is thread-safe.  |lock_| is
+  // protected.  Note that `ContinuousTrajectory` is thread-safe.  `lock_` is
   // also used to protect sections where the trajectories are not mutually
   // consistent (e.g., during Prolong).
   mutable absl::Mutex lock_;
 
-  // Parameter passed to the last call to |RequestReanimation|, if any.
+  // Parameter passed to the last call to `RequestReanimation`, if any.
   std::optional<Instant> last_desired_t_min_ GUARDED_BY(lock_);
 
   std::unique_ptr<typename Integrator<NewtonianMotionEquation>::Instance>
diff --git a/physics/ephemeris_body.hpp b/physics/ephemeris_body.hpp
index a9452be16f..4ffc0f5212 100644
--- a/physics/ephemeris_body.hpp
+++ b/physics/ephemeris_body.hpp
@@ -269,7 +269,7 @@ absl::Status Ephemeris<Frame>::Prolong(Instant const& t,
   absl::MutexLock l(&lock_);
   Instant const instance_time = this->instance_time_locked();
 
-  // We want |t_max()| to reach at least this point when this function
+  // We want `t_max()` to reach at least this point when this function
   // terminates normally.
   Instant const desired_t_max = std::min(
       t,
@@ -277,16 +277,16 @@ absl::Status Ephemeris<Frame>::Prolong(Instant const& t,
 
   Instant t_final;  // Final time to integrate.
   if (desired_t_max <= instance_time) {
-    // Note that |desired_t_max| may be before the last time that we integrated
-    // and still after |t_max()|.  In this case we want to make sure that the
+    // Note that `desired_t_max` may be before the last time that we integrated
+    // and still after `t_max()`.  In this case we want to make sure that the
     // integrator makes progress.
     t_final = instance_time + fixed_step_parameters_.step();
   } else {
     t_final = desired_t_max;
   }
 
-  // Perform the integration.  Note that we may have to iterate until |t_max()|
-  // actually reaches |desired_t_max| because the last series may not be fully
+  // Perform the integration.  Note that we may have to iterate until `t_max()`
+  // actually reaches `desired_t_max` because the last series may not be fully
   // determined after the first integration.
   while (t_max_locked() < desired_t_max) {
     instance_->Solve(t_final).IgnoreError();
@@ -455,7 +455,7 @@ JacobianOfAcceleration<Frame> Ephemeris<Frame>::ComputeJacobianOnMassiveBody(
   std::vector<JacobianOfAcceleration<Frame>> jacobians(bodies_.size());
   int b1 = -1;
 
-  // Evaluate the |positions|.  Locking is necessary to be able to call the
+  // Evaluate the `positions`.  Locking is necessary to be able to call the
   // "locked" method of each trajectory.
   {
     absl::ReaderMutexLock l(&lock_);
@@ -506,7 +506,7 @@ Vector<Jerk, Frame> Ephemeris<Frame>::ComputeGravitationalJerkOnMasslessBody(
         b2_trajectory->EvaluateDegreesOfFreedomLocked(t);
     GravitationalParameter const& μ2 = body2.gravitational_parameter();
 
-    // A vector from the center of |b2| to the center of |b1|.
+    // A vector from the center of `b2` to the center of `b1`.
     RelativeDegreesOfFreedom<Frame> const Δqv =
         degrees_of_freedom_of_b1 - degrees_of_freedom_of_b2;
     Displacement<Frame> const Δq = Δqv.displacement();
@@ -536,7 +536,7 @@ ComputeGravitationalJerkOnMassiveBody(not_null<MassiveBody const*> body,
   std::vector<Vector<Jerk, Frame>> jerks(bodies_.size());
   int b1 = -1;
 
-  // Evaluate the |degrees_of_freedom|.  Locking is necessary to be able to call
+  // Evaluate the `degrees_of_freedom`.  Locking is necessary to be able to call
   // the "locked" method of each trajectory.
   {
     absl::ReaderMutexLock l(&lock_);
@@ -606,7 +606,7 @@ Ephemeris<Frame>::ComputeGravitationalAccelerationOnMassiveBody(
   std::vector<Vector<Acceleration, Frame>> accelerations(bodies_.size());
   int b1 = -1;
 
-  // Evaluate the |positions|.  Locking is necessary to be able to call the
+  // Evaluate the `positions`.  Locking is necessary to be able to call the
   // "locked" method of each trajectory.
   {
     absl::ReaderMutexLock l(&lock_);
@@ -705,8 +705,8 @@ void Ephemeris<Frame>::ComputeApsides(not_null<MassiveBody const*> const body1,
   not_null<ContinuousTrajectory<Frame> const*> const body2_trajectory =
       trajectory(body2);
 
-  // Computes the derivative of the squared distance between |body1| and |body2|
-  // at time |t|.
+  // Computes the derivative of the squared distance between `body1` and `body2`
+  // at time `t`.
   auto const evaluate_square_distance_derivative =
       [body1_trajectory, body2_trajectory](
           Instant const& t) -> Variation<Square<Length>> {
@@ -732,7 +732,7 @@ void Ephemeris<Frame>::ComputeApsides(not_null<MassiveBody const*> const body1,
             Sign(*previous_squared_distance_derivative)) {
       CHECK(previous_time);
 
-      // The derivative of |squared_distance| changed sign.  Find its zero by
+      // The derivative of `squared_distance` changed sign.  Find its zero by
       // Brent's method, this is the time of the apsis.  Then compute the apsis
       // and append it to one of the output trajectories.
       Instant const apsis_time = Brent(evaluate_square_distance_derivative,
@@ -878,15 +878,15 @@ not_null<std::unique_ptr<Ephemeris<Frame>>> Ephemeris<Frame>::ReadFromMessage(
             message.checkpoint());
   }
 
-  // The checkpoint at or before |desired_t_min| will result in a |t_min()|
-  // which is at |desired_t_min| (if the checkpoint was taken with
-  // |last_points_.size() == 1|) or before (if the checkpoint was taken with
-  // |last_points_.size() > 1|).
+  // The checkpoint at or before `desired_t_min` will result in a `t_min()`
+  // which is at `desired_t_min` (if the checkpoint was taken with
+  // `last_points_.size() == 1`) or before (if the checkpoint was taken with
+  // `last_points_.size() > 1`).
   ephemeris->oldest_reanimated_checkpoint_ =
       ephemeris->checkpointer_->checkpoint_at_or_before(desired_t_min);
   if (ephemeris->oldest_reanimated_checkpoint_ == InfinitePast) {
     // In the pre-Grassmann compatibility case the (only) checkpoint may be
-    // after |desired_t_min|.  This also happens with old saves that are
+    // after `desired_t_min`.  This also happens with old saves that are
     // rewritten post-Grassmann.
     CHECK_LE(ephemeris->t_min(), desired_t_min);
   } else {
@@ -966,8 +966,8 @@ absl::Status Ephemeris<Frame>::Reanimate(Instant const desired_t_min) {
   {
     absl::ReaderMutexLock l(&lock_);
 
-    // It is very important that |oldest_reanimated_checkpoint_| be only read by
-    // the |reanimator_| thread.  If the caller was trying to determine the set
+    // It is very important that `oldest_reanimated_checkpoint_` be only read by
+    // the `reanimator_` thread.  If the caller was trying to determine the set
     // of checkpoints to reanimate it might race with a reanimation already in
     // flight and result in the same checkpoint reanimated multiple times, which
     // is a no-no.
@@ -1177,7 +1177,7 @@ void Ephemeris<Frame>::ComputeJacobianByMassiveBodyOnMassiveBodies(
     MassiveBody const& body2 = *bodies2[b2];
     GravitationalParameter const& μ2 = body2.gravitational_parameter();
 
-    // A vector from the center of |b2| to the center of |b1|.
+    // A vector from the center of `b2` to the center of `b1`.
     Displacement<Frame> const Δq = position_of_b1 - positions[b2];
 
     Square<Length> const Δq² = Δq.Norm²();
@@ -1214,7 +1214,7 @@ void Ephemeris<Frame>::ComputeGravitationalJerkByMassiveBodyOnMassiveBodies(
     MassiveBody const& body2 = *bodies2[b2];
     GravitationalParameter const& μ2 = body2.gravitational_parameter();
 
-    // A vector from the center of |b2| to the center of |b1|.
+    // A vector from the center of `b2` to the center of `b1`.
     RelativeDegreesOfFreedom<Frame> const Δqv =
         degrees_of_freedom_of_b1 - degrees_of_freedom[b2];
     Displacement<Frame> const Δq = Δqv.displacement();
@@ -1257,7 +1257,7 @@ ComputeGravitationalAccelerationByMassiveBodyOnMassiveBodies(
     MassiveBody const& body2 = *bodies2[b2];
     GravitationalParameter const& μ2 = body2.gravitational_parameter();
 
-    // A vector from the center of |b2| to the center of |b1|.
+    // A vector from the center of `b2` to the center of `b1`.
     Displacement<Frame> const Δq = position_of_b1 - positions[b2];
 
     Square<Length> const Δq² = Δq.Norm²();
@@ -1324,7 +1324,7 @@ Ephemeris<Frame>::ComputeGravitationalAccelerationByMassiveBodyOnMasslessBodies(
       absl::StatusCode::kOk);
 
   for (std::size_t b2 = 0; b2 < positions.size(); ++b2) {
-    // A vector from the center of |b2| to the center of |b1|.
+    // A vector from the center of `b2` to the center of `b1`.
     Displacement<Frame> const Δq = position1 - positions[b2];
 
     Square<Length> const Δq² = Δq.Norm²();
@@ -1370,7 +1370,7 @@ void Ephemeris<Frame>::ComputeGravitationalPotentialsOfMassiveBody(
   Position<Frame> const position1 = trajectory1.EvaluatePositionLocked(t);
 
   for (std::size_t b2 = 0; b2 < positions.size(); ++b2) {
-    // A vector from the center of |b2| to the center of |b1|.
+    // A vector from the center of `b2` to the center of `b1`.
     Displacement<Frame> const Δq = position1 - positions[b2];
 
     Square<Length> const Δq² = Δq.Norm²();
@@ -1579,8 +1579,8 @@ absl::Status Ephemeris<Frame>::FlowODEWithAdaptiveStep(
 
   // TODO(egg): when we have events in trajectories, we should add a singularity
   // event at the end if the outcome indicates a singularity
-  // (|VanishingStepSize|).  We should not have an event on the trajectory if
-  // |ReachedMaximalStepCount|, since that is not a physical property, but
+  // (`VanishingStepSize`).  We should not have an event on the trajectory if
+  // `ReachedMaximalStepCount`, since that is not a physical property, but
   // rather a self-imposed constraint.
   if (!status.ok() || t_final == t) {
     return status;
diff --git a/physics/equipotential.hpp b/physics/equipotential.hpp
index 17e499ac0d..6ed573d449 100644
--- a/physics/equipotential.hpp
+++ b/physics/equipotential.hpp
@@ -61,7 +61,7 @@ class Equipotential {
   using Line = DiscreteTrajectory<Frame>;
   using Lines = std::vector<Line>;
 
-  // The |characteristic_length| is used in the stopping condition.
+  // The `characteristic_length` is used in the stopping condition.
   Equipotential(
       AdaptiveParameters const& adaptive_parameters,
       not_null<ReferenceFrame<InertialFrame, Frame> const*> reference_frame,
@@ -79,11 +79,11 @@ class Equipotential {
     Length radius;
   };
 
-  // Computes equipotential lines for the given |energy| that delineate the
-  // |peaks| from the |wells| and from the “well at infinity” (which is a well
+  // Computes equipotential lines for the given `energy` that delineate the
+  // `peaks` from the `wells` and from the “well at infinity” (which is a well
   // because we are in a rotating frame).  An equipotential delineates a peak
   // from a well if it encloses the peak but not the well, or vice-versa.  Given
-  // a position, |towards_infinity| should return a position far away where the
+  // a position, `towards_infinity` should return a position far away where the
   // potential is lower, in a direction where not much happens, e.g., away from
   // the centre in a rotating frame.
   Lines ComputeLines(
@@ -111,7 +111,7 @@ class Equipotential {
   static constexpr Quotient<Time, IndependentVariable>
       reinterpret_independent_variable_as_time = 1 * Second;
 
-  // The |binormal| determines in what direction we go around the curve.  It may
+  // The `binormal` determines in what direction we go around the curve.  It may
   // be anything, but must be consistent across calls to the right-hand side.
   absl::Status RightHandSide(Bivector<double, Frame> const& binormal,
                              Position<Frame> const& position,
@@ -124,10 +124,10 @@ class Equipotential {
                                State const& /*state*/,
                                typename State::Error const& error) const;
 
-  // Computes the winding number of |line| around |position|.  |line| and
-  // |position| must be in a plane paralles to |plane|.  The returned integer is
+  // Computes the winding number of `line` around `position`.  `line` and
+  // `position` must be in a plane paralles to `plane`.  The returned integer is
   // nonnegative, i.e., doesn't give information about the direction in which
-  // the |line| rotates around |position|.
+  // the `line` rotates around `position`.
   std::int64_t WindingNumber(Plane<Frame> const& plane,
                              Position<Frame> const& position,
                              std::vector<Position<Frame>> const& line) const;
diff --git a/physics/equipotential_body.hpp b/physics/equipotential_body.hpp
index fa9e94cf56..5c051d4d4c 100644
--- a/physics/equipotential_body.hpp
+++ b/physics/equipotential_body.hpp
@@ -102,7 +102,7 @@ auto Equipotential<InertialFrame, Frame>::ComputeLines(
     SpecificEnergy const& energy) const -> Lines {
   using WellIterator = typename std::vector<Well>::const_iterator;
 
-  // A |PeakDelineation| represents:
+  // A `PeakDelineation` represents:
   // 1. the set of wells that are not yet delineated from a peak by
   //    equipotentials already computed;
   // 2. whether the well is delineated from the “well at infinity”.
@@ -111,7 +111,7 @@ auto Equipotential<InertialFrame, Frame>::ComputeLines(
     bool delineated_from_infinity = false;
   };
 
-  // |peak_delineations[i]| corresponds to |peaks[i]|.
+  // `peak_delineations[i]` corresponds to `peaks[i]`.
   std::vector<PeakDelineation> peak_delineations(peaks.size());
   for (auto& delineation : peak_delineations) {
     for (auto it = wells.begin(); it != wells.end(); ++it) {
@@ -124,7 +124,7 @@ auto Equipotential<InertialFrame, Frame>::ComputeLines(
     auto const& delineation = peak_delineations[i];
     Position<Frame> const& peak = peaks[i];
 
-    // Ignore |peak| if it is below |energy|.
+    // Ignore `peak` if it is below `energy`.
     if (reference_frame_->GeometricPotential(t, peak) < energy) {
       continue;
     }
@@ -134,7 +134,7 @@ auto Equipotential<InertialFrame, Frame>::ComputeLines(
       std::optional<WellIterator> expected_delineated_well;
       bool expect_delineation_from_infinity = false;
       if (!delineation.indistinct_wells.empty()) {
-        // Try to delineate |peak| from the first of its |indistinct_wells|.
+        // Try to delineate `peak` from the first of its `indistinct_wells`.
         expected_delineated_well = *delineation.indistinct_wells.begin();
         Well const well = **expected_delineated_well;
         Length const r = (peak - well.position).Norm();
@@ -168,7 +168,7 @@ auto Equipotential<InertialFrame, Frame>::ComputeLines(
             Barycentre({peak, well.position}, {x, r - x});
         lines.push_back(ComputeLine(plane, t, equipotential_position));
       } else {
-        // Try to delineate |peak| from the well at infinity; this works as for
+        // Try to delineate `peak` from the well at infinity; this works as for
         // an actual well, but instead of picking the point on the edge of the
         // well in the direction of the peak we generate a far away point based
         // on the peak (corresponding to a point on the edge of the well at
diff --git a/physics/equipotential_test.cpp b/physics/equipotential_test.cpp
index 05f10ce937..f038cd3b40 100644
--- a/physics/equipotential_test.cpp
+++ b/physics/equipotential_test.cpp
@@ -118,8 +118,8 @@ class EquipotentialTest : public ::testing::Test {
     return {l4, l5};
   }
 
-  // Logs to Mathematica the equipotential line for the given |body| in the
-  // specified |reference_frame|.
+  // Logs to Mathematica the equipotential line for the given `body` in the
+  // specified `reference_frame`.
   void LogEquipotentialLine(
       Logger& logger,
       Plane<World> const& plane,
@@ -147,8 +147,8 @@ class EquipotentialTest : public ::testing::Test {
   }
 
   // Logs to Mathematica a family of equipotential lines determined by a
-  // parameter.  There must exist an overload of |ComputeLine| with a
-  // |LineParameter| as its third argument.
+  // parameter.  There must exist an overload of `ComputeLine` with a
+  // `LineParameter` as its third argument.
   template<typename LineParameter>
   void LogFamilyOfEquipotentialLines(
       Logger& logger,
diff --git a/physics/euler_solver.hpp b/physics/euler_solver.hpp
index 06c3ecb34d..5fbdf0be96 100644
--- a/physics/euler_solver.hpp
+++ b/physics/euler_solver.hpp
@@ -75,7 +75,7 @@ class EulerSolver {
   AttitudeRotation AttitudeAt(Instant const& time) const;
 
   // The motion of the body at the given time.  The centre of gravity of the
-  // body moves according to |linear_motion|.
+  // body moves according to `linear_motion`.
   RigidMotion<PrincipalAxesFrame, InertialFrame> MotionAt(
       Instant const& time,
       DegreesOfFreedom<InertialFrame> const& linear_motion) const;
diff --git a/physics/frame_field.hpp b/physics/frame_field.hpp
index 8c4420551b..b771cc2b01 100644
--- a/physics/frame_field.hpp
+++ b/physics/frame_field.hpp
@@ -13,9 +13,9 @@ namespace internal {
 using namespace principia::geometry::_rotation;
 using namespace principia::geometry::_space;
 
-// A section of the frame bundle of the manifold |Position|, i.e., a smooth
+// A section of the frame bundle of the manifold `Position`, i.e., a smooth
 // assignment of an orthonormal basis to the tangent space of positions at every
-// |Position| q.
+// `Position` q.
 template<typename Frame, typename ThisFrame>
 class FrameField {
  public:
diff --git a/physics/geopotential.hpp b/physics/geopotential.hpp
index 54ceb25f42..01eab5c219 100644
--- a/physics/geopotential.hpp
+++ b/physics/geopotential.hpp
@@ -34,7 +34,7 @@ template<typename Frame>
 class Geopotential {
  public:
   // Spherical harmonics will not be damped if their contribution to the radial
-  // force exceeds |tolerance| times the central force.
+  // force exceeds `tolerance` times the central force.
   Geopotential(not_null<OblateBody<Frame> const*> body,
                double tolerance);
 
@@ -87,11 +87,11 @@ class Geopotential {
   template<typename>
   class AllDegrees;
 
-  // |limiting_degree| is the first degree such that
-  // |r_norm >= degree_damping_[limiting_degree].outer_threshold()|, or is
-  // |degree_damping_.size()| if |r_norm| is below all thresholds.
-  // Since |degree_damping_[0].outer_threshold()| and
-  // |degree_damping_[1].outer_threshold()| are infinite, |limiting_degree > 1|.
+  // `limiting_degree` is the first degree such that
+  // `r_norm >= degree_damping_[limiting_degree].outer_threshold()`, or is
+  // `degree_damping_.size()` if `r_norm` is below all thresholds.
+  // Since `degree_damping_[0].outer_threshold()` and
+  // `degree_damping_[1].outer_threshold()` are infinite, `limiting_degree > 1`.
   int LimitingDegree(Length const& r_norm) const;
 
   not_null<OblateBody<Frame> const*> body_;
@@ -104,7 +104,7 @@ class Geopotential {
   std::vector<HarmonicDamping> degree_damping_;
 
   // The contribution of the degree 2 sectoral harmonics is damped by
-  // |sectoral_damping_|; |degree_damping_[2]| affects only J2.
+  // `sectoral_damping_`; `degree_damping_[2]` affects only J2.
   // The monotonicity relation
   //   degree_damping[2] ≼ sectoral_damping_ ≼ degree_damping[3]
   // holds, where ≼ denotes the ordering of the thresholds.
diff --git a/physics/geopotential_body.hpp b/physics/geopotential_body.hpp
index e698ab95d0..0da16368b1 100644
--- a/physics/geopotential_body.hpp
+++ b/physics/geopotential_body.hpp
@@ -30,7 +30,7 @@ using namespace principia::quantities::_elementary_functions;
 
 template<typename Frame>
 struct Geopotential<Frame>::Precomputations {
-  // Allocate the maximum size to cover all possible degrees.  Making |size| a
+  // Allocate the maximum size to cover all possible degrees.  Making `size` a
   // template parameter of this class would be possible, but it would greatly
   // increase the number of instances of DegreeNOrderM and friends.
   static constexpr int size = OblateBody<Frame>::max_geopotential_degree + 1;
@@ -682,8 +682,8 @@ Geopotential<Frame>::Geopotential(not_null<OblateBody<Frame> const*> body,
     int n;
     int m;
   };
-  // If |after(left, right)|, |left| is popped after |right| in the
-  // |priority_queue|.
+  // If `after(left, right)`, `left` is popped after `right` in the
+  // `priority_queue`.
   auto const after = [](Threshold const& left, Threshold const& right) -> bool {
     return left.r < right.r ||
            (left.r == right.r &&
@@ -747,10 +747,10 @@ Geopotential<Frame>::GeneralSphericalHarmonicsAcceleration(
     Exponentiation<Length, -3> const& one_over_r³) const {
   if (r_norm != r_norm) {
     // Short-circuit NaN, to avoid having to deal with an unordered
-    // |r_norm| when finding the partition point below.
+    // `r_norm` when finding the partition point below.
     return NaN<ReducedAcceleration> * Vector<double, Frame>{};
   }
-  // We have |max_degree > 0|.
+  // We have `max_degree > 0`.
   int const max_degree = LimitingDegree(r_norm) - 1;
   switch (max_degree) {
     PRINCIPIA_CASE_SPHERICAL_HARMONICS_ACCELERATION(2);
@@ -829,10 +829,10 @@ Geopotential<Frame>::GeneralSphericalHarmonicsPotential(
     Exponentiation<Length, -3> const& one_over_r³) const {
   if (r_norm != r_norm) {
     // Short-circuit NaN, to avoid having to deal with an unordered
-    // |r_norm| when finding the partition point below.
+    // `r_norm` when finding the partition point below.
     return NaN<ReducedPotential>;
   }
-  // We have |max_degree > 0|.
+  // We have `max_degree > 0`.
   int const max_degree = LimitingDegree(r_norm) - 1;
   switch (max_degree) {
     PRINCIPIA_CASE_SPHERICAL_HARMONICS_POTENTIAL(2);
diff --git a/physics/geopotential_test.cpp b/physics/geopotential_test.cpp
index f23f778c39..19c6aa0b60 100644
--- a/physics/geopotential_test.cpp
+++ b/physics/geopotential_test.cpp
@@ -88,8 +88,8 @@ class GeopotentialTest : public ::testing::Test {
                                   right_ascension_of_pole_,
                                   declination_of_pole_) {}
 
-  // Rather confusingly, the quantity called |r| or |displacement| below is
-  // called |-Δq| in ephemeris_body.hpp.
+  // Rather confusingly, the quantity called `r` or `displacement` below is
+  // called `-Δq` in ephemeris_body.hpp.
 
   template<typename Frame>
   static Vector<Quotient<Acceleration, GravitationalParameter>, Frame>
@@ -445,7 +445,7 @@ TEST_F(GeopotentialTest, ThresholdComputation) {
   EXPECT_THAT(geopotential.sectoral_damping().inner_threshold(),
               Eq(Infinity<Length>));
 
-  // TODO(egg): This is brittle; we should have |SolarSystem| utilities for
+  // TODO(egg): This is brittle; we should have `SolarSystem` utilities for
   // that.
   double const earth_c20 = earth_message.geopotential().row(0).column(0).cos();
   earth_message.mutable_geopotential()
@@ -585,12 +585,12 @@ TEST_F(GeopotentialTest, DampedForces) {
   // The bodies underlying the geopotentials below.
   std::vector<not_null<std::unique_ptr<OblateBody<ICRS>>>> earths;
 
-  // |geopotential_degree[n]| has the degree n terms of the geopotential, with
+  // `geopotential_degree[n]` has the degree n terms of the geopotential, with
   // tolerance 0.
   std::array<std::optional<Geopotential<ICRS>>, 6> geopotential_degree;
-  // |geopotential_j2| has the degree 2 zonal term term with tolerance 0.
+  // `geopotential_j2` has the degree 2 zonal term term with tolerance 0.
   std::optional<Geopotential<ICRS>> geopotential_j2;
-  // |geopotential_c22_s22| has degree 2 sectoral terms with tolerance 0.
+  // `geopotential_c22_s22` has degree 2 sectoral terms with tolerance 0.
   std::optional<Geopotential<ICRS>> geopotential_c22_s22;
 
   for (int n = 2; n <= 5; ++n) {
diff --git a/physics/harmonic_damping.hpp b/physics/harmonic_damping.hpp
index 816ef6aab7..22e4653fc8 100644
--- a/physics/harmonic_damping.hpp
+++ b/physics/harmonic_damping.hpp
@@ -33,7 +33,7 @@ class HarmonicDamping final {
   // This class depends on the invariant: outer_threshold = 3 * inner_threshold.
   Length const& inner_threshold() const;
 
-  // Sets σℜ_over_r and grad_σℜ according to σ as defined by |*this|.
+  // Sets σℜ_over_r and grad_σℜ according to σ as defined by `*this`.
   template<typename Frame>
   void ComputeDampedRadialQuantities(
       Length const& r_norm,
diff --git a/physics/hierarchical_system.hpp b/physics/hierarchical_system.hpp
index d85339291c..019a6a8b1c 100644
--- a/physics/hierarchical_system.hpp
+++ b/physics/hierarchical_system.hpp
@@ -32,17 +32,17 @@ class HierarchicalSystem final {
   explicit HierarchicalSystem(
       not_null<std::unique_ptr<MassiveBody const>> primary);
 
-  // Adds the given |body| with the given |parent|.  |parent| must already have
-  // been inserted.  |jacobi_osculating_elements| must be a valid argument to
-  // the constructor of |KeplerOrbit|.
+  // Adds the given `body` with the given `parent`.  `parent` must already have
+  // been inserted.  `jacobi_osculating_elements` must be a valid argument to
+  // the constructor of `KeplerOrbit`.
   void Add(not_null<std::unique_ptr<MassiveBody const>> body,
            not_null<MassiveBody const*> parent,
            KeplerianElements<Frame> const& jacobi_osculating_elements);
 
-  // Puts the barycentre of the system at the motionless origin of |Frame|;
-  // |ConsumeBarycentricSystem().bodies| is in preorder, where the satellites of
+  // Puts the barycentre of the system at the motionless origin of `Frame`;
+  // `ConsumeBarycentricSystem().bodies` is in preorder, where the satellites of
   // a body are ordered by increasing semimajor axis.
-  // |*this| is invalid after a call to |ConsumeBarycentricSystem()|.
+  // `*this` is invalid after a call to `ConsumeBarycentricSystem()`.
   BarycentricSystem ConsumeBarycentricSystem();
 
   void WriteToMessage(
@@ -50,9 +50,9 @@ class HierarchicalSystem final {
 
  private:
   struct Subsystem;
-  // A |System| represents a |primary| body with orbiting |Subsystem|s, e.g.,
-  // the sun and its orbiting planetary systems.  |satellites| may be empty,
-  // representing the body |primary| with no satellites, e.g., Venus.
+  // A `System` represents a `primary` body with orbiting `Subsystem`s, e.g.,
+  // the sun and its orbiting planetary systems.  `satellites` may be empty,
+  // representing the body `primary` with no satellites, e.g., Venus.
   struct System {
     explicit System(not_null<std::unique_ptr<MassiveBody const>> primary)
         : primary(std::move(primary)) {}
@@ -60,9 +60,9 @@ class HierarchicalSystem final {
     not_null<std::unique_ptr<MassiveBody const>> primary;
     std::vector<not_null<std::unique_ptr<Subsystem>>> satellites;
   };
-  // A |Subsystem| is a |System| with osculating elements, seen as the
+  // A `Subsystem` is a `System` with osculating elements, seen as the
   // osculating elements of its barycentre around the inner parent subsystem,
-  // e.g., the elements of the Jovian |Subsystem| would be the osculating
+  // e.g., the elements of the Jovian `Subsystem` would be the osculating
   // elements of the barycentre of the Jovian system around the barycentre of
   // the Sun and inner planets.
   struct Subsystem : public System {
@@ -71,14 +71,14 @@ class HierarchicalSystem final {
     KeplerianElements<Frame> jacobi_osculating_elements;
   };
 
-  // Data about a |Subsystem|.
+  // Data about a `Subsystem`.
   struct BarycentricSubsystem final {
-    // A |MassiveBody| with the mass of the whole subsystem.
+    // A `MassiveBody` with the mass of the whole subsystem.
     std::unique_ptr<MassiveBody> equivalent_body;
     // The bodies composing the subsystem, in preorder, where the satellites
     // are ordered by increasing semimajor axis.
     std::vector<not_null<std::unique_ptr<MassiveBody const>>> bodies;
-    // Their |DegreesOfFreedom| relative to the barycentre of the subsystem, in
+    // Their `DegreesOfFreedom` relative to the barycentre of the subsystem, in
     // the same order.
     std::vector<RelativeDegreesOfFreedom<Frame>> barycentric_degrees_of_freedom;
   };
@@ -92,7 +92,7 @@ class HierarchicalSystem final {
           serialization::HierarchicalSystem::Subsystem>* messages);
 
   System system_;
-  // Invariant: |systems_[p]->primary.get() == p|.
+  // Invariant: `systems_[p]->primary.get() == p`.
   // None of these pointers should be null, but I want to use operator[].
   std::map<not_null<MassiveBody const*>, System*> systems_;
 };
diff --git a/physics/hierarchical_system_body.hpp b/physics/hierarchical_system_body.hpp
index 9fe6e95210..a2193a5048 100644
--- a/physics/hierarchical_system_body.hpp
+++ b/physics/hierarchical_system_body.hpp
@@ -36,7 +36,7 @@ void HierarchicalSystem<Frame>::Add(
   System& parent_system = *systems_[parent];
   parent_system.satellites.emplace_back(
       make_not_null_unique<Subsystem>(std::move(body)));
-  {  // Hide the moved-from |body|.
+  {  // Hide the moved-from `body`.
     not_null<MassiveBody const*> body = unowned_body;
     not_null<Subsystem*> inserted_system =
         parent_system.satellites.back().get();
@@ -105,7 +105,7 @@ HierarchicalSystem<Frame>::ToBarycentric(System& system) {
 
   BarycentricSubsystem result;
 
-  // A reference frame wherein the barycentre of |system| is motionless at the
+  // A reference frame wherein the barycentre of `system` is motionless at the
   // origin.
   using SystemBarycentre = geometry::_frame::Frame<struct SystemBarycentreTag>;
   static DegreesOfFreedom<SystemBarycentre> const system_barycentre = {
@@ -113,20 +113,20 @@ HierarchicalSystem<Frame>::ToBarycentric(System& system) {
   static Identity<SystemBarycentre, Frame> const id_bf;
   static Identity<Frame, SystemBarycentre> const id_fb;
 
-  // Jacobi coordinates for |system|, with satellite subsystems treated as point
+  // Jacobi coordinates for `system`, with satellite subsystems treated as point
   // masses at their barycentres.
   JacobiCoordinates<Frame> jacobi_coordinates(*system.primary);
   // Add the primary first (preorder).
   result.bodies.emplace_back(std::move(system.primary));
 
-  // The |n|th element of |satellite_degrees_of_freedom| contains the list of
-  // degrees of freedom of the bodies in the |n|th satellite subsystem with
+  // The `n`th element of `satellite_degrees_of_freedom` contains the list of
+  // degrees of freedom of the bodies in the `n`th satellite subsystem with
   // respect to their barycentre.
   std::vector<std::vector<RelativeDegreesOfFreedom<Frame>>>
       satellite_degrees_of_freedom;
 
-  // Fill |satellite_degrees_of_freedom|, |jacobi_coordinates|, and
-  // |result.bodies|.
+  // Fill `satellite_degrees_of_freedom`, `jacobi_coordinates`, and
+  // `result.bodies`.
   for (auto const& subsystem : system.satellites) {
     BarycentricSubsystem barycentric_satellite_subsystem =
         ToBarycentric(*subsystem);
@@ -150,13 +150,13 @@ HierarchicalSystem<Frame>::ToBarycentric(System& system) {
     }
   }
 
-  // Fill |result.barycentric_degrees_of_freedom|.
+  // Fill `result.barycentric_degrees_of_freedom`.
   // The primary.
   result.barycentric_degrees_of_freedom.emplace_back(
       id_bf(barycentres_of_subsystems.front() - system_barycentre));
   // The bodies in satellite subsystems.
   for (int n = 0; n < satellite_degrees_of_freedom.size(); ++n) {
-    // |n + 1| because the primary is at |barycentres_of_subsystems[0]|.
+    // `n + 1` because the primary is at `barycentres_of_subsystems[0]`.
     DegreesOfFreedom<SystemBarycentre> const subsystem_barycentre =
         barycentres_of_subsystems[n + 1];
     for (auto const& body_dof_wrt_subsystem_barycentre :
diff --git a/physics/hierarchical_system_test.cpp b/physics/hierarchical_system_test.cpp
index 86cb43d46d..3349fc9928 100644
--- a/physics/hierarchical_system_test.cpp
+++ b/physics/hierarchical_system_test.cpp
@@ -47,7 +47,7 @@ TEST_F(HierarchicalSystemTest, HierarchicalSystem) {
   elements.argument_of_periapsis = 0 * Radian;
   elements.mean_anomaly = 0 * Radian;
 
-  // Invariant: |body_indices[bodies[i]] == i| for all |i|.
+  // Invariant: `body_indices[bodies[i]] == i` for all `i`.
   std::map<not_null<MassiveBody const*>, int> body_indices;
   std::vector<not_null<MassiveBody const*>> bodies;
 
@@ -58,7 +58,7 @@ TEST_F(HierarchicalSystemTest, HierarchicalSystem) {
     return body;
   };
 
-  // We construct a system as follows, where the |body_indices| are, from left
+  // We construct a system as follows, where the `body_indices` are, from left
   // to right, 0, 2, 3, 1.
   // |<1 m>|     |<1 m>|
   // 2     1     1     2
@@ -103,7 +103,7 @@ TEST_F(HierarchicalSystemTest, FromMeanMotions) {
   elements.mean_anomaly = 0 * Radian;
 
 
-  // Invariant: |body_indices[bodies[i]] == i| for all |i|.
+  // Invariant: `body_indices[bodies[i]] == i` for all `i`.
   std::map<not_null<MassiveBody const*>, int> body_indices;
   std::vector<not_null<MassiveBody const*>> bodies;
 
@@ -115,7 +115,7 @@ TEST_F(HierarchicalSystemTest, FromMeanMotions) {
     return body;
   };
 
-  // We construct a system as follows, where the |body_indices| are, from left
+  // We construct a system as follows, where the `body_indices` are, from left
   // to right, 0, 2, 1.  All bodies have unit gravitational parameter.
   // |<1 m>|
   // .     .     .
diff --git a/physics/integration_parameters.hpp b/physics/integration_parameters.hpp
index 8f4eeeb011..7585c0c8af 100644
--- a/physics/integration_parameters.hpp
+++ b/physics/integration_parameters.hpp
@@ -22,18 +22,18 @@ using namespace principia::quantities::_quantities;
 template<typename ODE>
 class AdaptiveStepParameters final {
  public:
-  // The |length_integration_tolerance| is used to compute the
-  // |tolerance_to_error_ratio| for step size control.  The number of steps is
-  // limited to |max_steps|.
+  // The `length_integration_tolerance` is used to compute the
+  // `tolerance_to_error_ratio` for step size control.  The number of steps is
+  // limited to `max_steps`.
   template<typename E = ODE,
            std::enable_if_t<E::order == 1, std::nullptr_t> = nullptr>
   AdaptiveStepParameters(AdaptiveStepSizeIntegrator<E> const& integrator,
                          std::int64_t max_steps,
                          Length const& length_integration_tolerance);
 
-  // The |length_| and |speed_integration_tolerance|s are used to compute the
-  // |tolerance_to_error_ratio| for step size control.  The number of steps is
-  // limited to |max_steps|.
+  // The `length_` and `speed_integration_tolerance`s are used to compute the
+  // `tolerance_to_error_ratio` for step size control.  The number of steps is
+  // limited to `max_steps`.
   template<typename E = ODE,
            std::enable_if_t<E::order == 2, std::nullptr_t> = nullptr>
   AdaptiveStepParameters(AdaptiveStepSizeIntegrator<E> const& integrator,
diff --git a/physics/jacobi_coordinates.hpp b/physics/jacobi_coordinates.hpp
index e62ba6a451..291c77f0db 100644
--- a/physics/jacobi_coordinates.hpp
+++ b/physics/jacobi_coordinates.hpp
@@ -30,15 +30,15 @@ class JacobiCoordinates final {
  public:
   explicit JacobiCoordinates(MassiveBody const& primary);
 
-  // Adds |body| with the given |DegreesOfFreedom| with respect to the
+  // Adds `body` with the given `DegreesOfFreedom` with respect to the
   // barycentre of the existing bodies.
   void Add(MassiveBody const& body,
            RelativeDegreesOfFreedom<Frame> const& dof_relative_to_system);
 
-  // Adds |body| with the |RelativeDegreesOfFreedom| of a |KeplerOrbit| with the
-  // given |KeplerianElements| around the barycentre of the existing bodies.
-  // |osculating_elements_relative_to_system| must be a valid argument to the
-  // constructor of |KeplerOrbit|.
+  // Adds `body` with the `RelativeDegreesOfFreedom` of a `KeplerOrbit` with the
+  // given `KeplerianElements` around the barycentre of the existing bodies.
+  // `osculating_elements_relative_to_system` must be a valid argument to the
+  // constructor of `KeplerOrbit`.
   void Add(
       MassiveBody const& body,
       KeplerianElements<Frame> const& osculating_elements_relative_to_system);
@@ -53,7 +53,7 @@ class JacobiCoordinates final {
       const;
 
  private:
-  // A reference frame parallel to |Frame|, in which the primary is motionless
+  // A reference frame parallel to `Frame`, in which the primary is motionless
   // at the origin.
   using PrimocentricFrame =
       geometry::_frame::Frame<struct PrimocentricFrameTag>;
diff --git a/physics/kepler_orbit.hpp b/physics/kepler_orbit.hpp
index 146c6b89f5..fc1dd226ea 100644
--- a/physics/kepler_orbit.hpp
+++ b/physics/kepler_orbit.hpp
@@ -44,8 +44,8 @@ struct KeplerianElements final {
   // The following two elements are NaN for elliptic orbits.
   std::optional<AngularFrequency> hyperbolic_mean_motion;
   std::optional<Speed> hyperbolic_excess_velocity;
-  // 3. semiminor axis.  The |semiminor_axis| is NaN for hyperbolic orbits, the
-  // |impact_parameter| is NaN for elliptic orbits.
+  // 3. semiminor axis.  The `semiminor_axis` is NaN for hyperbolic orbits, the
+  // `impact_parameter` is NaN for elliptic orbits.
   std::optional<Length> semiminor_axis;
   std::optional<Length> impact_parameter;
   // 4. semilatus rectum.
@@ -94,8 +94,8 @@ class KeplerOrbit final {
   static_assert(!Frame::may_rotate);
 
  public:
-  // Exactly one of the |optional|s must be filled in the given
-  // |KeplerianElements|.
+  // Exactly one of the `optional`s must be filled in the given
+  // `KeplerianElements`.
   KeplerOrbit(MassiveBody const& primary,
               Body const& secondary,
               KeplerianElements<Frame> const& elements_at_epoch,
@@ -105,29 +105,29 @@ class KeplerOrbit final {
               RelativeDegreesOfFreedom<Frame> const& state_vectors,
               Instant const& epoch);
 
-  // The |DegreesOfFreedom| of the secondary minus those of the primary.
+  // The `DegreesOfFreedom` of the secondary minus those of the primary.
   RelativeDegreesOfFreedom<Frame> StateVectors(Instant const& t) const;
 
-  // All |optional|s are filled in the result.
+  // All `optional`s are filled in the result.
   KeplerianElements<Frame> const& elements_at_epoch() const;
 
  private:
-  // |elements| must be minimally specified.  Fills all |optional|s in
-  // |elements|.
+  // `elements` must be minimally specified.  Fills all `optional`s in
+  // `elements`.
   static void CompleteElements(KeplerianElements<Frame>& elements,
                                GravitationalParameter const& μ);
-  // For each category in section I of |elements|, either one, none, or all of
-  // the |optional|s must be filled.  If one is filled, fills the others in that
+  // For each category in section I of `elements`, either one, none, or all of
+  // the `optional`s must be filled.  If one is filled, fills the others in that
   // category.
   static void CompleteConicParametersByCategory(
       KeplerianElements<Frame>& elements,
       GravitationalParameter const& μ);
-  // Section I of |elements| must be minimally specified.  Fills it.
+  // Section I of `elements` must be minimally specified.  Fills it.
   static void CompleteConicParameters(KeplerianElements<Frame>& elements,
                                       GravitationalParameter const& μ);
-  // Section II of |elements| must be minimally specified.  Fills it.
+  // Section II of `elements` must be minimally specified.  Fills it.
   static void CompleteOrientationParameters(KeplerianElements<Frame>& elements);
-  // Sections I and II of |elements| must be filled; section III must be
+  // Sections I and II of `elements` must be filled; section III must be
   // minimally specified.  Fills section III.
   static void CompleteAnomalies(KeplerianElements<Frame>& elements);
 
diff --git a/physics/kepler_orbit_body.hpp b/physics/kepler_orbit_body.hpp
index 157485a225..b93a2aacfd 100644
--- a/physics/kepler_orbit_body.hpp
+++ b/physics/kepler_orbit_body.hpp
@@ -171,8 +171,8 @@ KeplerOrbit<Frame>::KeplerOrbit(
   Angle const ω =
       ReduceAngle<0, 2 * π>(OrientedAngleBetween(ascending_node, periapsis, h));
   // Longitude of ascending node.
-  // This is equivalent to |OrientedAngleBetween(x, ascending_node, x_wedge_y)|
-  // since |ascending_node| lies in the xy plane.
+  // This is equivalent to `OrientedAngleBetween(x, ascending_node, x_wedge_y)`
+  // since `ascending_node` lies in the xy plane.
   Angle const Ω = ReduceAngle<0, 2 * π>(
       ArcTan(ascending_node.coordinates().y, ascending_node.coordinates().x));
   Angle const true_anomaly =
diff --git a/physics/massive_body.hpp b/physics/massive_body.hpp
index d8d2685eb5..fbb22a7b4e 100644
--- a/physics/massive_body.hpp
+++ b/physics/massive_body.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |Body| must be included in
+// The files containing the tree of child classes of `Body` must be included in
 // the order of inheritance to avoid circular dependencies.
 #ifndef PRINCIPIA_PHYSICS_BODY_HPP_
 #include "physics/body.hpp"
@@ -67,7 +67,7 @@ class MassiveBody : public Body {
   // Returns false.
   bool is_oblate() const override;
 
-  // Call the following |WriteToMessage|, which dispatches to the proper
+  // Call the following `WriteToMessage`, which dispatches to the proper
   // subclass.
   void WriteToMessage(not_null<serialization::Body*> message) const override;
 
@@ -76,7 +76,7 @@ class MassiveBody : public Body {
   virtual void WriteToMessage(
       not_null<serialization::MassiveBody*> message) const;
 
-  // |message.has_massive_body()| must be true.
+  // `message.has_massive_body()` must be true.
   static not_null<std::unique_ptr<MassiveBody>> ReadFromMessage(
       serialization::Body const& message);
 
diff --git a/physics/massless_body.hpp b/physics/massless_body.hpp
index 886aa89779..4bd6822774 100644
--- a/physics/massless_body.hpp
+++ b/physics/massless_body.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |Body| must be included in
+// The files containing the tree of child classes of `Body` must be included in
 // the order of inheritance to avoid circular dependencies.
 #ifndef PRINCIPIA_PHYSICS_BODY_HPP_
 #include "physics/body.hpp"
@@ -35,7 +35,7 @@ class MasslessBody : public Body {
   virtual void WriteToMessage(
       not_null<serialization::MasslessBody*> message) const;
 
-  // |message.has_massless_body()| must be true.
+  // `message.has_massless_body()` must be true.
   static not_null<std::unique_ptr<MasslessBody>> ReadFromMessage(
       serialization::Body const& message);
 
diff --git a/physics/mechanical_system.hpp b/physics/mechanical_system.hpp
index 8eee0fefab..8c37da7b8e 100644
--- a/physics/mechanical_system.hpp
+++ b/physics/mechanical_system.hpp
@@ -33,11 +33,11 @@ using namespace principia::quantities::_quantities;
 
 // Computes the instantaneous overall properties of a mechanical system.
 // Effectively an extension of
-// |BarycentreCalculator<DegreesOfFreedom<InertialFrame>, Mass>| that also
+// `BarycentreCalculator<DegreesOfFreedom<InertialFrame>, Mass>` that also
 // handles rotational motion.
-// |InertialFrame| is an inertial frame in which the motion of the member bodies
-// is given; |SystemFrame| is a non-rotating frame with the same axes as
-// |InertialFrame| and whose origin is the centre of mass of the system.
+// `InertialFrame` is an inertial frame in which the motion of the member bodies
+// is given; `SystemFrame` is a non-rotating frame with the same axes as
+// `InertialFrame` and whose origin is the centre of mass of the system.
 template<typename InertialFrame, typename SystemFrame>
 class MechanicalSystem {
  public:
@@ -52,17 +52,17 @@ class MechanicalSystem {
                     InertiaTensor<BodyFrame> const& tensors);
 
   // The motion of a non-rotating frame whose origin is the centre of mass of
-  // the system, and whose axes are those of |InertialFrame|.
+  // the system, and whose axes are those of `InertialFrame`.
   RigidMotion<SystemFrame, InertialFrame> LinearMotion() const;
   // The total mass.
   Mass const& mass() const;
   // The centre of mass.
   DegreesOfFreedom<InertialFrame> centre_of_mass() const;
   // The total angular momentum of the system, with respect to the origin of
-  // |SystemFrame|, i.e., the centre of mass of the system.
+  // `SystemFrame`, i.e., the centre of mass of the system.
   Bivector<AngularMomentum, SystemFrame> AngularMomentum() const;
   // The moments of inertia of the system, with respect to the origin of
-  // |SystemFrame|, i.e., the centre of mass of the system.
+  // `SystemFrame`, i.e., the centre of mass of the system.
   InertiaTensor<SystemFrame> InertiaTensor() const;
 
  private:
@@ -81,13 +81,13 @@ class MechanicalSystem {
   // contribute to the overall inertia.
   //
   // Note: It is more natural to manipulate the inertia tensor as a
-  // |SymmetricBilinearForm<MomentOfInertia, Frame, Vector>| than a
-  // |SymmetricBilinearForm<MomentOfInertia, Frame, Bivector>|.
+  // `SymmetricBilinearForm<MomentOfInertia, Frame, Vector>` than a
+  // `SymmetricBilinearForm<MomentOfInertia, Frame, Bivector>`.
   // The former has coordinates
   //   ⎛ ∑x²   ∑xy   ∑xy ⎞
   //   ⎜ ∑yx   ∑y²   ∑yz ⎟
   //   ⎝ ∑zx   ∑zy   ∑z² ⎠
-  // whereas the latter (obtained from the former by |Anticommutator()|) has the
+  // whereas the latter (obtained from the former by `Anticommutator()`) has the
   // coordinates
   //   ⎛ ∑(y² + z²)   -∑xy      -∑xy    ⎞
   //   ⎜    -∑yx   ∑(x² + z²)   -∑yz    ⎟
@@ -95,7 +95,7 @@ class MechanicalSystem {
   // It is however common practice in physics to use the bilinear form on
   // bivectors, and to call its eigenvalues the principal moments of inertia.
   // This class thus exposes the form on bivectors in its API, and uses
-  // |AnticommutatorInverse()| and |Anticommutator()| to convert between it and
+  // `AnticommutatorInverse()` and `Anticommutator()` to convert between it and
   // the form on vectors used internally.
   SymmetricBilinearForm<MomentOfInertia, InertialFrame, Vector>
       sum_of_inertia_tensors_;
diff --git a/physics/mechanical_system_test.cpp b/physics/mechanical_system_test.cpp
index dcb7aabdaf..0e118dc0f7 100644
--- a/physics/mechanical_system_test.cpp
+++ b/physics/mechanical_system_test.cpp
@@ -105,10 +105,10 @@ TEST_F(MechanicalSystemTest, RigidTwoPointMasses) {
   Bivector<double, SystemFrame> const axis = Normalize(L);
   SymmetricBilinearForm<MomentOfInertia, SystemFrame, Bivector> const I =
       system_.InertiaTensor();
-  // Compute the kinetic energy of the system in |InertialFrame| as the energy
+  // Compute the kinetic energy of the system in `InertialFrame` as the energy
   // of its linear motion plus that of its rotational motion, and compare that
   // with sum of the kinetic energies of the point masses.  Note that m1 is
-  // stationary in |InertialFrame|.
+  // stationary in `InertialFrame`.
   EXPECT_THAT(p.Norm²() / (2 * m) + (L / Radian).Norm²() / (2 * I(axis, axis)),
               Eq(0.5 * m2 * Pow<2>(v)));
 }
diff --git a/physics/mock_ephemeris.hpp b/physics/mock_ephemeris.hpp
index e825c75fa6..d3094674a4 100644
--- a/physics/mock_ephemeris.hpp
+++ b/physics/mock_ephemeris.hpp
@@ -131,7 +131,7 @@ ACTION_P2(AppendToDiscreteTrajectory, time, degrees_of_freedom) {
 
 ACTION_P3(AppendToDiscreteTrajectory, trajectory, time, degrees_of_freedom) {
   // The extra level of indirection is useful for tests that get a pointer to a
-  // trajectory and squirrel it away using |SaveArg<N>|.
+  // trajectory and squirrel it away using `SaveArg<N>`.
   EXPECT_OK((*trajectory)->Append(time, degrees_of_freedom));
 }
 
diff --git a/physics/oblate_body.hpp b/physics/oblate_body.hpp
index 8e7fa0a1a5..d45ef0173e 100644
--- a/physics/oblate_body.hpp
+++ b/physics/oblate_body.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |Body| must be included in
+// The files containing the tree of child classes of `Body` must be included in
 // the order of inheritance to avoid circular dependencies.
 #ifndef PRINCIPIA_PHYSICS_ROTATING_BODY_HPP_
 #include "physics/rotating_body.hpp"
diff --git a/physics/protector.hpp b/physics/protector.hpp
index 7e3c66a522..b6cd81f186 100644
--- a/physics/protector.hpp
+++ b/physics/protector.hpp
@@ -27,8 +27,8 @@ class Protector {
   // state of the protector permits it.
   using Callback = std::function<void()>;
 
-  // If the range ]-∞, t[ is unprotected, |callback| is run immediately and this
-  // function returns true.  Otherwise |callback| is delayed and will be run as
+  // If the range ]-∞, t[ is unprotected, `callback` is run immediately and this
+  // function returns true.  Otherwise `callback` is delayed and will be run as
   // soon as ]-∞, t[ becomes unprotected; returns false in this case.  The
   // callbacks are run without any lock held, in time order.
   bool RunWhenUnprotected(Instant const& t, Callback callback);
diff --git a/physics/reference_frame.hpp b/physics/reference_frame.hpp
index 1be81d4630..1f6346557a 100644
--- a/physics/reference_frame.hpp
+++ b/physics/reference_frame.hpp
@@ -32,7 +32,7 @@ using namespace principia::physics::_ephemeris;
 using namespace principia::physics::_similar_motion;
 using namespace principia::quantities::_named_quantities;
 
-// The Frenet frame of a free fall trajectory in |Frame|.
+// The Frenet frame of a free fall trajectory in `Frame`.
 // TODO(egg): this should actually depend on its template parameter somehow.
 template<typename Frame>
 using Frenet = geometry::_frame::Frame<serialization::Frame::PhysicsTag,
@@ -40,8 +40,8 @@ using Frenet = geometry::_frame::Frame<serialization::Frame::PhysicsTag,
                                        Handedness::Right,
                                        serialization::Frame::FRENET>;
 
-// The definition of a reference frame |ThisFrame| in arbitrary motion with
-// respect to the inertial reference frame |InertialFrame|.
+// The definition of a reference frame `ThisFrame` in arbitrary motion with
+// respect to the inertial reference frame `InertialFrame`.
 template<typename InertialFrame, typename ThisFrame>
 class ReferenceFrame {
   static_assert(InertialFrame::is_inertial, "InertialFrame must be inertial");
@@ -49,33 +49,33 @@ class ReferenceFrame {
  public:
   virtual ~ReferenceFrame() = default;
 
-  // The operations that take an |Instant| are valid in the range
+  // The operations that take an `Instant` are valid in the range
   // [t_min, t_max].
   virtual Instant t_min() const = 0;
   virtual Instant t_max() const = 0;
 
-  // At least one of |ToThisFrameAtTimeSimilarly| and
-  // |FromThisFrameAtTimeSimilarly| must be overriden in derived classes; the
+  // At least one of `ToThisFrameAtTimeSimilarly` and
+  // `FromThisFrameAtTimeSimilarly` must be overriden in derived classes; the
   // default implementation inverts the other one.
   virtual SimilarMotion<InertialFrame, ThisFrame> ToThisFrameAtTimeSimilarly(
       Instant const& t) const;
   virtual SimilarMotion<ThisFrame, InertialFrame> FromThisFrameAtTimeSimilarly(
       Instant const& t) const;
 
-  // The acceleration due to the non-inertial motion of |ThisFrame| and gravity.
+  // The acceleration due to the non-inertial motion of `ThisFrame` and gravity.
   // A particle in free fall follows a trajectory whose second derivative
-  // is |GeometricAcceleration|.
+  // is `GeometricAcceleration`.
   virtual Vector<Acceleration, ThisFrame> GeometricAcceleration(
       Instant const& t,
       DegreesOfFreedom<ThisFrame> const& degrees_of_freedom) const = 0;
 
-  // The acceleration of a particle at rest in |ThisFrame| at the given
-  // |position| owing to non-inertial motion of |ThisFrame| and gravity,
+  // The acceleration of a particle at rest in `ThisFrame` at the given
+  // `position` owing to non-inertial motion of `ThisFrame` and gravity,
   // excluding components with a rotation.
-  // Let r be the radial vector (from the origin of |ThisFrame|) corresponding
-  // to |position|.
+  // Let r be the radial vector (from the origin of `ThisFrame`) corresponding
+  // to `position`.
   // Let r ↦ r″ be the vector field of free fall accelerations from rest in
-  // |ThisFrame| at t. This function returns
+  // `ThisFrame` at t. This function returns
   //   a = r″ - (rot r″) r / 2.
   // In a rotating reference frame, this may equivalently be expressed using
   // the second derivative of position with respect to the parametrization on
@@ -88,13 +88,13 @@ class ReferenceFrame {
       Position<ThisFrame> const& position) const = 0;
 
   // Computes the (scalar) potential from which the acceleration given by
-  // |RotationFreeGeometricAccelerationAtRest| derives.
+  // `RotationFreeGeometricAccelerationAtRest` derives.
   virtual SpecificEnergy GeometricPotential(
       Instant const& t,
       Position<ThisFrame> const& position) const = 0;
 
-  // The definition of the Frenet frame of a free fall trajectory in |ThisFrame|
-  // with the given |degrees_of_freedom| at instant |t|.
+  // The definition of the Frenet frame of a free fall trajectory in `ThisFrame`
+  // with the given `degrees_of_freedom` at instant `t`.
   virtual Rotation<Frenet<ThisFrame>, ThisFrame> FrenetFrame(
       Instant const& t,
       DegreesOfFreedom<ThisFrame> const& degrees_of_freedom) const;
diff --git a/physics/reference_frame_body.hpp b/physics/reference_frame_body.hpp
index e2ec8d2467..41abe60c1a 100644
--- a/physics/reference_frame_body.hpp
+++ b/physics/reference_frame_body.hpp
@@ -48,7 +48,7 @@ ReferenceFrame<InertialFrame, ThisFrame>::FrenetFrame(
   Vector<double, ThisFrame> tangent = Normalize(velocity);
   Vector<double, ThisFrame> normal = Normalize(normal_acceleration);
   Bivector<double, ThisFrame> binormal = Wedge(tangent, normal);
-  // Maps |tangent| to {1, 0, 0}, |normal| to {0, 1, 0}, and |binormal| to
+  // Maps `tangent` to {1, 0, 0}, `normal` to {0, 1, 0}, and `binormal` to
   // {0, 0, 1}.
   return Rotation<Frenet<ThisFrame>, ThisFrame>(tangent, normal, binormal);
 }
diff --git a/physics/rigid_motion.hpp b/physics/rigid_motion.hpp
index ce55c0484e..62108957f7 100644
--- a/physics/rigid_motion.hpp
+++ b/physics/rigid_motion.hpp
@@ -33,9 +33,9 @@ using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 using namespace principia::quantities::_si;
 
-// The instantaneous motion of |ToFrame| with respect to |FromFrame|.
-// This is the derivative of a |RigidTransformation<FromFrame, ToFrame>|.
-// In order to invert, the |RigidTransformation| is needed, and we need its
+// The instantaneous motion of `ToFrame` with respect to `FromFrame`.
+// This is the derivative of a `RigidTransformation<FromFrame, ToFrame>`.
+// In order to invert, the `RigidTransformation` is needed, and we need its
 // linear part anyway, so we store it (and we forward its action on positions).
 template<typename FromFrame, typename ToFrame>
 class RigidMotion final {
@@ -57,7 +57,7 @@ class RigidMotion final {
       Velocity<ToFrame> const& velocity_of_from_frame_origin);
 
   RigidTransformation<FromFrame, ToFrame> const& rigid_transformation() const;
-  // Returns |rigid_transformation().linear_map()|.
+  // Returns `rigid_transformation().linear_map()`.
   OrthogonalMap<FromFrame, ToFrame> const& orthogonal_map() const;
 
   template<typename F>
@@ -73,12 +73,12 @@ class RigidMotion final {
   template<template<typename, typename> typename SimilarMotion>
   SimilarMotion<FromFrame, ToFrame> Forget() const;
 
-  // A rigid motion expressing that |FromFrame| and |ToFrame| have the same
+  // A rigid motion expressing that `FromFrame` and `ToFrame` have the same
   // axes, origin, and instantaneous motion.
   // This function is enabled only if both frames have the same handedness (this
-  // is a requirement of OrthogonalMap::Identity) and if the |motion| of
-  // FromFrame is a special case of that of |ToFrame| (see the comments on
-  // |FrameMotion|).
+  // is a requirement of OrthogonalMap::Identity) and if the `motion` of
+  // FromFrame is a special case of that of `ToFrame` (see the comments on
+  // `FrameMotion`).
   template<typename F = FromFrame,
            typename T = ToFrame,
            typename = std::enable_if_t<(F::handedness == T::handedness &&
@@ -96,7 +96,7 @@ class RigidMotion final {
  private:
   RigidTransformation<FromFrame, ToFrame> rigid_transformation_;
   // d/dt rigid_transformation⁻¹(basis of ToFrame). The positively oriented
-  // orthogonal bases of |FromFrame| are acted upon faithfully and transitively
+  // orthogonal bases of `FromFrame` are acted upon faithfully and transitively
   // by SO(FromFrame), so this lies in the tangent space, i.e., the Lie algebra
   // 𝖘𝔬(FromFrame) ≅ FromFrame ∧ FromFrame.
   AngularVelocity<FromFrame> angular_velocity_of_to_frame_;
@@ -117,7 +117,7 @@ RigidMotion<FromFrame, ToFrame> operator*(
     RigidMotion<ThroughFrame, ToFrame> const& left,
     RigidMotion<FromFrame, ThroughFrame> const& right);
 
-// A |RigidTransformation|, its first derivative (a |RigidMotion|), and its
+// A `RigidTransformation`, its first derivative (a `RigidMotion`), and its
 // second derivative (angular and linear accelerations).
 template<typename FromFrame, typename ToFrame>
 class AcceleratedRigidMotion final {
diff --git a/physics/rigid_reference_frame.hpp b/physics/rigid_reference_frame.hpp
index 218c048c8c..545d220c78 100644
--- a/physics/rigid_reference_frame.hpp
+++ b/physics/rigid_reference_frame.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |ReferenceFrame| must be
+// The files containing the tree of child classes of `ReferenceFrame` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
@@ -44,8 +44,8 @@ using namespace principia::physics::_similar_motion;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// The definition of a reference frame |ThisFrame| in arbitrary motion with
-// respect to the inertial reference frame |InertialFrame|.
+// The definition of a reference frame `ThisFrame` in arbitrary motion with
+// respect to the inertial reference frame `InertialFrame`.
 template<typename InertialFrame, typename ThisFrame>
 class RigidReferenceFrame : public ReferenceFrame<InertialFrame, ThisFrame> {
  public:
@@ -56,7 +56,7 @@ class RigidReferenceFrame : public ReferenceFrame<InertialFrame, ThisFrame> {
   SimilarMotion<ThisFrame, InertialFrame> FromThisFrameAtTimeSimilarly(
       Instant const& t) const final;
 
-  // At least one of |ToThisFrameAtTime| and |FromThisFrameAtTime| must be
+  // At least one of `ToThisFrameAtTime` and `FromThisFrameAtTime` must be
   // overriden in derived classes; the default implementation inverts the other
   // one.
   virtual RigidMotion<InertialFrame, ThisFrame> ToThisFrameAtTime(
@@ -64,20 +64,20 @@ class RigidReferenceFrame : public ReferenceFrame<InertialFrame, ThisFrame> {
   virtual RigidMotion<ThisFrame, InertialFrame> FromThisFrameAtTime(
       Instant const& t) const;
 
-  // The acceleration due to the non-inertial motion of |ThisFrame| and gravity.
+  // The acceleration due to the non-inertial motion of `ThisFrame` and gravity.
   // A particle in free fall follows a trajectory whose second derivative
-  // is |GeometricAcceleration|.
+  // is `GeometricAcceleration`.
   virtual Vector<Acceleration, ThisFrame> GeometricAcceleration(
       Instant const& t,
       DegreesOfFreedom<ThisFrame> const& degrees_of_freedom) const;
 
-  // The acceleration of a particle at rest in |ThisFrame| at the given
-  // |position| owing to non-inertial motion of |ThisFrame| and gravity,
+  // The acceleration of a particle at rest in `ThisFrame` at the given
+  // `position` owing to non-inertial motion of `ThisFrame` and gravity,
   // excluding components with a rotation.
-  // Let r be the radial vector (from the origin of |ThisFrame|) corresponding
-  // to |position|.
+  // Let r be the radial vector (from the origin of `ThisFrame`) corresponding
+  // to `position`.
   // Let r ↦ r″ be the vector field of free fall accelerations from rest in
-  // |ThisFrame| at t. This function returns
+  // `ThisFrame` at t. This function returns
   //   a = r″ - (rot r″) r / 2.
   // In a rotating reference frame, this may equivalently be expressed using
   // the second derivative of position with respect to the parametrization on
@@ -90,7 +90,7 @@ class RigidReferenceFrame : public ReferenceFrame<InertialFrame, ThisFrame> {
       Position<ThisFrame> const& position) const;
 
   // Computes the (scalar) potential from which the acceleration given by
-  // |RotationFreeGeometricAccelerationAtRest| derives.
+  // `RotationFreeGeometricAccelerationAtRest` derives.
   virtual SpecificEnergy GeometricPotential(
       Instant const& t,
       Position<ThisFrame> const& position) const;
@@ -123,7 +123,7 @@ class RigidReferenceFrame : public ReferenceFrame<InertialFrame, ThisFrame> {
   };
 
   // Computes the orthogonal and orthonormal trihedra associated with
-  // |ThisFrame|.
+  // `ThisFrame`.
   static void ComputeTrihedra(
       Displacement<InertialFrame> const& r,
       Velocity<InertialFrame> const& ṙ,
@@ -153,16 +153,16 @@ class RigidReferenceFrame : public ReferenceFrame<InertialFrame, ThisFrame> {
       Trihedron<Length, ArealSpeed, 2>& 𝛛²orthogonal,
       Trihedron<double, double, 2>& 𝛛²orthonormal);
 
-  // Computes the rotation that maps |InertialFrame| to |ThisFrame|.
+  // Computes the rotation that maps `InertialFrame` to `ThisFrame`.
   static Rotation<InertialFrame, ThisFrame> ComputeRotation(
       Trihedron<double, double> const& orthonormal);
 
-  // Computes the angular velocity of |ThisFrame| in |InertialFrame|.
+  // Computes the angular velocity of `ThisFrame` in `InertialFrame`.
   static AngularVelocity<InertialFrame> ComputeAngularVelocity(
       Trihedron<double, double> const& orthonormal,
       Trihedron<double, double, 1> const& 𝛛orthonormal);
 
-  // Computes the angular acceleration of |ThisFrame| in |InertialFrame|.
+  // Computes the angular acceleration of `ThisFrame` in `InertialFrame`.
   static Bivector<AngularAcceleration, InertialFrame>
   ComputeAngularAcceleration(Trihedron<double, double> const& orthonormal,
                              Trihedron<double, double, 1> const& 𝛛orthonormal,
diff --git a/physics/rigid_reference_frame_body.hpp b/physics/rigid_reference_frame_body.hpp
index 70286dad1d..9662329712 100644
--- a/physics/rigid_reference_frame_body.hpp
+++ b/physics/rigid_reference_frame_body.hpp
@@ -136,9 +136,9 @@ RigidReferenceFrame<InertialFrame, ThisFrame>::ReadFromMessage(
     not_null<Ephemeris<InertialFrame> const*> const ephemeris) {
   std::unique_ptr<RigidReferenceFrame> result;
   int extensions_found = 0;
-  // NOTE(egg): the |static_cast|ing below is needed on MSVC, because the silly
+  // NOTE(egg): the `static_cast`ing below is needed on MSVC, because the silly
   // compiler doesn't see the
-  // |operator std::unique_ptr<RigidReferenceFrame>() &&|.
+  // `operator std::unique_ptr<RigidReferenceFrame>() &&`.
   if (message.HasExtension(
           serialization::BarycentricRotatingReferenceFrame::extension)) {
     ++extensions_found;
@@ -221,7 +221,7 @@ void RigidReferenceFrame<InertialFrame, ThisFrame>::ComputeTrihedra(
     Velocity<InertialFrame> const& ṙ,
     Trihedron<Length, ArealSpeed>& orthogonal,
     Trihedron<double, double>& orthonormal) {
-  // Our orthogonal (but not orthonormal) trihedron for |ThisFrame|.
+  // Our orthogonal (but not orthonormal) trihedron for `ThisFrame`.
   Displacement<InertialFrame> const& F = r;
   Bivector<ArealSpeed, InertialFrame> const B = Wedge(r, ṙ);
   Vector<Product<Length, ArealSpeed>, InertialFrame> const N = B * F;
@@ -248,7 +248,7 @@ void RigidReferenceFrame<InertialFrame, ThisFrame>::ComputeTrihedraDerivatives(
   auto const& N = orthogonal.normal;
   auto const& B = orthogonal.binormal;
 
-  // The derivatives of the |orthogonal| trihedron.
+  // The derivatives of the `orthogonal` trihedron.
   Velocity<InertialFrame> const& Ḟ = ṙ;
   Bivector<Variation<ArealSpeed>, InertialFrame> const Ḃ = Wedge(r, r̈);
   Vector<Variation<Product<Length, ArealSpeed>>, InertialFrame> const Ṅ =
@@ -259,7 +259,7 @@ void RigidReferenceFrame<InertialFrame, ThisFrame>::ComputeTrihedraDerivatives(
     return (v.Norm²() * v̇ - InnerProduct(v, v̇) * v) / Pow<3>(v.Norm());
   };
 
-  // The derivatives of the |orthonormal| trihedron.
+  // The derivatives of the `orthonormal` trihedron.
   Vector<Variation<double>, InertialFrame> const ḟ = 𝛛normalized(F, Ḟ);
   Vector<Variation<double>, InertialFrame> const ṅ = 𝛛normalized(N, Ṅ);
   Bivector<Variation<double>, InertialFrame> const ḃ = 𝛛normalized(B, Ḃ);
@@ -287,7 +287,7 @@ void RigidReferenceFrame<InertialFrame, ThisFrame>::ComputeTrihedraDerivatives2(
   auto const& Ṅ = 𝛛orthogonal.normal;
   auto const& Ḃ = 𝛛orthogonal.binormal;
 
-  // The second derivatives of the |orthogonal| trihedron.
+  // The second derivatives of the `orthogonal` trihedron.
   Vector<Acceleration, InertialFrame> const& F̈ = r̈;
   Bivector<Variation<ArealSpeed, 2>, InertialFrame> const B̈ =
       Wedge(ṙ, r̈) + Wedge(r, r⁽³⁾);
@@ -304,7 +304,7 @@ void RigidReferenceFrame<InertialFrame, ThisFrame>::ComputeTrihedraDerivatives2(
            3 * v * Pow<2>(InnerProduct(v, v̇)) / Pow<5>(v.Norm());
   };
 
-  // The second derivatives of the |orthonormal| trihedron.
+  // The second derivatives of the `orthonormal` trihedron.
   Vector<Variation<double, 2>, InertialFrame> const f̈ = 𝛛²normalized(F, Ḟ, F̈);
   Vector<Variation<double, 2>, InertialFrame> const n̈ = 𝛛²normalized(N, Ṅ, N̈);
   Bivector<Variation<double, 2>, InertialFrame> const b̈ = 𝛛²normalized(B, Ḃ, B̈);
diff --git a/physics/rigid_reference_frame_test.cpp b/physics/rigid_reference_frame_test.cpp
index 00f27e3d26..706e6c7bb7 100644
--- a/physics/rigid_reference_frame_test.cpp
+++ b/physics/rigid_reference_frame_test.cpp
@@ -62,7 +62,7 @@ class ReferenceFrameTest : public testing::Test {
   using Translating = Rotating;  // A better name for linear acceleration.
 
   // Computes a first-order approximation of the acceleration using the
-  // potential returned by |mock_frame_|.  Useful for checking that the
+  // potential returned by `mock_frame_`.  Useful for checking that the
   // potential and the accelaration are consistent.
   Vector<Acceleration, Rotating> FirstOrderAccelerationFromPotential(
       Instant const& t,
diff --git a/physics/rotating_body.hpp b/physics/rotating_body.hpp
index f3ea2cc795..8fe7f2d9c2 100644
--- a/physics/rotating_body.hpp
+++ b/physics/rotating_body.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |Body| must be included in
+// The files containing the tree of child classes of `Body` must be included in
 // the order of inheritance to avoid circular dependencies.
 #ifndef PRINCIPIA_PHYSICS_MASSIVE_BODY_HPP_
 #include "physics/massive_body.hpp"
@@ -40,12 +40,12 @@ class RotatingBody : public MassiveBody {
  public:
   class Parameters final {
    public:
-    // |reference_angle| is the angle of the prime meridian at
-    // |reference_instant|.  |angular_frequency| gives the rate of rotation of
+    // `reference_angle` is the angle of the prime meridian at
+    // `reference_instant`.  `angular_frequency` gives the rate of rotation of
     // the body around the pole (it may be negative, as is the convention for
     // planets and satellites whose rotation is retrograde).  The direction of
-    // the pole is specified in |Frame| using |right_ascension_of_pole| and
-    // |declination_of_pole|.
+    // the pole is specified in `Frame` using `right_ascension_of_pole` and
+    // `declination_of_pole`.
     Parameters(Length const& min_radius,
                Length const& mean_radius,
                Length const& max_radius,
@@ -88,11 +88,11 @@ class RotatingBody : public MassiveBody {
   // at construction.
   Vector<double, Frame> const& polar_axis() const;
 
-  // Two unit vectors in the equatorial plane of the body.  |biequatorial| is
-  // also in the equatorial plane of Frame.  The basis |equatorial|,
-  // |biequatorial|, |polar_axis| has the same orientation as that of |Frame|.
+  // Two unit vectors in the equatorial plane of the body.  `biequatorial` is
+  // also in the equatorial plane of Frame.  The basis `equatorial`,
+  // `biequatorial`, `polar_axis` has the same orientation as that of `Frame`.
   // In the figures of the 2015 IAU WGCCRE report (figure 1 or 2 depending on
-  // the convention used for |polar_axis|), |biequatorial| is the node Q.
+  // the convention used for `polar_axis`), `biequatorial` is the node Q.
   Vector<double, Frame> const& biequatorial() const;
   Vector<double, Frame> const& equatorial() const;
 
@@ -109,15 +109,15 @@ class RotatingBody : public MassiveBody {
   // and angular frequency passed at construction.
   AngularVelocity<Frame> const& angular_velocity() const;
 
-  // Returns the position at time |t|.
+  // Returns the position at time `t`.
   Angle AngleAt(Instant const& t) const;
 
   // Returns the rotation relating the reference frame of the surface of this
-  // body to |Frame|.  The reference frame of the surface is defined as follows:
-  //   - the z axis is the |polar_axis|;
+  // body to `Frame`.  The reference frame of the surface is defined as follows:
+  //   - the z axis is the `polar_axis`;
   //   - the x axis points from the centre of the body to the reference
   //     meridian;
-  //   - the reference frame has the same handedness as |Frame|.
+  //   - the reference frame has the same handedness as `Frame`.
   // Following this definition,
   //   Displacement<SurfaceFrame>(RadiusLatitudeLongitude(r, φ, λ))
   // converts planetocentric coordinates to a displacement from the body centre
@@ -132,10 +132,10 @@ class RotatingBody : public MassiveBody {
   Rotation<Frame, SurfaceFrame> ToSurfaceFrame(Instant const& t) const;
 
   // Returns the rotation relating the celestial reference frame of this
-  // body to |Frame|.  The celestial reference frame is defined as follows:
-  //   - the z axis is the |polar_axis|;
-  //   - the x axis is the |equatorial| vector;
-  //   - the reference frame has the same handedness as |Frame|.
+  // body to `Frame`.  The celestial reference frame is defined as follows:
+  //   - the z axis is the `polar_axis`;
+  //   - the x axis is the `equatorial` vector;
+  //   - the reference frame has the same handedness as `Frame`.
   template<typename CelestialFrame>
   Rotation<Frame, CelestialFrame> ToCelestialFrame() const;
 
@@ -150,7 +150,7 @@ class RotatingBody : public MassiveBody {
   void WriteToMessage(
       not_null<serialization::MassiveBody*> message) const override;
 
-  // Fails if the |RotatingBody| extension is absent from the message.
+  // Fails if the `RotatingBody` extension is absent from the message.
   static not_null<std::unique_ptr<RotatingBody<Frame>>> ReadFromMessage(
       serialization::RotatingBody const& message,
       MassiveBody::Parameters const& massive_body_parameters);
diff --git a/physics/rotating_body_body.hpp b/physics/rotating_body_body.hpp
index 401362b217..e0c3153512 100644
--- a/physics/rotating_body_body.hpp
+++ b/physics/rotating_body_body.hpp
@@ -108,7 +108,7 @@ template<typename Frame>
 template<typename CelestialFrame>
 Rotation<Frame, CelestialFrame> RotatingBody<Frame>::ToCelestialFrame()
     const {
-  // In coordinates, the third parameter is |polar_axis|, but we seem
+  // In coordinates, the third parameter is `polar_axis`, but we seem
   // to be a bit confused as to which of these things should be
   // vectors or bivectors here.
   // TODO(egg): Figure that out.
diff --git a/physics/rotating_pulsating_reference_frame.hpp b/physics/rotating_pulsating_reference_frame.hpp
index df91625d40..9800e60000 100644
--- a/physics/rotating_pulsating_reference_frame.hpp
+++ b/physics/rotating_pulsating_reference_frame.hpp
@@ -1,4 +1,4 @@
-// The files containing the tree of child classes of |ReferenceFrame| must be
+// The files containing the tree of child classes of `ReferenceFrame` must be
 // included in the order of inheritance to avoid circular dependencies.  This
 // class will end up being reincluded as part of the implementation of its
 // parent.
diff --git a/physics/similar_motion.hpp b/physics/similar_motion.hpp
index 0eca129f6c..0df5015000 100644
--- a/physics/similar_motion.hpp
+++ b/physics/similar_motion.hpp
@@ -37,9 +37,9 @@ using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 using namespace principia::quantities::_si;
 
-// The instantaneous motion of |ToFrame| with respect to |FromFrame|.  This is
-// the derivative of a |Similarity<FromFrame, ToFrame>|.  In order to invert,
-// the |Similarity| is needed, and we need its linear part anyway, so we store
+// The instantaneous motion of `ToFrame` with respect to `FromFrame`.  This is
+// the derivative of a `Similarity<FromFrame, ToFrame>`.  In order to invert,
+// the `Similarity` is needed, and we need its linear part anyway, so we store
 // it (and we forward its action on positions).
 template<typename FromFrame, typename ToFrame>
 class SimilarMotion final {
@@ -64,12 +64,12 @@ class SimilarMotion final {
       Homothecy<double, FromFrame, ToFrame> const& homothecy,
       Variation<double> dilatation_rate);
 
-  // A similar motion expressing that |FromFrame| and |ToFrame| have the same
+  // A similar motion expressing that `FromFrame` and `ToFrame` have the same
   // axes, origin, and instantaneous motion.
   // This function is enabled only if both frames have the same handedness (this
-  // is a requirement of OrthogonalMap::Identity) and if the |motion| of
-  // FromFrame is a special case of that of |ToFrame| (see the comments on
-  // |FrameMotion|).
+  // is a requirement of OrthogonalMap::Identity) and if the `motion` of
+  // FromFrame is a special case of that of `ToFrame` (see the comments on
+  // `FrameMotion`).
   template<typename F = FromFrame,
            typename T = ToFrame,
            typename = std::enable_if_t<(F::handedness == T::handedness &&
diff --git a/physics/solar_system.hpp b/physics/solar_system.hpp
index 6a52bd47f5..f3d3127fbf 100644
--- a/physics/solar_system.hpp
+++ b/physics/solar_system.hpp
@@ -82,21 +82,21 @@ class SolarSystem final {
   // The names of the bodies, sorted alphabetically.
   std::vector<std::string> const& names() const;
 
-  // The index of the body named |name| in the vector |names()| and in the
+  // The index of the body named `name` in the vector `names()` and in the
   // bodies of the ephemeris.
   int index(std::string const& name) const;
 
-  // The initial state of the body named |name|.
+  // The initial state of the body named `name`.
   DegreesOfFreedom<Frame> degrees_of_freedom(std::string const& name) const;
 
-  // The gravitational parameter of the body named |name|.
+  // The gravitational parameter of the body named `name`.
   GravitationalParameter gravitational_parameter(std::string const& name) const;
 
-  // The mean radius of the body named |name|.
+  // The mean radius of the body named `name`.
   Length mean_radius(std::string const& name) const;
 
-  // The |MassiveBody| for the body named |name|, extracted from the given
-  // |ephemeris|.
+  // The `MassiveBody` for the body named `name`, extracted from the given
+  // `ephemeris`.
   not_null<MassiveBody const*> massive_body(Ephemeris<Frame> const& ephemeris,
                                             std::string const& name) const;
 
@@ -105,13 +105,13 @@ class SolarSystem final {
       Ephemeris<Frame> const& ephemeris,
       std::string const& name) const;
 
-  // The |ContinuousTrajectory| for the body named |name|, extracted from the
-  // given |ephemeris|.
+  // The `ContinuousTrajectory` for the body named `name`, extracted from the
+  // given `ephemeris`.
   ContinuousTrajectory<Frame> const& trajectory(
       Ephemeris<Frame> const& ephemeris,
       std::string const& name) const;
 
-  // The configuration protocol buffers for the body named |name|.
+  // The configuration protocol buffers for the body named `name`.
   serialization::GravityModel::Body const& gravity_model_message(
       std::string const& name) const;
   bool has_cartesian_initial_state_message(std::string const& name) const;
@@ -151,7 +151,7 @@ class SolarSystem final {
                        KeplerianElements<Frame> const& elements);
 
  private:
-  // Fails if the given |body| doesn't have a consistent set of fields.
+  // Fails if the given `body` doesn't have a consistent set of fields.
   static void Check(serialization::GravityModel::Body const& body);
 
   // Factory functions for the parameter classes of the bodies.
diff --git a/physics/trajectory.hpp b/physics/trajectory.hpp
index d8be8f1459..c724bf418b 100644
--- a/physics/trajectory.hpp
+++ b/physics/trajectory.hpp
@@ -26,14 +26,14 @@ class Trajectory {
   virtual Instant t_min() const = 0;
   virtual Instant t_max() const = 0;
 
-  // Evaluates the trajectory at the given |time|, which must be in
+  // Evaluates the trajectory at the given `time`, which must be in
   // [t_min(), t_max()].
   virtual Position<Frame> EvaluatePosition(Instant const& time) const = 0;
   virtual Velocity<Frame> EvaluateVelocity(Instant const& time) const = 0;
   virtual DegreesOfFreedom<Frame> EvaluateDegreesOfFreedom(
       Instant const& time) const = 0;
 
-  // TODO(phl): This should probably declare |value_type| and friends.
+  // TODO(phl): This should probably declare `value_type` and friends.
 };
 
 }  // namespace internal
diff --git a/quantities/concepts.hpp b/quantities/concepts.hpp
index 6b7721fabb..aaa2fd8770 100644
--- a/quantities/concepts.hpp
+++ b/quantities/concepts.hpp
@@ -15,7 +15,7 @@ using namespace base::_traits;
 using namespace quantities::_quantities;
 
 // TODO(egg): additive_group should subsume affine, but we use it there.
-// We use |convertible_to| here because we want this concept to work with
+// We use `convertible_to` here because we want this concept to work with
 // Boost multiprecision types which heavily use implicit conversions.
 template<typename G>
 concept additive_group = requires(G x, G y, int n) {
diff --git a/quantities/dimensions.hpp b/quantities/dimensions.hpp
index c964548967..ada26608ba 100644
--- a/quantities/dimensions.hpp
+++ b/quantities/dimensions.hpp
@@ -26,14 +26,14 @@ using NoDimensions = Dimensions<0, 0, 0, 0, 0, 0, 0, 0>;
 template<typename Dimensions>
 struct DimensionsAreSerializable;
 
-// These structs have a |Type| member that is a |Dimensions| suitable for
-// the result of the operation applied to argument(s) having the |Dimensions|
+// These structs have a `Type` member that is a `Dimensions` suitable for
+// the result of the operation applied to argument(s) having the `Dimensions`
 // given as template parameter(s).
 
 template<typename Dimensions, int n>
 struct DimensionsExponentiationGenerator;
 
-// Only legal if |n| divides the dimensions.
+// Only legal if `n` divides the dimensions.
 template<typename Dimensions, int n>
 struct DimensionsNthRootGenerator;
 
diff --git a/quantities/dimensions_body.hpp b/quantities/dimensions_body.hpp
index b8809ed8e5..63cd2a4a2a 100644
--- a/quantities/dimensions_body.hpp
+++ b/quantities/dimensions_body.hpp
@@ -16,7 +16,7 @@ class ExponentSerializer : not_constructible {
   // Returns true if the exponent is in the range that we can serialize.
   static constexpr bool IsSerializable(std::int64_t exponent);
 
-  // Returns the serialized representation of the exponent.  |position| is the
+  // Returns the serialized representation of the exponent.  `position` is the
   // 0-based position of the dimension in the representation.
   static constexpr std::int64_t Representation(
       std::int64_t exponent,
diff --git a/quantities/elementary_functions.hpp b/quantities/elementary_functions.hpp
index b668f79301..192a23049c 100644
--- a/quantities/elementary_functions.hpp
+++ b/quantities/elementary_functions.hpp
@@ -13,7 +13,7 @@ using namespace boost::multiprecision;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// Equivalent to |std::fma(x, y, z)|.
+// Equivalent to `std::fma(x, y, z)`.
 template<typename Q1, typename Q2>
 Product<Q1, Q2> FusedMultiplyAdd(Q1 const& x,
                                  Q2 const& y,
@@ -31,30 +31,30 @@ Product<Q1, Q2> FusedNegatedMultiplySubtract(Q1 const& x,
                                              Q2 const& y,
                                              Product<Q1, Q2> const& z);
 
-// Equivalent to |std::abs(x)|.
+// Equivalent to `std::abs(x)`.
 template<typename Q>
 Q Abs(Q const& quantity);
 
-// Returns a value between zero and |modulus|.
+// Returns a value between zero and `modulus`.
 template<typename Q>
 Q Mod(Q const& argument, Q const& modulus);
 
-// Equivalent to |std::sqrt(x)|.
+// Equivalent to `std::sqrt(x)`.
 template<typename Q>
 SquareRoot<Q> Sqrt(Q const& x);
 
-// Equivalent to |std::cbrt(x)|.
+// Equivalent to `std::cbrt(x)`.
 template<typename Q>
 CubeRoot<Q> Cbrt(Q const& x);
 
-// Not equivalent to |std::nextafter(x)|; follows IEEE 754:2008 conventions
-// instead of C++ ones.  In particular, |NextUp(-0.0) == NextUp(+0.0)|.
+// Not equivalent to `std::nextafter(x)`; follows IEEE 754:2008 conventions
+// instead of C++ ones.  In particular, `NextUp(-0.0) == NextUp(+0.0)`.
 template<typename Q>
 constexpr Q NextUp(Q const& x);
 template<typename Q>
 constexpr Q NextDown(Q const& x);
 
-// Equivalent to |std::pow(x, exponent)| unless -3 ≤ x ≤ 3, in which case
+// Equivalent to `std::pow(x, exponent)` unless -3 ≤ x ≤ 3, in which case
 // explicit specialization yields multiplications statically.
 template<int exponent, typename Q>
 constexpr Exponentiation<Q, exponent> Pow(Q const& x);
@@ -83,7 +83,7 @@ Angle ArcCosh(double x);
 Angle ArcTanh(double x);
 
 // Returns the element of {α + 2nπ | n ∈ ℤ} which is closest to
-// |previous_angle|.
+// `previous_angle`.
 Angle UnwindFrom(Angle const& previous_angle, Angle const& α);
 
 // Only dimensionless quantities can be rounded.
diff --git a/quantities/elementary_functions_body.hpp b/quantities/elementary_functions_body.hpp
index bf45606530..1c1345e929 100644
--- a/quantities/elementary_functions_body.hpp
+++ b/quantities/elementary_functions_body.hpp
@@ -162,7 +162,7 @@ inline constexpr double Pow<3>(double x) {
 template<int exponent, typename Q>
 constexpr Exponentiation<Q, exponent> Pow(Q const& x) {
   if constexpr (number_category<Q>::value == number_kind_rational) {
-    // It seems that Boost does not define |pow| for |cpp_rational|.
+    // It seems that Boost does not define `pow` for `cpp_rational`.
     return cpp_rational(pow(numerator(x), exponent),
                         pow(denominator(x), exponent));
   } else if constexpr (is_number<Q>::value) {
@@ -206,7 +206,7 @@ template<typename Q>
   requires is_number<Q>::value || std::floating_point<Q>
 Q Round(Q const& x) {
   if constexpr (is_number<Q>::value) {
-    // TODO(phl): This is clunky.  Use |divide_qr| or something.
+    // TODO(phl): This is clunky.  Use `divide_qr` or something.
     return static_cast<Q>(round(static_cast<cpp_bin_float_50>(x)));
   } else {
     return std::round(x);
diff --git a/quantities/elementary_functions_test.cpp b/quantities/elementary_functions_test.cpp
index 1aec37265a..89abf3d6e9 100644
--- a/quantities/elementary_functions_test.cpp
+++ b/quantities/elementary_functions_test.cpp
@@ -71,7 +71,7 @@ TEST_F(ElementaryFunctionsTest, DimensionlessExponentiation) {
   EXPECT_EQ(negativePower, Pow<-3>(number));
   positivePower *= number;
   negativePower /= number;
-  // This one calls |std::pow|.
+  // This one calls `std::pow`.
   EXPECT_THAT(positivePower, AlmostEquals(Pow<4>(number), 0, 1));
   EXPECT_THAT(negativePower, AlmostEquals(Pow<-4>(number), 0, 1));
 }
diff --git a/quantities/generators.hpp b/quantities/generators.hpp
index 8e7110673b..f94530dea9 100644
--- a/quantities/generators.hpp
+++ b/quantities/generators.hpp
@@ -5,14 +5,14 @@ namespace quantities {
 namespace _generators {
 namespace internal {
 
-// These structs have a |Type| member that is a |Quantity| suitable for
-// the result of the operation applied to argument(s) of the |Quantity| types
+// These structs have a `Type` member that is a `Quantity` suitable for
+// the result of the operation applied to argument(s) of the `Quantity` types
 // given as template parameter(s).
 
 template<typename Q, int n>
 struct ExponentiationGenerator;
 
-// Only legal if |n| divides the dimensions of |Q|.
+// Only legal if `n` divides the dimensions of `Q`.
 template<typename Q, int n, typename = void>
 struct NthRootGenerator;
 
diff --git a/quantities/generators_body.hpp b/quantities/generators_body.hpp
index 1b214ee96a..a5c487265d 100644
--- a/quantities/generators_body.hpp
+++ b/quantities/generators_body.hpp
@@ -17,7 +17,7 @@ using namespace boost::multiprecision;
 using namespace principia::base::_not_constructible;
 using namespace principia::quantities::_dimensions;
 
-// The template template parameter |Quantity| on specializations lifts a
+// The template template parameter `Quantity` on specializations lifts a
 // circular dependency.
 
 template<typename Q>
@@ -58,8 +58,8 @@ struct NthRootGenerator<Quantity<D>, n, void> : not_constructible {
       Quantity<typename DimensionsNthRootGenerator<D, n>::Type>>::Type;
 };
 
-// NOTE(phl): We use |is_arithmetic| here, not |double|, to make it possible to
-// write something like |Sqrt(2)|.  We could use |is_arithmetic| in more places
+// NOTE(phl): We use `is_arithmetic` here, not `double`, to make it possible to
+// write something like `Sqrt(2)`.  We could use `is_arithmetic` in more places
 // but it would make the template magic even harder to follow, so let's not do
 // that until we have a good reason.
 template<typename Q, int n>
diff --git a/quantities/named_quantities.hpp b/quantities/named_quantities.hpp
index 45a5d917d3..d5690e4276 100644
--- a/quantities/named_quantities.hpp
+++ b/quantities/named_quantities.hpp
@@ -9,7 +9,7 @@ namespace internal {
 
 using namespace principia::quantities::_quantities;
 
-// The result type of +, -, * and / on arguments of types |Left| and |Right|.
+// The result type of +, -, * and / on arguments of types `Left` and `Right`.
 template<typename Left, typename Right>
 using Sum = decltype(std::declval<Left>() + std::declval<Right>());
 template<typename Left, typename Right = Left>
@@ -37,21 +37,21 @@ using SquareRoot = NthRoot<Q, 2>;
 template<typename Q>
 using CubeRoot = NthRoot<Q, 3>;
 
-// The result type of the N-th derivative of a |Value|-valued function with
-// respect to its |Argument|-valued argument.
+// The result type of the N-th derivative of a `Value`-valued function with
+// respect to its `Argument`-valued argument.
 template<typename Value, typename Argument, int order = 1>
 using Derivative = typename std::conditional_t<
     order == 0,
     Value,
     Quotient<Difference<Value>, Exponentiation<Difference<Argument>, order>>>;
 
-// The result type of the primitive of a |Value|-valued function with respect to
-// its |Argument|-valued argument.  The primitive of an affine-valued function
+// The result type of the primitive of a `Value`-valued function with respect to
+// its `Argument`-valued argument.  The primitive of an affine-valued function
 // does not make much sense, but it must compile, hence the Difference.
 template<typename Value, typename Argument>
 using Primitive = Product<Difference<Value>, Difference<Argument>>;
 
-// |Variation<T>| is the type of the time derivative of a |T|-valued function.
+// `Variation<T>` is the type of the time derivative of a `T`-valued function.
 template<typename T, int order = 1>
 using Variation = Derivative<T, Time, order>;
 
diff --git a/quantities/quantities.hpp b/quantities/quantities.hpp
index c7c7e44951..f8e8fad488 100644
--- a/quantities/quantities.hpp
+++ b/quantities/quantities.hpp
@@ -42,8 +42,8 @@ using LuminousIntensity = Quantity<Dimensions<0, 0, 0, 0, 0, 0, 1, 0>>;
 // We strongly type angles.
 using Angle             = Quantity<Dimensions<0, 0, 0, 0, 0, 0, 0, 1>>;
 
-// |Product| and |Quotient| are not exported from this namespace.  Instead they
-// are defined as the result types of |operator*| and |operator/|.
+// `Product` and `Quotient` are not exported from this namespace.  Instead they
+// are defined as the result types of `operator*` and `operator/`.
 template<typename Left, typename Right>
 using Product = typename ProductGenerator<Left, Right>::Type;
 template<typename Left, typename Right>
@@ -119,7 +119,7 @@ template<typename RDimensions>
 constexpr Quotient<double, Quantity<RDimensions>>
 operator/(double, Quantity<RDimensions> const&);
 
-// Used for implementing |si::Unit|.  Don't call directly, don't export from
+// Used for implementing `si::Unit`.  Don't call directly, don't export from
 // this namespace.  Defined here to break circular dependencies.
 template<typename Q>
 constexpr Q SIUnit() { return Q(1); };
@@ -129,10 +129,10 @@ inline __m128d ToM128D(double x);
 template<typename Dimensions>
 __m128d ToM128D(Quantity<Dimensions> x);
 
-// A positive infinity of |Q|.
+// A positive infinity of `Q`.
 template<typename Q>
 constexpr Q Infinity = SIUnit<Q>() * std::numeric_limits<double>::infinity();
-// A quiet NaN of |Q|.
+// A quiet NaN of `Q`.
 template <typename Q>
 CONSTEXPR_NAN Q NaN = SIUnit<Q>() * std::numeric_limits<double>::quiet_NaN();
 
diff --git a/quantities/serialization.hpp b/quantities/serialization.hpp
index 5ebf47b3d4..b4e62b7c21 100644
--- a/quantities/serialization.hpp
+++ b/quantities/serialization.hpp
@@ -9,7 +9,7 @@ namespace internal {
 
 using namespace principia::base::_not_constructible;
 
-// A helper class that serializes a |Quantity| or a |double| to a protobuf
+// A helper class that serializes a `Quantity` or a `double` to a protobuf
 // structure like:
 //
 // message Message {
diff --git a/quantities/si.hpp b/quantities/si.hpp
index da1a054fad..1a30da68f8 100644
--- a/quantities/si.hpp
+++ b/quantities/si.hpp
@@ -18,8 +18,8 @@ namespace internal {
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
-// Returns the base or derived SI unit of |Q|.
-// For instance, |si::Unit<Action>() == Joule * Second|.
+// Returns the base or derived SI unit of `Q`.
+// For instance, `si::Unit<Action>() == Joule * Second`.
 template<typename Q>
 constexpr Q Unit = _quantities::internal::SIUnit<Q>();
 template<>
diff --git a/quantities/tuples.hpp b/quantities/tuples.hpp
index 66516e1165..ab7bb25628 100644
--- a/quantities/tuples.hpp
+++ b/quantities/tuples.hpp
@@ -23,16 +23,16 @@ struct is_tuple<std::tuple<D...>> : std::true_type, not_constructible {};
 template<typename T>
 constexpr bool is_tuple_v = is_tuple<T>::value;
 
-// This struct has a |Type| member which is a tuple obtained by applying
-// |Transform| to corresponding elements in |Tuples| (which may be tuples,
-// arrays, or pairs).  If the |Tuples| have different sizes, |void| is passed to
-// |Transform| for the missing element types.
+// This struct has a `Type` member which is a tuple obtained by applying
+// `Transform` to corresponding elements in `Tuples` (which may be tuples,
+// arrays, or pairs).  If the `Tuples` have different sizes, `void` is passed to
+// `Transform` for the missing element types.
 template<template<typename...> typename Transform, typename... Tuples>
 class ApplyGenerator;
 
-// This struct has a |Type| member which is an n-element tuple of successive
-// derivatives of |Value| with respect to |Argument|; the first element is
-// |Value|.
+// This struct has a `Type` member which is an n-element tuple of successive
+// derivatives of `Value` with respect to `Argument`; the first element is
+// `Value`.
 template<typename Value, typename Argument, int n,
          typename = std::make_index_sequence<n>>
 struct DerivativesGenerator;
diff --git a/serialization/geometry.proto b/serialization/geometry.proto
index 2cd05ff3e6..cba4889c37 100644
--- a/serialization/geometry.proto
+++ b/serialization/geometry.proto
@@ -120,7 +120,7 @@ message Permutation {
   }
 
   // These enums are used in the definition of the field
-  // |coordinate_permutation|.
+  // `coordinate_permutation`.
 
   // Three two-bit fields which indicate how each coordinate get mapped by the
   // permutation.
@@ -129,7 +129,7 @@ message Permutation {
     Y = 1;
     Z = 2;
   }
-  // A three bit field used when using |coordinate_permutation| to index arrays.
+  // A three bit field used when using `coordinate_permutation` to index arrays.
   enum Index {
     INDEX = 6;
   }
@@ -161,7 +161,7 @@ message Signature {
 }
 
 // Frames follow.  Note that the names of the enum types are part of the
-// serialized representation (|tag_type_fingerprint| field).
+// serialized representation (`tag_type_fingerprint` field).
 
 message Frame {
   // The frame tags used in the plugin.
diff --git a/serialization/journal.proto b/serialization/journal.proto
index c900eff2f1..23527cb612 100644
--- a/serialization/journal.proto
+++ b/serialization/journal.proto
@@ -759,9 +759,9 @@ message ExternalFlowFreefall {
   optional Return return = 3;
 }
 
-// Sets |coefficient| to the normalized geopotential coefficient of the given
-// |degree| and |order| of the body with index |body_index|.
-// |coefficient.x| is set to Cnm, |coefficient.y| is set to Snm.
+// Sets `coefficient` to the normalized geopotential coefficient of the given
+// `degree` and `order` of the body with index `body_index`.
+// `coefficient.x` is set to Cnm, `coefficient.y` is set to Snm.
 message ExternalGeopotentialGetCoefficient {
   extend Method {
     optional ExternalGeopotentialGetCoefficient extension = 5156;
@@ -785,8 +785,8 @@ message ExternalGeopotentialGetCoefficient {
   optional Return return = 3;
 }
 
-// Sets |reference_radius| to the value in metres of the reference radius of
-// the geopotential model for the body with index |body_index|.
+// Sets `reference_radius` to the value in metres of the reference radius of
+// the geopotential model for the body with index `body_index`.
 // If the body does not have a geopotential model, i.e., if it is modeled as an
 // isotropic sphere, the mean radius is used.
 message ExternalGeopotentialGetReferenceRadius {
diff --git a/serialization/physics.proto b/serialization/physics.proto
index 644cfbc274..e79e6e3862 100644
--- a/serialization/physics.proto
+++ b/serialization/physics.proto
@@ -260,8 +260,8 @@ message OblateBody {
         }
         required double sin = 3;
       }
-      // For a given |degree|, the |column| array must contain at most
-      // |degree + 1| entries.
+      // For a given `degree`, the `column` array must contain at most
+      // `degree + 1` entries.
       required int32 degree = 1;
       // For stability, the serialization produces columns by increasing order.
       repeated GeopotentialColumn column = 2;
diff --git a/sourcerer/analyser.cs b/sourcerer/analyser.cs
index e315a337d3..d66835fa00 100644
--- a/sourcerer/analyser.cs
+++ b/sourcerer/analyser.cs
@@ -7,7 +7,7 @@ namespace sourcerer {
 // A class for extracting information from a syntactic tree.  Does not change
 // the tree.
 public class Analyser {
-  // Returns the list of exported (public) declarations in |node| and its
+  // Returns the list of exported (public) declarations in `node` and its
   // descendants.  Note that internal namespace do *not* export their
   // declarations.
   public static List<Declaration> CollectExportedDeclarations(Node node) {
@@ -25,7 +25,7 @@ public static List<Declaration> CollectExportedDeclarations(Node node) {
   }
 
 
-  // Given a |using_declaration| and map from (exported) declarations to the
+  // Given a `using_declaration` and map from (exported) declarations to the
   // file where they are declared, returns the file where the name referenced by
   // the using declaration is declared.
   public static File? FindFileReferencedByUsingDeclaration(
@@ -46,7 +46,7 @@ declaration.parent is Namespace ns &&
     return null;
   }
 
-  // Returns the list of top-level includes in |file|.
+  // Returns the list of top-level includes in `file`.
   public static List<Include> FindIncludes(File file) {
     var includes = new List<Include>();
     bool after_cpp_if = false;
@@ -66,7 +66,7 @@ public static List<Include> FindIncludes(File file) {
     return includes;
   }
 
-  // Returns the list of innermost namespaces found in |node| and its
+  // Returns the list of innermost namespaces found in `node` and its
   // descendants.
   public static List<Namespace> FindInnermostNamespaces(Node node) {
     var innermost_namespaces = new List<Namespace>();
@@ -83,7 +83,7 @@ public static List<Namespace> FindInnermostNamespaces(Node node) {
     return innermost_namespaces;
   }
 
-  // Returns the last outermost namespace found in |file|.
+  // Returns the last outermost namespace found in `file`.
   // TODO(phl): This should probably be changed to return all the outermost
   // namespaces.
   public static Namespace? FindLastOutermostNamespace(File file) {
@@ -96,7 +96,7 @@ public static List<Namespace> FindInnermostNamespaces(Node node) {
     return last_outermost_namespace;
   }
 
-  // Returns the legacy internal namespaces found in |node| and it descendants.
+  // Returns the legacy internal namespaces found in `node` and it descendants.
   // A legacy internal namespace is one whose name starts with "internal_".
 
   public static List<Namespace> FindLegacyInternalNamespaces(Node node) {
@@ -113,8 +113,8 @@ public static List<Namespace> FindLegacyInternalNamespaces(Node node) {
     return legacy_internal_namespaces;
   }
 
-  // Returns the using declarations found in |node| and its descendants.  If
-  // |internal_only| is true, internal namespaces are ignored (that is, only the
+  // Returns the using declarations found in `node` and its descendants.  If
+  // `internal_only` is true, internal namespaces are ignored (that is, only the
   // exported using declarations are returned).
   public static List<UsingDeclaration> FindUsingDeclarations(
       Node node,
@@ -136,8 +136,8 @@ public static List<UsingDeclaration> FindUsingDeclarations(
     return internal_using_declarations;
   }
 
-  // Returns the using directives found in |node| and its descendants.  If
-  // |internal_only| is true, internal namespaces are ignored (that is, only the
+  // Returns the using directives found in `node` and its descendants.  If
+  // `internal_only` is true, internal namespaces are ignored (that is, only the
   // exported using directives are returned).
   public static List<UsingDirective> FindUsingDirectives(
       Node node,
diff --git a/sourcerer/include_what_you_using.cs b/sourcerer/include_what_you_using.cs
index 6e579e5a22..27aab28820 100644
--- a/sourcerer/include_what_you_using.cs
+++ b/sourcerer/include_what_you_using.cs
@@ -291,12 +291,12 @@ private static void FixIncludes(Parser.File file,
       return;
     }
 
-    // Replace the includes in |consecutive_includes| with |new_includes|.
+    // Replace the includes in `consecutive_includes` with `new_includes`.
     int first_include_position;
     int last_include_position;
     if (consecutive_user_includes.Count == 0) {
       // There is no existing block of consecutive includes, so we have to do
-      // fancy footwork to decide where to hook |new_includes|.
+      // fancy footwork to decide where to hook `new_includes`.
       var start_includes =
           (from inc in all_includes where !inc.is_own_body select inc).
           ToArray();
diff --git a/sourcerer/parser.cs b/sourcerer/parser.cs
index 552ebb0da1..61409784b2 100644
--- a/sourcerer/parser.cs
+++ b/sourcerer/parser.cs
@@ -220,7 +220,7 @@ public override void WriteNode(string indent = "") {
   }
 
   public class Include : Node {
-    // The |file_info| is the file where this include appears, not the one that
+    // The `file_info` is the file where this include appears, not the one that
     // is included.
     public Include(Node? parent,
                    string[] path,
diff --git a/sourcerer/renamespacer.cs b/sourcerer/renamespacer.cs
index 1cc4a8da78..52a23d0ac3 100644
--- a/sourcerer/renamespacer.cs
+++ b/sourcerer/renamespacer.cs
@@ -141,9 +141,9 @@ public static void Run(string[] args) {
     }
   }
 
-  // Insert a using directive for |file_namespace| at the correct place in
-  // |using_directives|, but only if it's not there already.  If
-  // |using_directives| is empty, the insertion takes place after |after|.
+  // Insert a using directive for `file_namespace` at the correct place in
+  // `using_directives`, but only if it's not there already.  If
+  // `using_directives` is empty, the insertion takes place after `after`.
   // Return true iff a directive was added.
   private static bool InsertUsingDirectiveIfNeeded(
       string file_namespace,
@@ -170,7 +170,7 @@ private static bool InsertUsingDirectiveIfNeeded(
       return false;
     }
 
-    // Insert the using directive.  Note that we must update |using_directives|.
+    // Insert the using directive.  Note that we must update `using_directives`.
     var parent = file_namespace_insertion_point.parent;
     Debug.Assert(parent is Namespace, "Insertion point not within a namespace");
     int insertion_point_position_in_parent =
diff --git a/testing_utilities/almost_equals.hpp b/testing_utilities/almost_equals.hpp
index 9735826082..361765e355 100644
--- a/testing_utilities/almost_equals.hpp
+++ b/testing_utilities/almost_equals.hpp
@@ -39,14 +39,14 @@ using namespace principia::quantities::_quantities;
 template<typename T>
 class AlmostEqualsMatcher;
 
-// The 2-argument version of |AlmostEquals()| should always be preferred as it
+// The 2-argument version of `AlmostEquals()` should always be preferred as it
 // guarantees that the error bound is tight.
 template<typename T>
 testing::PolymorphicMatcher<AlmostEqualsMatcher<T>> AlmostEquals(
     T const& expected,
     std::int64_t max_ulps);
 
-// The 3-argument version of |AlmostEquals()| is exclusively for use when a
+// The 3-argument version of `AlmostEquals()` is exclusively for use when a
 // given assertion may have different errors, e.g., because it's in a loop.  It
 // doesn't guarantee that the error bound is tight.  For vectors, it applies
 // only to the component with the largest error.
diff --git a/testing_utilities/approximate_quantity.hpp b/testing_utilities/approximate_quantity.hpp
index 8c03855473..320dc0e6f4 100644
--- a/testing_utilities/approximate_quantity.hpp
+++ b/testing_utilities/approximate_quantity.hpp
@@ -131,7 +131,7 @@ template<typename Quantity>
 std::ostream& operator<<(std::ostream& out,
                          ApproximateQuantity<Quantity> const& q);
 
-// The internal struct |NumericLiteral| and the operator""_ are to be used in
+// The internal struct `NumericLiteral` and the operator""_ are to be used in
 // concert to allow the syntax 1.234_(1), or, in principle, 1.234_(123) for
 // approximate quantities.
 struct NumericLiteral {
diff --git a/testing_utilities/discrete_trajectory_factories.hpp b/testing_utilities/discrete_trajectory_factories.hpp
index 962851832d..231eb8c4ab 100644
--- a/testing_utilities/discrete_trajectory_factories.hpp
+++ b/testing_utilities/discrete_trajectory_factories.hpp
@@ -49,8 +49,8 @@ NewMotionlessTrajectoryTimeline(Position<Frame> const& position,
                                 Instant const& t2);
 
 // A linear trajectory with constant velocity, going through
-// |degrees_of_freedom.position()| at t = t0.  The first point is at time |t1|,
-// the last point at a time < |t2|.
+// `degrees_of_freedom.position()` at t = t0.  The first point is at time `t1`,
+// the last point at a time < `t2`.
 template<typename Frame>
 Timeline<Frame>
 NewLinearTrajectoryTimeline(DegreesOfFreedom<Frame> const& degrees_of_freedom,
@@ -58,7 +58,7 @@ NewLinearTrajectoryTimeline(DegreesOfFreedom<Frame> const& degrees_of_freedom,
                             Instant const& t0,
                             Instant const& t1,
                             Instant const& t2);
-// Same as above, going through |degrees_of_freedom.position()| at t = t1.
+// Same as above, going through `degrees_of_freedom.position()` at t = t1.
 template<typename Frame>
 Timeline<Frame>
 NewLinearTrajectoryTimeline(DegreesOfFreedom<Frame> const& degrees_of_freedom,
@@ -74,8 +74,8 @@ NewLinearTrajectoryTimeline(Velocity<Frame> const& v,
                             Instant const& t2);
 
 // A trajectory with a uniform acceleration, having the specified
-// |degrees_of_freedom| at t = 0.  The first point is at time |t1|, the last
-// point at a time < |t2|.
+// `degrees_of_freedom` at t = 0.  The first point is at time `t1`, the last
+// point at a time < `t2`.
 template<typename Frame>
 Timeline<Frame> NewAcceleratedTrajectoryTimeline(
     DegreesOfFreedom<Frame> const& degrees_of_freedom,
@@ -85,7 +85,7 @@ Timeline<Frame> NewAcceleratedTrajectoryTimeline(
     Instant const& t2);
 
 // A circular trajectory in the plane XY, centred at the origin.  The first
-// point is at time |t1|, the last point at a time < |t2|.
+// point is at time `t1`, the last point at a time < `t2`.
 template<typename Frame>
 Timeline<Frame>
 NewCircularTrajectoryTimeline(AngularFrequency const& ω,
diff --git a/testing_utilities/numerics.hpp b/testing_utilities/numerics.hpp
index dd7eb93024..17715f2426 100644
--- a/testing_utilities/numerics.hpp
+++ b/testing_utilities/numerics.hpp
@@ -36,7 +36,7 @@ template<typename Dimensions>
 Quantity<Dimensions> AbsoluteError(Quantity<Dimensions> const& expected,
                                    Quantity<Dimensions> const& actual);
 
-// Uses |R3Element::Norm|.
+// Uses `R3Element::Norm`.
 template<typename Scalar>
 Scalar AbsoluteError(R3Element<Scalar> const& expected,
                      R3Element<Scalar> const& actual);
@@ -74,7 +74,7 @@ template<typename Dimensions>
 double RelativeError(Quantity<Dimensions> const& expected,
                      Quantity<Dimensions> const& actual);
 
-// Uses |R3Element::Norm|.
+// Uses `R3Element::Norm`.
 template<typename Scalar>
 double RelativeError(R3Element<Scalar> const& expected,
                      R3Element<Scalar> const& actual);
diff --git a/testing_utilities/numerics_test.cpp b/testing_utilities/numerics_test.cpp
index b2398cbde8..c8123528fc 100644
--- a/testing_utilities/numerics_test.cpp
+++ b/testing_utilities/numerics_test.cpp
@@ -52,7 +52,7 @@ TEST_F(NumericsTest, ULPs) {
   EXPECT_THAT(ULPDistance(1, 1), Eq(0));
   EXPECT_THAT(ULPDistance(+0.0, +0.0), Eq(0));
   EXPECT_THAT(ULPDistance(+0.0, -0.0), Eq(0));
-  // |std::numeric_limits<double>::min()| is the smallest positive normalized
+  // `std::numeric_limits<double>::min()` is the smallest positive normalized
   // number.  52 bits of mantissa stand between it and 0, in the form of
   // denormals.
   EXPECT_THAT(ULPDistance(+0.0, std::numeric_limits<double>::min()),
diff --git a/testing_utilities/optimization_test_functions.cpp b/testing_utilities/optimization_test_functions.cpp
index 971cff7d9d..7cabd032a0 100644
--- a/testing_utilities/optimization_test_functions.cpp
+++ b/testing_utilities/optimization_test_functions.cpp
@@ -33,7 +33,7 @@ constexpr FixedMatrix<double, /*rows=*/4, /*columns=*/3> A({3.0, 10, 30,
                                                             3.0, 10, 30,
                                                             0.1, 10, 35});
 
-// There is a lot of confusion regarding the value of |P|, and unfortunately I
+// There is a lot of confusion regarding the value of `P`, and unfortunately I
 // couldn't go back to the source, which is widely known as "the traditional ...
 // test set ... from Dixon and Szegő".
 // For A(0, 0) the two values 3689e-4 and 6890e-4 are customarily found.  For
diff --git a/testing_utilities/solar_system_factory.hpp b/testing_utilities/solar_system_factory.hpp
index 29ee95f2ba..f52f3fc4af 100644
--- a/testing_utilities/solar_system_factory.hpp
+++ b/testing_utilities/solar_system_factory.hpp
@@ -100,10 +100,10 @@ class SolarSystemFactory : not_constructible {
   static not_null<std::unique_ptr<SolarSystem<ICRS>>>
   AtСпутник2Launch(Accuracy accuracy);
 
-  // Returns the index of the parent of the body with the given |index|.
+  // Returns the index of the parent of the body with the given `index`.
   // Because enums are broken in C++ we use ints.  Sigh.
   static int parent(int index);
-  // The name of the body with the given |index|.
+  // The name of the body with the given `index`.
   static std::string name(int index);
 };
 
diff --git a/testing_utilities/solar_system_factory_test.cpp b/testing_utilities/solar_system_factory_test.cpp
index e4a78eff7c..9a1268aea3 100644
--- a/testing_utilities/solar_system_factory_test.cpp
+++ b/testing_utilities/solar_system_factory_test.cpp
@@ -63,10 +63,10 @@ class SolarSystemFactoryTest : public testing::Test {
     return a * std::pow(secondary_body.mass() / primary_body.mass(), 2.0 / 5.0);
   }
 
-  // Tests whether |tertiary| orbits |secondary| in an orbit with excentricity
-  // |excentricity| within |relative_error| and, if |primary| is not null, tests
-  // that |tertiary| is within the Laplace sphere of |secondary| with respect
-  // to |*primary|. If |relative_error| is greater than 1e-6, it should be tight
+  // Tests whether `tertiary` orbits `secondary` in an orbit with excentricity
+  // `excentricity` within `relative_error` and, if `primary` is not null, tests
+  // that `tertiary` is within the Laplace sphere of `secondary` with respect
+  // to `*primary`. If `relative_error` is greater than 1e-6, it should be tight
   // within an order of magnitude.
   void TestStronglyBoundOrbit(
       double eccentricity,
diff --git a/testing_utilities/statistics.hpp b/testing_utilities/statistics.hpp
index 9d3b56fb3c..8832f791c2 100644
--- a/testing_utilities/statistics.hpp
+++ b/testing_utilities/statistics.hpp
@@ -5,8 +5,8 @@
 
 #include "quantities/named_quantities.hpp"
 
-// Various statistics on finite populations stored as |std::vector|s of
-// |Quantity| or |Dimensionless|.
+// Various statistics on finite populations stored as `std::vector`s of
+// `Quantity` or `Dimensionless`.
 
 namespace principia {
 namespace testing_utilities {
@@ -20,7 +20,7 @@ template<typename T>
 T Mean(std::vector<T> const& x);
 
 // The population variance σ(x)² = Var[x] = E[x² - E[x]²].
-// Computed as |Covariance(x, x)|.
+// Computed as `Covariance(x, x)`.
 template<typename T>
 Product<T, T> Variance(std::vector<T> const& x);
 
@@ -34,20 +34,20 @@ T StandardDeviation(std::vector<T> const& x);
 
 // The Pearson product-moment correlation coefficient
 // ρ(x, y) = Cov[x, y] / (σ(x) σ(y)).
-// |x| and |y| should have the same size.
+// `x` and `y` should have the same size.
 template<typename T, typename U>
 double PearsonProductMomentCorrelationCoefficient(std::vector<T> const& x,
                                                   std::vector<U> const& y);
 
 // The slope of the least-squares linear regression to the dataset
-// with abscissae |x| and ordinates |y|. |x| and |y| should have the same size.
+// with abscissae `x` and ordinates `y`. `x` and `y` should have the same size.
 template<typename T, typename U>
 Quotient<U, T> Slope(std::vector<T> const& x, std::vector<U> const& y);
 
 // Mathematica input for a bidimensional dataset, copyable from the command line
 // (includes a call to StringReplace to remove stray newlines). The resulting
-// expression is a |List| of pairs {xᵢ, yᵢ}, which can be given as an argument
-// to |ListPlot|. |x| and |y| should have the same size.
+// expression is a `List` of pairs {xᵢ, yᵢ}, which can be given as an argument
+// to `ListPlot`. `x` and `y` should have the same size.
 // The result contains one pair per line and is delimited by Mathematica
 // comments so as to make the command line output more legible. It is not
 // terminated by a newline.
diff --git a/testing_utilities/statistics_body.hpp b/testing_utilities/statistics_body.hpp
index 4bcf372f96..4860c8f69c 100644
--- a/testing_utilities/statistics_body.hpp
+++ b/testing_utilities/statistics_body.hpp
@@ -64,7 +64,7 @@ std::string BidimensionalDatasetMathematicaInput(std::vector<T> const& x,
   result += "ToExpression[StringReplace[\"\n{";
   for (std::size_t i = 0; i < x.size(); ++i) {
     result += "{";
-    // We use |DebugString(double const)| in order to get enough digits.
+    // We use `DebugString(double const)` in order to get enough digits.
     result += DebugString(DoubleValue(x[i]));
     result += ",";
     result += DebugString(DoubleValue(y[i]));
diff --git a/testing_utilities/vanishes_before.hpp b/testing_utilities/vanishes_before.hpp
index 5b8fc85514..e1163f075b 100644
--- a/testing_utilities/vanishes_before.hpp
+++ b/testing_utilities/vanishes_before.hpp
@@ -23,17 +23,17 @@ class VanishesBeforeMatcher;
 // computed value is exactly zero.  The matchers take a reference value, which
 // represents the order of magnitude of the intermediate results that triggered
 // the cancellation, and a tolerance expressed as a number of ulps in the
-// error.  More precisely the matcher checks that the |reference| is equal to
-// to |actual + reference| to within the specified number of ulps.
+// error.  More precisely the matcher checks that the `reference` is equal to
+// to `actual + reference` to within the specified number of ulps.
 
-// The 2-argument version of |VanishesBefore()| should always be preferred as it
+// The 2-argument version of `VanishesBefore()` should always be preferred as it
 // guarantees that the error bound is tight.
 template<typename T>
 testing::PolymorphicMatcher<VanishesBeforeMatcher<T>> VanishesBefore(
     T const& reference,
     std::int64_t max_ulps);
 
-// The 3-argument version of |VanishesBefore()| is exclusively for use when a
+// The 3-argument version of `VanishesBefore()` is exclusively for use when a
 // given assertion may have different errors, e.g., because it's in a loop.  It
 // doesn't guarantee that the error bound is tight.
 template<typename T>
diff --git a/tools/journal_proto_processor.cpp b/tools/journal_proto_processor.cpp
index faf2786a81..35ef65645b 100644
--- a/tools/journal_proto_processor.cpp
+++ b/tools/journal_proto_processor.cpp
@@ -63,7 +63,7 @@ std::string ToLower(std::string const& s) {
 }  // namespace
 
 void JournalProtoProcessor::ProcessMessages() {
-  // Get the file containing |Method|.
+  // Get the file containing `Method`.
   Descriptor const* method_descriptor =
       journal::serialization::Method::descriptor();
   FileDescriptor const* file_descriptor = method_descriptor->file();
@@ -73,7 +73,7 @@ void JournalProtoProcessor::ProcessMessages() {
     Descriptor const* message_descriptor = file_descriptor->message_type(i);
     std::string message_descriptor_name = message_descriptor->name();
     if (message_descriptor->extension_range_count() > 0) {
-      // Only the |Method| message should have a range.  Don't generate any code
+      // Only the `Method` message should have a range.  Don't generate any code
       // for it.
       CHECK_EQ(method_message_name, message_descriptor_name)
           << message_descriptor_name << " should not have extension ranges";
@@ -87,7 +87,7 @@ void JournalProtoProcessor::ProcessMessages() {
         break;
       }
       case 1: {
-        // An extension.  Check that it extends |Method|.
+        // An extension.  Check that it extends `Method`.
         FieldDescriptor const* extension = message_descriptor->extension(0);
         CHECK(extension->is_extension());
         Descriptor const* containing_type = extension->containing_type();
@@ -444,8 +444,8 @@ void JournalProtoProcessor::ProcessOptionalNonStringField(
         };
   }
 
-  // It is not possible to use a custom marshaler on an |T?|, as this raises
-  // |System.Runtime.InteropServices.MarshalDirectiveException| with the message
+  // It is not possible to use a custom marshaler on an `T?`, as this raises
+  // `System.Runtime.InteropServices.MarshalDirectiveException` with the message
   // "Custom marshalers are only allowed on classes, strings, arrays, and boxed
   // value types.".
   if (Contains(interchange_, descriptor)) {
@@ -460,11 +460,11 @@ void JournalProtoProcessor::ProcessOptionalNonStringField(
       field_cs_custom_marshaler_[descriptor] =
           custom_marshaler_generic_name(cs_unboxed_type);
     }
-    // For fields of interchange messages we can use a |T?| as the field is not
+    // For fields of interchange messages we can use a `T?` as the field is not
     // the part being marshaled, it is the entire interchange message.
     field_cs_type_[descriptor] = cs_unboxed_type + "?";
   } else {
-    // We could use a boxed |T|, whose type would be |object|, but we would lose
+    // We could use a boxed `T`, whose type would be `object`, but we would lose
     // static typing.  We use a custom strongly-typed boxed type instead.
     field_cs_custom_marshaler_[descriptor] =
         custom_marshaler_generic_name(cs_unboxed_type);
@@ -735,7 +735,7 @@ void JournalProtoProcessor::ProcessRequiredFixed64Field(
         "std::vector<" +
         options.GetExtension(journal::serialization::pointer_to) + ">";
     std::string const size_field_name = field_cxx_size_[descriptor]->name();
-    // Note that in this lambda |expr| is the size field, not the address field:
+    // Note that in this lambda `expr` is the size field, not the address field:
     // the latter was allocated in C# and never inserted in our pointer map, so
     // it's mostly useless.
     field_cxx_deserializer_fn_[descriptor] =
diff --git a/tools/journal_proto_processor.hpp b/tools/journal_proto_processor.hpp
index 0bdcb05344..745ea80e5a 100644
--- a/tools/journal_proto_processor.hpp
+++ b/tools/journal_proto_processor.hpp
@@ -108,8 +108,8 @@ class JournalProtoProcessor final {
   // structure.
   // We use cxx to designate C++ code and cs to designate C# code.
 
-  // The fields that are in.  Note that the out fields present in |in_out_| are
-  // not in |in_|.
+  // The fields that are in.  Note that the out fields present in `in_out_` are
+  // not in `in_`.
   std::set<FieldDescriptor const*> in_;
 
   // The fields that are in-out, i.e. for which fields of the same name exist in
@@ -120,7 +120,7 @@ class JournalProtoProcessor final {
 
   // The fields that are out.  Those fields are transmitted through the
   // interface with an extra level of indirection.  Note that the in fields
-  // present in |in_out_| are not in |out_|.
+  // present in `in_out_` are not in `out_`.
   std::set<FieldDescriptor const*> out_;
 
   // The fields that are returned.
@@ -151,12 +151,12 @@ class JournalProtoProcessor final {
                              std::string const& identifier)>>
       field_cxx_arguments_fn_;
 
-  // For all fields, a lambda that takes a serialized expression |expr| and a
-  // protocol buffer denoted by |prefix| and returns a statement to assign
-  // |expr| to the proper field of |prefix|.  |prefix| must be suitable as a
+  // For all fields, a lambda that takes a serialized expression `expr` and a
+  // protocol buffer denoted by `prefix` and returns a statement to assign
+  // `expr` to the proper field of `prefix`.  `prefix` must be suitable as a
   // prefix of a call, i.e., it must be a pointer followed by "->" or a
-  // reference followed by ".".  The lambda calls |field_cxx_serializer_fn_| to
-  // serialize expressions as necessary; thus, |expr| must *not* be serialized.
+  // reference followed by ".".  The lambda calls `field_cxx_serializer_fn_` to
+  // serialize expressions as necessary; thus, `expr` must *not* be serialized.
   std::map<FieldDescriptor const*,
            std::function<std::string(std::string const& prefix,
                                      std::string const& expr)>>
@@ -164,16 +164,16 @@ class JournalProtoProcessor final {
 
   // For fields that have an (is_consumed) or (is_consumed_if) option, a lambda
   // producing a statement to call Delete() to remove the appropriate entry from
-  // the pointer_map.  |expr| is a uint64 expression for the entry to be
-  // removed (typically something like |message.in().bar()|).  No data for other
+  // the pointer_map.  `expr` is a uint64 expression for the entry to be
+  // removed (typically something like `message.in().bar()`).  No data for other
   // fields.
   std::map<FieldDescriptor const*,
            std::function<std::string(std::string const& expr)>>
       field_cxx_deleter_fn_;
 
   // For all fields, a lambda that takes an expression for reading a protobuf
-  // field (typically something like |message.in().bar()|) and returns an
-  // expression for the deserialized form of |expr| suitable for storing in a
+  // field (typically something like `message.in().bar()`) and returns an
+  // expression for the deserialized form of `expr` suitable for storing in a
   // local variable (typically a call to some Deserialize function, but other
   // transformations are possible).  Deals with arrays of pointers for repeated
   // fields.
@@ -192,8 +192,8 @@ class JournalProtoProcessor final {
 
   // For fields that have an (is_produced) or (is_produced_if) option, a lambda
   // producing a statement to call Insert() to enter the appropriate entry into
-  // the pointer_map.  |expr1| is an uint64 expression for the serialized value
-  // of the pointer (typically something like |message.in().bar()|), |expr2| is
+  // the pointer_map.  `expr1` is an uint64 expression for the serialized value
+  // of the pointer (typically something like `message.in().bar()`), `expr2` is
   // a pointer expression for the current value of the pointer (typically the
   // name of a local variable).  No data for other fields.
   std::map<FieldDescriptor const*,
@@ -202,28 +202,28 @@ class JournalProtoProcessor final {
       field_cxx_inserter_fn_;
 
   // For all fields, a lambda that takes a C# parameter type as stored in
-  // |field_cs_type_|, and adds a mode to it.
+  // `field_cs_type_`, and adds a mode to it.
   std::map<FieldDescriptor const*,
            std::function<std::string(std::string const& type)>>
       field_cs_mode_fn_;
   // For all fields, a lambda that takes a C++ parameter or member type as
-  // stored in |field_cxx_type_|, and adds a mode to it.
+  // stored in `field_cxx_type_`, and adds a mode to it.
   std::map<FieldDescriptor const*,
            std::function<std::string(std::string const& type)>>
       field_cxx_mode_fn_;
 
   // For all fields, a lambda that takes a pointer expression and a statement
-  // generated by |field_cxx_assignment_fn_|.  If the field is optional, returns
-  // an if statement that only executes |stmt| if |expr| in nonnull.
+  // generated by `field_cxx_assignment_fn_`.  If the field is optional, returns
+  // an if statement that only executes `stmt` if `expr` in nonnull.
   std::map<FieldDescriptor const*,
            std::function<std::string(std::string const& expr,
                                      std::string const& stmt)>>
       field_cxx_optional_assignment_fn_;
 
   // For all fields, a lambda that takes a condition to check for the presence
-  // of an optional field (typically something like |message.in().has_bar()|)
+  // of an optional field (typically something like `message.in().has_bar()`)
   // and a deserialized expression for reading the field (typically the result
-  // of |field_cxx_deserializer_fn_|) and returns a conditional expression for
+  // of `field_cxx_deserializer_fn_`) and returns a conditional expression for
   // either a pointer to the deserialized value or nullptr.
   std::map<FieldDescriptor const*,
            std::function<std::string(std::string const& condition,