diff --git a/bindings/python/src/geometry/basic_objects.cpp b/bindings/python/src/geometry/basic_objects.cpp
index a0960c452..ccb0bac76 100644
--- a/bindings/python/src/geometry/basic_objects.cpp
+++ b/bindings/python/src/geometry/basic_objects.cpp
@@ -42,8 +42,6 @@
         .def( pybind11::init< const Point< dimension >&,                       \
             const Point< dimension >& >() )                                    \
         .def( "direction", &Segment##dimension##D::direction )                 \
-        .def( "normalized_direction",                                          \
-            &Segment##dimension##D::normalized_direction )                     \
         .def( "barycenter", &Segment##dimension##D::barycenter )               \
         .def( "length", &Segment##dimension##D::length )                       \
         .def( "vertices", &Segment##dimension##D::vertices )                   \
diff --git a/include/geode/geometry/basic_objects/segment.hpp b/include/geode/geometry/basic_objects/segment.hpp
index e1d4b95df..920ff381a 100644
--- a/include/geode/geometry/basic_objects/segment.hpp
+++ b/include/geode/geometry/basic_objects/segment.hpp
@@ -56,7 +56,6 @@ namespace geode
             GenericSegment< PointType, dimension >&& other ) noexcept;
 
         [[nodiscard]] Vector< dimension > direction() const;
-        [[nodiscard]] Vector< dimension > normalized_direction() const;
         [[nodiscard]] Point< dimension > barycenter() const;
         [[nodiscard]] double length() const;
         void set_point( local_index_t vertex, PointType point );
diff --git a/src/geode/geometry/barycentric_coordinates.cpp b/src/geode/geometry/barycentric_coordinates.cpp
index d780dee21..454cea7b8 100644
--- a/src/geode/geometry/barycentric_coordinates.cpp
+++ b/src/geode/geometry/barycentric_coordinates.cpp
@@ -172,12 +172,11 @@ namespace geode
         const Point< dimension >& point, const Segment< dimension >& segment )
     {
         const auto dir = segment.direction();
-        const auto length = dir.length();
         const auto& vertices = segment.vertices();
         const Vector< dimension > v0p{ vertices[0], point };
-        const auto dot0 = v0p.dot( dir ) / length;
+        const auto dot0 = v0p.dot( dir );
         const Vector< dimension > v1p{ vertices[1], point };
-        const auto dot1 = -v1p.dot( dir ) / length;
+        const auto dot1 = -v1p.dot( dir );
         const auto sum = dot0 + dot1;
         OpenGeodeGeometryException::check_exception( sum != 0, point,
             OpenGeodeException::TYPE::data,
diff --git a/src/geode/geometry/basic_objects/infinite_line.cpp b/src/geode/geometry/basic_objects/infinite_line.cpp
index 4dacd4a1a..fdbd04b24 100644
--- a/src/geode/geometry/basic_objects/infinite_line.cpp
+++ b/src/geode/geometry/basic_objects/infinite_line.cpp
@@ -38,7 +38,7 @@ namespace geode
     template < typename PointType, index_t dimension >
     GenericLine< PointType, dimension >::GenericLine(
         const Segment< dimension >& segment )
-        : GenericLine( segment.normalized_direction(), segment.vertices()[0] )
+        : GenericLine( segment.direction(), segment.vertices()[0] )
     {
     }
     template < typename PointType, index_t dimension >
diff --git a/src/geode/geometry/basic_objects/segment.cpp b/src/geode/geometry/basic_objects/segment.cpp
index 6a8b1cad4..8520c98ac 100644
--- a/src/geode/geometry/basic_objects/segment.cpp
+++ b/src/geode/geometry/basic_objects/segment.cpp
@@ -60,14 +60,9 @@ namespace geode
             OpenGeodeException::TYPE::data,
             "[Segment::direction] Segment length too small (",
             direction.length(), ")" );
-        return direction;
-    }
-    template < typename PointType, index_t dimension >
-    Vector< dimension >
-        GenericSegment< PointType, dimension >::normalized_direction() const
-    {
-        return direction().normalize();
+        return direction.normalize();
     }
+
     template < typename PointType, index_t dimension >
     Point< dimension >
         GenericSegment< PointType, dimension >::barycenter() const
diff --git a/src/geode/geometry/bounding_box.cpp b/src/geode/geometry/bounding_box.cpp
index 4d1ba2e3f..337fda6c1 100644
--- a/src/geode/geometry/bounding_box.cpp
+++ b/src/geode/geometry/bounding_box.cpp
@@ -91,7 +91,7 @@ namespace
         const auto box_extent = box.diagonal() / 2.;
         const auto segment_origin = segment.barycenter() - box.center();
         const auto segment_extent = segment.length() / 2.;
-        const auto segment_direction = segment.normalized_direction();
+        const auto segment_direction = segment.direction();
         for( const auto i : geode::LRange{ dimension } )
         {
             const auto lhs = std::fabs( segment_origin.value( i ) );
diff --git a/src/geode/geometry/distance.cpp b/src/geode/geometry/distance.cpp
index b53c70e47..2258a180a 100644
--- a/src/geode/geometry/distance.cpp
+++ b/src/geode/geometry/distance.cpp
@@ -486,8 +486,10 @@ namespace
         /* Algorithm and code found on
          * https://github.com/davideberly/GeometricTools/blob/master/GTE/Mathematics/DistSegmentSegment.h
          */
-        const auto P1mP0 = segment0.direction();
-        const auto Q1mQ0 = segment1.direction();
+        const geode::Vector< dimension > P1mP0{ segment0.vertices()[0],
+            segment0.vertices()[1] };
+        const geode::Vector< dimension > Q1mQ0{ segment1.vertices()[0],
+            segment1.vertices()[1] };
         const geode::Vector< dimension > P0mQ0{ segment1.vertices()[0],
             segment0.vertices()[0] };
         const auto a = P1mP0.dot( P1mP0 );
@@ -799,7 +801,7 @@ namespace
         auto step = longest_segment.length() / 2;
         auto current_distance =
             geode::point_segment_distance( current_point, shortest_segment );
-        const auto segment_direction = longest_segment.normalized_direction();
+        const auto segment_direction = longest_segment.direction();
         while( step > geode::GLOBAL_EPSILON )
         {
             const auto point_at_step_plus =
@@ -898,7 +900,8 @@ namespace geode
         segment_line_distance( const Segment< dimension >& segment,
             const InfiniteLine< dimension >& line )
     {
-        const auto segDirection = segment.direction();
+        const Vector< dimension > segDirection{ segment.vertices()[0],
+            segment.vertices()[1] };
         const Vector< dimension > diff{ segment.vertices()[0], line.origin() };
         const auto a00 = line.direction().dot( line.direction() );
         const auto a01 = -line.direction().dot( segDirection );
diff --git a/src/geode/geometry/intersection.cpp b/src/geode/geometry/intersection.cpp
index 688567c86..5b614c305 100644
--- a/src/geode/geometry/intersection.cpp
+++ b/src/geode/geometry/intersection.cpp
@@ -272,8 +272,7 @@ namespace geode
         //   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
         //   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
         //   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
-        const auto segment_normalized_direction =
-            segment.normalized_direction();
+        const auto segment_normalized_direction = segment.direction();
         auto d_dot_n = segment_normalized_direction.dot( normal );
         signed_index_t sign;
         if( d_dot_n > 0. )
@@ -538,7 +537,7 @@ namespace geode
         // is x^2 + y^2 = r^2, where r is the cylinder radius. The end
         // caps are |z| = h/2, where h is the cylinder height.
         const auto basis =
-            compute_orthogonal_basis( cylinder.axis().normalized_direction() );
+            compute_orthogonal_basis( cylinder.axis().direction() );
         const auto& W = basis[0];
         const auto& U = basis[1];
         const auto& V = basis[2];
@@ -796,7 +795,7 @@ namespace geode
                     {
                         const geode::Vector3D point_to_vertex{ results[r],
                             cylinder.axis().vertices()[v] };
-                        if( cylinder.axis().normalized_direction().dot(
+                        if( cylinder.axis().direction().dot(
                                 point_to_vertex.normalize() )
                             <= GLOBAL_EPSILON )
                         {
diff --git a/src/geode/geometry/projection.cpp b/src/geode/geometry/projection.cpp
index 603729e96..0d9a18311 100644
--- a/src/geode/geometry/projection.cpp
+++ b/src/geode/geometry/projection.cpp
@@ -41,7 +41,7 @@ namespace geode
         {
             return barycenter;
         }
-        const auto norm_dir = segment.direction() / length;
+        const auto norm_dir = segment.direction();
         const auto d = norm_dir.dot( { barycenter, point } );
         if( std::fabs( d ) <= length / 2. )
         {
diff --git a/src/geode/mesh/helpers/rasterize.cpp b/src/geode/mesh/helpers/rasterize.cpp
index 8d80ba7a3..0a0fffe97 100644
--- a/src/geode/mesh/helpers/rasterize.cpp
+++ b/src/geode/mesh/helpers/rasterize.cpp
@@ -238,10 +238,12 @@ namespace
         const auto& vertices = triangle_in_grid.vertices();
         for( const auto e : geode::LRange{ 3 } )
         {
-            result[e].first = geode::Vector2D{
-                { -1 * edges_in_grid[e].direction().value( plane_axes[1] ),
-                    edges_in_grid[e].direction().value( plane_axes[0] ) }
-            } * normal_orientation;
+            result[e].first =
+                geode::Vector2D{
+                    { -1 * edges_in_grid[e].direction().value( plane_axes[1] ),
+                        edges_in_grid[e].direction().value( plane_axes[0] ) }
+                }
+                * normal_orientation * edges_in_grid[e].length();
             const auto& vertex = vertices[e];
             result[e].second = -result[e].first.dot( geode::Vector2D{
                                    { vertex.value( plane_axes[0] ),
@@ -564,8 +566,8 @@ namespace
         const auto pt1_in_grid =
             grid.grid_coordinate_system().coordinates( seg_vertices[1] );
         const geode::Segment2D segment_in_grid{ pt0_in_grid, pt1_in_grid };
-        const auto normal_in_grid =
-            geode::perpendicular( segment_in_grid.direction() );
+        const auto normal_in_grid = geode::perpendicular(
+            segment_in_grid.direction() * segment_in_grid.length() );
         const geode::InfiniteLine2D line_in_grid{ segment_in_grid };
         const auto critical_point = compute_critical_point( normal_in_grid );