diff --git a/application/editormode.h b/application/editormode.h
index 671da0e8..164efc18 100644
--- a/application/editormode.h
+++ b/application/editormode.h
@@ -1513,7 +1513,8 @@ class editor_mode : public application_mode, private editor_track::observer, pri
 	// the track through the points clicked, each the way its mode says; End: the free end it finishes at, the last point then
 	std::vector<segment_data> lay_pieces(std::vector<glm::dvec3> const &Points, std::vector<lay_mode> const &Modes, editor_track::snap_target const &End, double &Length, std::string &Error,
 	                                     lay_line_plan *Plan = nullptr) const;
-	bool lay_line(std::vector<glm::dvec3> const &Points, std::vector<lay_mode> const &Modes, editor_track::snap_target const &End, lay_line_plan &Plan, std::string &Error) const;
+	// Adjoining: the curve next to a free end on a curve goes on from its curvature, where it turns its way; else from a straight there
+	bool lay_line(std::vector<glm::dvec3> const &Points, std::vector<lay_mode> const &Modes, editor_track::snap_target const &End, lay_line_plan &Plan, std::string &Error, bool const Adjoining = true) const;
 	// the curves of a stretch traced, the ones fitted lately kept for the same points
 	// none while the stretch the cursor moves along is still being fitted; Meanwhile: the fit done last of the same points but the one
 	// at the cursor until then
diff --git a/application/editormodelay.cpp b/application/editormodelay.cpp
index d2a031c9..d0b9261d 100644
--- a/application/editormodelay.cpp
+++ b/application/editormodelay.cpp
@@ -46,6 +46,29 @@ http:
 
 using namespace track_mode;
 
+namespace
+{
+
+// the curve of the track of a free end the line laid goes on from at its start, or into at its end: its radius, the side it turns to
+// as the line runs and its cant leaning into the turn; nothing on a straight
+void adjoining_curve(editor_track::snap_target const &End, bool const Atend, double const Gauge, alignment::design &Design)
+{
+	if (End.track == nullptr || (End.track->eType != tt_Normal && End.track->eType != tt_Switch))
+		return;
+	auto const bend{editor_track::bend_at(*End.track, End.position)};
+	if (false == bend.has_value() || std::abs(bend->curvature) < 1e-4)
+		return;
+	// the curvature as the track goes on beyond its end: the way the line runs at its start, against it at its end
+	auto const curvature{Atend ? -bend->curvature : bend->curvature};
+	auto const cant{Gauge * std::sin(glm::radians(bend->roll)) * (bend->curvature > 0.0 ? 1.0 : -1.0)};
+	(Atend ? Design.end_radius : Design.start_radius) = 1.0 / std::abs(curvature);
+	(Atend ? Design.end_turn : Design.start_turn) = curvature > 0.0 ? 1 : -1;
+	(Atend ? Design.end_cant : Design.start_cant) = std::max(0.0, cant);
+	(Atend ? Design.end_curved : Design.start_curved) = true;
+}
+
+} // namespace
+
 void editor_mode::update_build_tools()
 {
 	glm::dvec3 const ground{cursor_ground()};
@@ -437,7 +460,8 @@ void editor_mode::point_drag_finish()
 std::optional<alignment::lay_result> editor_mode::eased_layout(TTrack const *From, glm::dvec3 const &Point, glm::dvec2 const &Direction, glm::dvec3 const &Target, double const Radius) const
 {
 	m_eased_last.reset();
-	if (From == nullptr || From->eType != tt_Normal)
+	// from the diverging track of a switch a curve goes on from its curvature, a straight goes on right from its end, as from the switch
+	if (From == nullptr || (From->eType != tt_Normal && (From->eType != tt_Switch || m_track_layout == track_layout::straight)))
 		return std::nullopt;
 	auto const end{editor_track::bend_at(*From, Point)};
 	if (false == end.has_value())
@@ -971,7 +995,8 @@ std::vector<segment_data> editor_mode::lay_pieces(std::vector<glm::dvec3> const
 		return std::max(alignment::minimum_pieces(Shape, Design), static_cast<std::size_t>(std::ceil(Shape.length / std::max(5.0, tool.piece_length))));
 	};
 	std::vector<segment_data> pieces;
-	// the curvature of the track laid has to go on from the one of the track it joins, a jump gets a transition curve between them
+	// the curvature of the track laid has to go on from the one of the track it joins, a jump gets a transition curve between them. Not
+	// at a switch: its diverging track ends its curve with a jump as it begins it, a straight going on right from there
 	auto const grade{(Points.back().y - Points.front().y) / std::max(1.0, plan_distance(Points.front(), Points.back()))};
 	auto const eased = [&](editor_track::snap_target const &Joint, double const Chainage, double const Sign) {
 		if (Joint.track == nullptr || Joint.track->eType != tt_Normal)
@@ -987,15 +1012,22 @@ std::vector<segment_data> editor_mode::lay_pieces(std::vector<glm::dvec3> const
 	if ((false == in.pieces.empty() || false == out.pieces.empty()) && editor_track::eases_room(in, out, Points.front(), design.start_direction, Points.back(), design.end_direction))
 	{
 		auto easeddesign{design};
+		// an end moved out of the curve of the adjoining track is on a straight
 		if (false == in.pieces.empty())
 		{
 			easeddesign.start = in.end;
 			easeddesign.start_direction = in.direction;
+			easeddesign.start_curved = false;
+			easeddesign.start_radius = 0.0;
+			easeddesign.start_turn = 0;
 		}
 		if (false == out.pieces.empty())
 		{
 			easeddesign.end = out.end;
 			easeddesign.end_direction = -out.direction;
+			easeddesign.end_curved = false;
+			easeddesign.end_radius = 0.0;
+			easeddesign.end_turn = 0;
 		}
 		// the bends stay where they are, measured from the ends moved
 		if (easeddesign.vertices.size() >= 2 && shape.vertices.size() == easeddesign.vertices.size())
@@ -1019,6 +1051,12 @@ std::vector<segment_data> editor_mode::lay_pieces(std::vector<glm::dvec3> const
 	{
 		Length = shape.length;
 		pieces = alignment::pieces(shape, design, count(shape, design));
+		// a line lay_line begins at the end of the transition out of the curve of the free end keeps the transition before it
+		auto const after = [&](editor_track::easing const &Easing, glm::dvec3 const &Joint, glm::dvec3 const &Own) { return false == Easing.pieces.empty() && plan_distance(Joint, Own) > 0.01; };
+		auto const &before{after(in, Points.front(), design.start) ? in : editor_track::easing{}};
+		auto const &beyond{after(out, Points.back(), design.end) ? out : editor_track::easing{}};
+		Length = editor_track::eased_length(before, Length, beyond);
+		pieces = editor_track::eased_pieces(before, pieces, beyond);
 	}
 	// the heights: fitted to the ground, or from point to point through the points clicked
 	TTrack const *style{tool.start.track != nullptr ? tool.start.track : End.track != nullptr ? End.track : tool.copy_selected ? selected_track() : nullptr};
@@ -1033,7 +1071,7 @@ std::vector<segment_data> editor_mode::lay_pieces(std::vector<glm::dvec3> const
 	return pieces;
 }
 
-bool editor_mode::lay_line(std::vector<glm::dvec3> const &Points, std::vector<lay_mode> const &Modes, editor_track::snap_target const &End, lay_line_plan &Plan, std::string &Error) const
+bool editor_mode::lay_line(std::vector<glm::dvec3> const &Points, std::vector<lay_mode> const &Modes, editor_track::snap_target const &End, lay_line_plan &Plan, std::string &Error, bool const Adjoining) const
 {
 	auto const &tool{m_lay};
 	Plan = {};
@@ -1043,6 +1081,22 @@ bool editor_mode::lay_line(std::vector<glm::dvec3> const &Points, std::vector<la
 	design.speed = design_speed(tool.start.track, End.track);
 	design.start = Points.front();
 	auto const joined{End.track != nullptr && glm::length(plan_of(End.direction)) > 1e-6};
+	// from a free end on a curve, or to one, the curve laid next to it turning its way goes on from its curvature: it begins right at the
+	// end, not on a straight, its transition going from that curvature. Where no such curve fits, the line is laid from a straight there,
+	// which lay_pieces eases out of the curve
+	if (Adjoining)
+	{
+		if (tool.start.track != nullptr && glm::length(plan_of(tool.start.direction)) > 1e-6)
+			adjoining_curve(tool.start, false, design.norms.gauge, design);
+		if (joined)
+			adjoining_curve(End, true, design.norms.gauge, design);
+	}
+	auto const curved{design.start_curved || design.end_curved};
+	auto const from_straight = [&]() { return curved && lay_line(Points, Modes, End, Plan, Error, false); };
+	// the end of the transition out of the curve of the free end, the start of the line where a curve traced next to it is laid from a
+	// straight there; the same at the end
+	std::optional<std::pair<glm::dvec3, glm::dvec2>> easedstart;
+	std::optional<std::pair<glm::dvec3, glm::dvec2>> easedend;
 	// the points between the start and the end: a free end reached is the last point
 	auto const inner{Points.size() - (joined ? 1 : 0)};
 	auto const mode_of = [&](std::size_t const Index) { return Index < Modes.size() ? Modes[Index] : lay_mode::straights; };
@@ -1117,6 +1171,8 @@ bool editor_mode::lay_line(std::vector<glm::dvec3> const &Points, std::vector<la
 			traced.push_back(plan_of(Points[k]));
 		}
 		i = last;
+		// the curve right from the free end the line starts at
+		auto const fromend{bends.empty() && Plan.traces.empty() && along.has_value()};
 		// the straight the curve comes from: the one of the free end or of the curve before, else the one through the last two
 		// points clicked before the curve, the last of them then no bend
 		auto entry{anchor};
@@ -1179,17 +1235,88 @@ bool editor_mode::lay_line(std::vector<glm::dvec3> const &Points, std::vector<la
 			// the curve may begin before the point the straight was clicked at, and end past the last point where the line goes on
 			base.start_reserve = behind;
 			base.end_reserve = last == inner ? 0.0 : 1e4;
-			auto const fitted{traced_stretch(base, traced, tool.radii, tool.straights_between)};
+			// it goes on from the curve of the free end it starts at, or into the one it finishes at
+			base.start_curved = design.start_curved && fromend;
+			base.end_curved = design.end_curved && reaching;
+			auto fitted{traced_stretch(base, traced, tool.radii, tool.straights_between)};
 			if (false == fitted.has_value())
 			{
 				Error = STR_C("Fitting the curve to the points...");
 				return false;
 			}
+			// next to a free end on a curve the stretch goes on from that curve, or begins from a straight there: eased out of the curve
+			// by the transition lay_pieces lays, or right from the end of the diverging track of a switch, as the switch goes on. The
+			// straight one where the curve next to the free end doesn't go on from it, or where that one doesn't keep to the points and
+			// this one keeps much closer
+			if (base.start_curved || base.end_curved)
+			{
+				auto plain{base};
+				plain.start_curved = plain.end_curved = false;
+				std::vector<glm::dvec2> kept;
+				auto const easing = [&](editor_track::snap_target const &Joint, double const Grade) {
+					return Joint.track != nullptr && Joint.track->eType == tt_Normal ? editor_track::ease_out_of(*Joint.track, Joint.position, Grade, design.speed, design.norms) : editor_track::easing{};
+				};
+				auto const in{base.start_curved ? easing(tool.start, 0.0) : editor_track::easing{}};
+				auto const out{base.end_curved ? easing(End, 0.0) : editor_track::easing{}};
+				if (false == in.pieces.empty())
+				{
+					plain.start = in.end;
+					plain.start_direction = in.direction;
+				}
+				if (false == out.pieces.empty())
+				{
+					plain.end = out.end;
+					plain.end_direction = -out.direction;
+				}
+				// the points along the transitions out of the curves left out, the line from the straights after them
+				for (auto const &point : traced)
+					if ((in.pieces.empty() || glm::distance(point, plan_of(base.start)) > in.length) && (out.pieces.empty() || glm::distance(point, plan_of(base.end)) > out.length))
+						kept.push_back(point);
+				auto const other{kept.size() >= 2 ? traced_stretch(plain, kept, tool.radii, tool.straights_between) : std::optional<alignment::trace_stretch>{alignment::trace_stretch{}}};
+				if (false == other.has_value())
+				{
+					Error = STR_C("Fitting the curve to the points...");
+					return false;
+				}
+				auto goes_on{false};
+				if (fitted->valid)
+				{
+					auto laid{base};
+					laid.vertices = fitted->vertices;
+					for (auto const &curve : alignment::compute(laid).curves)
+						goes_on = goes_on || curve.curvature_in > 0.0 || curve.curvature_out > 0.0;
+				}
+				// a curve going on which keeps to the points within 8 cm on average and 30 cm at most, as the fits take it for one keeping to
+				// them, stays: the straight one fits the points clicked a little off closer with the radii it has more
+				auto const loose{fitted->valid && (fitted->rms > 0.08 || fitted->worst > 0.3)};
+				if (other->valid && (false == fitted->valid || false == goes_on || (loose && other->rms < 0.75 * fitted->rms)))
+				{
+					fitted = other;
+					// the line laid from the end of the transition out of the curve, which lay_pieces lays before it
+					if (false == in.pieces.empty())
+						easedstart = std::make_pair(in.end, in.direction);
+					if (false == out.pieces.empty())
+						easedend = std::make_pair(out.end, -out.direction);
+					// from a straight there; at a switch with the jump of the curvature it has, which isn't warned of
+					auto const straight_at = [&](editor_track::snap_target const &Joint, bool &Curved, double &Radius, int &Turn) {
+						Curved = false;
+						if (Joint.track != nullptr && Joint.track->eType == tt_Switch)
+						{
+							Radius = 0.0;
+							Turn = 0;
+						}
+					};
+					if (base.start_curved)
+						straight_at(tool.start, design.start_curved, design.start_radius, design.start_turn);
+					if (base.end_curved)
+						straight_at(End, design.end_curved, design.end_radius, design.end_turn);
+				}
+			}
 			auto const &fit{*fitted};
 			if (false == fit.valid)
 			{
 				Error = STR_C("No curve follows the points clicked along it");
-				return false;
+				return from_straight();
 			}
 			for (auto const &vertex : fit.vertices)
 				bends.push_back({lifted(vertex.position, entry.y), vertex, false});
@@ -1259,6 +1386,13 @@ bool editor_mode::lay_line(std::vector<glm::dvec3> const &Points, std::vector<la
 			return false;
 		design.start_direction = glm::normalize(first);
 	}
+	if (easedstart.has_value())
+		std::tie(design.start, design.start_direction) = *easedstart;
+	if (easedend.has_value())
+	{
+		std::tie(design.end, design.end_direction) = *easedend;
+		end = design.end;
+	}
 	for (auto const &bend : bends)
 	{
 		auto vertex{bend.corner ? alignment::vertex{} : bend.vertex};
@@ -1275,7 +1409,7 @@ bool editor_mode::lay_line(std::vector<glm::dvec3> const &Points, std::vector<la
 	if (false == Plan.shape.valid)
 	{
 		Error = Plan.shape.errors.empty() ? std::string{STR_C("The track can't be laid through these points")} : Plan.shape.errors.front();
-		return false;
+		return from_straight();
 	}
 	// the grade breaks at the bends which stayed bends; along a curve, traced or made of bends, it goes on even from end to end
 	for (std::size_t k = 0; k < design.vertices.size() && k < Plan.corners.size(); ++k)
@@ -1295,8 +1429,12 @@ bool editor_mode::lay_line(std::vector<glm::dvec3> const &Points, std::vector<la
 std::optional<alignment::trace_stretch> editor_mode::traced_stretch(alignment::design const &Base, std::vector<glm::dvec2> const &Points, int const Radii, bool const Straights, bool const Meanwhile) const
 {
 	// the stretches traced before the one the cursor moves along are the same from frame to frame: their fits are kept
+	// the curves of the adjoining tracks it goes on from or into, signed by their turn, and their cants
+	auto const curvature = [](bool const Curved, double const Radius, int const Turn) { return Curved && Radius > 0.0 ? Turn / Radius : 0.0; };
 	std::vector<double> key{Base.start.x, Base.start.z, Base.start_direction.x, Base.start_direction.y, Base.end.x, Base.end.z, Base.end_direction.x, Base.end_direction.y, Base.speed,
-	                        static_cast<double>(Base.shape), static_cast<double>(Radii), Straights ? 1.0 : 0.0, Base.start_reserve, Base.end_reserve};
+	                        static_cast<double>(Base.shape), static_cast<double>(Radii), Straights ? 1.0 : 0.0, Base.start_reserve, Base.end_reserve,
+	                        curvature(Base.start_curved, Base.start_radius, Base.start_turn), Base.start_curved ? Base.start_cant : 0.0, curvature(Base.end_curved, Base.end_radius, Base.end_turn),
+	                        Base.end_curved ? Base.end_cant : 0.0};
 	for (auto const &point : Points)
 	{
 		key.push_back(point.x);
@@ -1330,7 +1468,7 @@ std::optional<alignment::trace_stretch> editor_mode::traced_stretch(alignment::d
 	}
 	m_stretch_fitter.ask({key, Base, Points, Radii, Straights});
 	std::vector<double> last;
-	auto const header{std::size_t{14}};
+	auto const header{std::size_t{18}};
 	if (Meanwhile && m_stretch_fitter.latest(last, fit) && last.size() >= header + 2 && key.size() >= header + 2 && std::equal(key.begin(), key.begin() + 4, last.begin()) &&
 	    std::equal(key.begin() + 8, key.begin() + header, last.begin() + 8))
 	{
@@ -1447,6 +1585,11 @@ void editor_mode::lay_finish(editor_track::snap_target const &End)
 		tool.status += "\n" + error;
 	if (eased.has_value() && eased->compound)
 		tool.status += "\n" + format(STR_C("Compound curve: R %.0f m goes on into R %.0f m through a transition curve of %.0f m"), eased->from_radius, eased->radius, eased->entry);
+	// the curves next to the free ends going on from the curves of their tracks
+	if (plan.shape.valid)
+		for (auto const &curve : plan.shape.curves)
+			if (auto const on{curve_goes_on(curve)}; false == on.empty())
+				tool.status += "\n" + format(STR_C("Curve %d %s"), curve.vertex + 1, on.c_str());
 	if (eased.has_value() && false == eased->note.empty())
 		tool.status += "\n" + eased->note;
 	{
diff --git a/application/editormoderoute.cpp b/application/editormoderoute.cpp
index d4695b6f..ed3331a5 100644
--- a/application/editormoderoute.cpp
+++ b/application/editormoderoute.cpp
@@ -277,6 +277,11 @@ void editor_mode::route_take_stored(int const Index)
 	design.norms = stored.design.norms;
 	design.transition_pieces = stored.design.transition_pieces;
 	design.arc_piece_angle = stored.design.arc_piece_angle;
+	// a curve laid going on from the curve of the track adjoining keeps going on from it, its radius the one which begins it there
+	design.start_curved = stored.design.start_curved;
+	design.end_curved = stored.design.end_curved;
+	design.start_cant = stored.design.start_cant;
+	design.end_cant = stored.design.end_cant;
 	route.designed = static_cast<int>(design.vertices.size());
 	route.origin = stored.origin;
 	route.vertex = -1;
@@ -2105,6 +2110,19 @@ bool editor_mode::render_route_vertex(int const Index)
 		return edited;
 	};
 	ImU32 const transition{IM_COL32(255, 140, 30, 255)};
+	// the first curve, or the last one, may go on from the curve of the track adjoining at that end: it begins right there, its radius
+	// the one which begins it there, its entry, or exit, the transition between the two curves
+	auto const count{static_cast<int>(design.vertices.size())};
+	for (auto const atend : {false, true})
+	{
+		auto const radius{atend ? design.end_radius : design.start_radius};
+		if ((atend ? Index + 1 != count : Index != 0) || radius <= 0.0 || radius >= 10000.0 || (atend && count == 1 && design.start_curved))
+			continue;
+		auto &curved{atend ? design.end_curved : design.start_curved};
+		changed |= ImGui::Checkbox((format(atend ? STR_C("Goes into the curve of the track at the end (R %.0f m)") : STR_C("Goes on from the curve of the track at the start (R %.0f m)"), radius) + (atend ? "##curvedend" : "##curvedstart")).c_str(), &curved);
+		item_tooltip("The curve begins right at the end of the fragment, at the curvature of the track adjoining there, where it turns the same way; its radius is the one "
+		             "which begins it there, the transition at that end goes between the two curves");
+	}
 	changed |= field("##radius", vertex.radius, 5.0f, vertex.compound ? STR_C("R1 %.0f m") : STR_C("R %.0f m"), overlay_color::grip, "Radius of the arc: drag sideways, or a double click to type it", part::arc);
 	ImGui::SameLine();
 	changed |= field("##cant", vertex.cant, 1.0f, STR_C("cant %.0f mm"), IM_COL32(240, 170, 60, 255),
diff --git a/application/editormodeselftest.cpp b/application/editormodeselftest.cpp
index 6ec1a20c..c4bc00d7 100644
--- a/application/editormodeselftest.cpp
+++ b/application/editormodeselftest.cpp
@@ -129,6 +129,11 @@ editor_mode::selftest_result editor_mode::selftest_dispatch(std::string const &c
 //   layclicks <layout 0..3> <radius> <x> <z>...   clicks of the lay tool at the points, a free end within 3 m joined
 //   layspeed <km/h> <own 0|1>            the speed set for the laying, and whether it goes also on from a track with its own
 //   laymode <straights|curve>, layradius <R from> <R to>, laytrace <radii 0..3> <straights between 0|1>   as the panel of the laying sets them
+//   endcurves                            logs every free end of the rails: where, the way out and the curvature its track goes on with
+//   curvejoint <x> <z>                   logs the paths meeting at the end nearest the point, the curvature of each and its jump from the ones before to the ones after
+//   laywalk <from|into> <x> <z> <spacing> <noise> <k0> <k1> <L>...   a line of known curves on from the free end nearest the point,
+//                                        the points along it clicked in the mode of a curve, from the end or towards it (see the command)
+//   laybends <x> <z> <distance> <degrees> ... <distance>   the bends of straights clicked from the free end nearest the point
 //   layp <x> <z>...                      the points clicked in the mode set, on the ground, a free end within 3 m reached
 //   layreport <label>                    logs the line the points clicked make, as Enter would lay it: its bends and curves, warnings, traces
 //   layenter, layback, laycancel         as Enter, Backspace and Esc while laying
diff --git a/application/editormodeselftestjoin.cpp b/application/editormodeselftestjoin.cpp
index 679ab688..c19e041d 100644
--- a/application/editormodeselftestjoin.cpp
+++ b/application/editormodeselftestjoin.cpp
@@ -46,6 +46,7 @@ http://mozilla.org/MPL/2.0/.
 #include <fstream>
 #include <map>
 #include <sstream>
+#include <array>
 #include "application/editormodeselftest.h"
 
 editor_mode::selftest_result editor_mode::selftest_join(std::string const &command, std::istringstream &words)
@@ -129,6 +130,87 @@ editor_mode::selftest_result editor_mode::selftest_join(std::string const &comma
 			WriteLog(format("SELFTEST %s end: %.3f m from the target", command.c_str(), geometry::plan_distance(previous, b)));
 		return selftest_result::handled;
 	}
+	if (command == "endcurves")
+	{
+		// every free end of the rails: where, the way out of it and the curvature of its track as it would go on beyond it
+		for (auto const &end : editor_track::free_ends(nullptr, 1, glm::dvec3{0.0}, 1e7, {}))
+		{
+			auto const bend{editor_track::bend_at(*end.track, end.position)};
+			auto const curvature{bend.has_value() ? bend->curvature : 0.0};
+			WriteLog(format("SELFTEST freeend %s[%d].%s: %.3f %.3f %.3f, out %.6f %.6f, k %.6f (R %.1f), roll %.3f", end.track->name().c_str(), end.point.path, end.point.kind == editor_track::point_kind::end ? "end" : "start", end.position.x, end.position.y,
+			                end.position.z, bend.has_value() ? bend->direction.x : 0.0, bend.has_value() ? bend->direction.y : 0.0, curvature, std::abs(curvature) > 1e-9 ? 1.0 / std::abs(curvature) : 0.0, bend.has_value() ? bend->roll : 0.0));
+		}
+		return selftest_result::handled;
+	}
+	if (command == "curvejoint")
+	{
+		// the paths meeting at the point: the curvature of each, signed the way the first one runs into the point, and the jumps of the
+		// curvature and of the direction from the ones before the point to the ones after it
+		glm::dvec3 point{0.0};
+		words >> point.x >> point.z;
+		// the end of a path nearest the point, within 3 m
+		auto nearest{3.0};
+		auto const given{point};
+		for (auto const *track : simulation::Paths.sequence())
+			if (track != nullptr && false == track->m_editorremoved)
+				for (auto const &path : track->m_paths)
+					for (auto const index : {segment_data::point::start, segment_data::point::end})
+						if (auto const distance{geometry::plan_distance(path.points[index], given)}; distance < nearest)
+						{
+							nearest = distance;
+							point = path.points[index];
+						}
+		struct meeting
+		{
+			TTrack const *track;
+			int path;
+			bool atend;
+			double curvature; // as the path goes away from the point
+			double roll;
+			glm::dvec2 out;
+		};
+		std::vector<meeting> meetings;
+		for (auto const *track : simulation::Paths.sequence())
+		{
+			if (track == nullptr || track->m_editorremoved)
+				continue;
+			for (int i = 0; i < static_cast<int>(track->m_paths.size()); ++i)
+				for (auto const atend : {false, true})
+				{
+					auto const &path{track->m_paths[i]};
+					if (geometry::plan_distance(path.points[atend ? segment_data::point::end : segment_data::point::start], point) > 0.05)
+						continue;
+					geometry::bezier const curve{path};
+					auto const first{curve.first(atend ? 1.0 : 0.0)};
+					auto const second{curve.second(atend ? 1.0 : 0.0)};
+					auto const speed{std::hypot(first.x, first.z)};
+					if (speed < 1e-9)
+						continue;
+					auto const curvature{(first.x * second.z - first.z * second.x) / (speed * speed * speed)};
+					glm::dvec2 const along{first.x / speed, first.z / speed};
+					meetings.push_back({track, i, atend, atend ? -curvature : curvature, static_cast<double>(atend ? path.rolls[1] : path.rolls[0]), atend ? -along : along});
+				}
+		}
+		if (meetings.empty())
+		{
+			WriteLog(format("SELFTEST curvejoint %.1f %.1f: no path ends there", point.x, point.z));
+			return selftest_result::handled;
+		}
+		auto const into{-meetings.front().out};
+		std::vector<std::pair<double, glm::dvec2>> before;
+		std::vector<std::pair<double, glm::dvec2>> after;
+		for (auto const &each : meetings)
+		{
+			auto const leaving{glm::dot(each.out, into) > 0.0};
+			auto const curvature{leaving ? each.curvature : -each.curvature};
+			(leaving ? after : before).emplace_back(curvature, leaving ? each.out : -each.out);
+			WriteLog(format("SELFTEST curvejoint %s[%d].%s: %s, k %.6f (R %.1f), roll %.3f", each.track->name().c_str(), each.path, each.atend ? "end" : "start", leaving ? "after" : "before", curvature, std::abs(curvature) > 1e-9 ? 1.0 / std::abs(curvature) : 0.0, each.roll));
+		}
+		for (auto const &[k0, d0] : before)
+			for (auto const &[k1, d1] : after)
+				WriteLog(format("SELFTEST curvejoint jump: k %.6f -> %.6f, by %.6f 1/m (%.1f%%), kink %.4f deg", k0, k1, k1 - k0, std::abs(k0) > 1e-9 ? 100.0 * std::abs(k1 - k0) / std::abs(k0) : 0.0, glm::degrees(std::abs(geometry::signed_angle(d0, d1)))));
+		return selftest_result::handled;
+	}
 	if (command == "fittime")
 	{
 		// the grade line of a straight laid over rolling ground fitted, as at a click, and as while the track follows the
@@ -267,6 +349,123 @@ editor_mode::selftest_result editor_mode::selftest_join(std::string const &comma
 		lay_report(label);
 		return selftest_result::handled;
 	}
+	// a line of known curves going on from the free end nearest the point, within 60 m: segments of the curvature going evenly from the
+	// first to the second (1/m, positive turning the way the track of the end turns, to the left from a straight one) over the length. from: the free end
+	// clicked, then in the mode of a curve the points along the line every Spacing metres and two on the straight after it, 30 and 60 m
+	// on, left for Enter; into: the same line laid towards the free end, the point 60 m on clicked first, the one 30 m on and the ones
+	// along the line in the mode of a curve, the free end last, which lays it. The points shifted across by up to Noise
+	if (command == "laywalk")
+	{
+		std::string way;
+		glm::dvec3 around{0.0};
+		double spacing{10.0};
+		double noise{0.0};
+		words >> way >> around.x >> around.z >> spacing >> noise;
+		std::vector<std::array<double, 3>> segments;
+		for (std::array<double, 3> segment; words >> segment[0] >> segment[1] >> segment[2];)
+			segments.push_back(segment);
+		auto const end{editor_track::find_free_end(nullptr, 1, around, 60.0, {})};
+		auto const bend{end.track != nullptr ? editor_track::bend_at(*end.track, end.position) : std::nullopt};
+		if (false == bend.has_value() || segments.empty() || spacing <= 0.0)
+		{
+			WriteLog("SELFTEST laywalk: no free end near the point, or no line");
+			return selftest_result::handled;
+		}
+		glm::dvec2 position{end.position.x, end.position.z};
+		auto heading{std::atan2(bend->direction.y, bend->direction.x)};
+		auto const sense{bend->curvature < 0.0 ? -1.0 : 1.0};
+		double chainage{0.0};
+		std::vector<glm::dvec2> along;
+		std::vector<glm::dvec2> across;
+		auto next{spacing};
+		for (auto const &[from, to, length] : segments)
+		{
+			auto const steps{std::max(1, static_cast<int>(std::ceil(length / 0.05)))};
+			auto const step{length / steps};
+			auto const start{heading};
+			auto const angle = [&, from = from * sense, to = to * sense, length = length](double const S) { return start + from * S + (to - from) * S * S / (2.0 * length); };
+			for (int i = 0; i < steps; ++i)
+			{
+				auto const middle{angle((i + 0.5) * step)};
+				position += glm::dvec2{std::cos(middle), std::sin(middle)} * step;
+				chainage += step;
+				if (chainage >= next - 1e-6)
+				{
+					auto const now{angle((i + 1) * step)};
+					along.push_back(position);
+					across.push_back({-std::sin(now), std::cos(now)});
+					next += spacing;
+				}
+			}
+			heading = angle(length);
+		}
+		glm::dvec2 const out{std::cos(heading), std::sin(heading)};
+		glm::dvec2 const side{-out.y, out.x};
+		auto const shifted = [&](glm::dvec2 const &Point, glm::dvec2 const &Across, int const Count) {
+			auto const shift{noise * (Count % 3 == 0 ? 1.0 : Count % 3 == 1 ? -0.6 : 0.2)};
+			return glm::dvec3{Point.x + Across.x * shift, 0.0, Point.y + Across.y * shift};
+		};
+		WriteLog(format("SELFTEST laywalk %s from %s[%d]: %.3f %.3f heading %.4f, k %.6f, line %.1f m to %.3f %.3f heading %.4f, %zu points along it", way.c_str(), end.track->name().c_str(), end.point.path, end.position.x, end.position.z, std::atan2(bend->direction.y, bend->direction.x),
+		                bend->curvature, chainage, position.x, position.y, heading, along.size()));
+		m_lay.active = true;
+		lay_cancel();
+		if (m_lay.mode != lay_mode::straights)
+			lay_switch_mode();
+		if (way == "into")
+		{
+			lay_point(shifted(position + out * 60.0, side, 0));
+			lay_switch_mode();
+			lay_point(shifted(position + out * 30.0, side, 1));
+			for (auto i{along.size()}; i-- > 0;)
+				if (glm::distance(along[i], glm::dvec2{end.position.x, end.position.z}) > 3.5)
+					lay_point(shifted(along[i], across[i], static_cast<int>(i)));
+			lay_point(end.position);
+			WriteLog(format("SELFTEST laywalk into: %zu points, %s", m_lay.points.size(), m_lay.status.c_str()));
+		}
+		else
+		{
+			lay_point(end.position);
+			lay_switch_mode();
+			for (std::size_t i = 0; i < along.size(); ++i)
+				lay_point(shifted(along[i], across[i], static_cast<int>(i)));
+			lay_point(shifted(position + out * 30.0, side, 1));
+			lay_point(shifted(position + out * 60.0, side, 2));
+			WriteLog(format("SELFTEST laywalk from: %zu points, start %s", m_lay.points.size(), m_lay.start.track != nullptr ? m_lay.start.track->name().c_str() : "-"));
+		}
+		lay_switch_mode();
+		return selftest_result::handled;
+	}
+	// the bends of straights from the free end nearest the point, within 60 m: the free end clicked, then each point the distance on
+	// along the way it goes, which then turns by the angle (degrees, positive the way the track of the end turns, to the left from a
+	// straight one); the last one the end, left for Enter
+	if (command == "laybends")
+	{
+		glm::dvec3 around{0.0};
+		words >> around.x >> around.z;
+		auto const end{editor_track::find_free_end(nullptr, 1, around, 60.0, {})};
+		auto const bend{end.track != nullptr ? editor_track::bend_at(*end.track, end.position) : std::nullopt};
+		if (false == bend.has_value())
+		{
+			WriteLog("SELFTEST laybends: no free end near the point");
+			return selftest_result::handled;
+		}
+		m_lay.active = true;
+		lay_cancel();
+		if (m_lay.mode != lay_mode::straights)
+			lay_switch_mode();
+		lay_point(end.position);
+		glm::dvec2 position{end.position.x, end.position.z};
+		auto heading{std::atan2(bend->direction.y, bend->direction.x)};
+		for (double distance{0.0}; words >> distance;)
+		{
+			position += glm::dvec2{std::cos(heading), std::sin(heading)} * distance;
+			lay_point({position.x, 0.0, position.y});
+			if (double turn{0.0}; words >> turn)
+				heading += glm::radians(turn) * (bend->curvature < 0.0 ? -1.0 : 1.0);
+		}
+		WriteLog(format("SELFTEST laybends from %s[%d] %.3f %.3f: %zu points", end.track->name().c_str(), end.point.path, end.position.x, end.position.z, m_lay.points.size()));
+		return selftest_result::handled;
+	}
 	if (command == "layenter" || command == "laycancel" || command == "layback")
 	{
 		m_typed.clear();
diff --git a/application/editormodeselftesttrack.cpp b/application/editormodeselftesttrack.cpp
index 05ca9361..97f59268 100644
--- a/application/editormodeselftesttrack.cpp
+++ b/application/editormodeselftesttrack.cpp
@@ -233,6 +233,13 @@ editor_mode::selftest_result editor_mode::selftest_track(std::string const &comm
 				text += format(" [R %.3f L %.3f share %.4f]", arc.radius, arc.transition, arc.share);
 			WriteLog(text);
 		}
+		// the curves the design lays, going on from the curves of the tracks adjoining where they do, and its warnings
+		WriteLog(format("SELFTEST route ends: start R %.1f turn %d curved %d, end R %.1f turn %d curved %d", m_route.design.start_radius, m_route.design.start_turn, m_route.design.start_curved ? 1 : 0, m_route.design.end_radius, m_route.design.end_turn, m_route.design.end_curved ? 1 : 0));
+		for (auto const &curve : m_route.result.curves)
+			WriteLog(format("SELFTEST route curve %d: R %.1f, L %.1f/%.1f, from R %.1f, into R %.1f", curve.vertex, curve.radius, curve.transition_in, curve.transition_out, curve.curvature_in > 0.0 ? 1.0 / curve.curvature_in : 0.0,
+			                curve.curvature_out > 0.0 ? 1.0 / curve.curvature_out : 0.0));
+		for (auto const &warning : m_route.result.warnings)
+			WriteLog("SELFTEST route warning: " + warning);
 		return selftest_result::handled;
 	}
 	if (command == "routevertex" || command == "routearc" || command == "routeshare")
diff --git a/application/editormodetrack.cpp b/application/editormodetrack.cpp
index 49351111..227f4fc0 100644
--- a/application/editormodetrack.cpp
+++ b/application/editormodetrack.cpp
@@ -1909,6 +1909,11 @@ std::string editor_mode::track_readout() const
 				text += "   " + curve_label(curve, laying_norms());
 				if (false == alignment::meets_norms(curve, plan.design))
 					text += "\n" + STR("this curve doesn't meet the norms, it's laid all the same");
+				// the curves next to the free ends going on from the curves of their tracks: the first and the last one
+				if (auto const on{curve_goes_on(plan.shape.curves.front())}; false == on.empty())
+					text += "\n" + on;
+				if (auto const on{curve_goes_on(curve)}; plan.shape.curves.size() > 1 && false == on.empty())
+					text += "\n" + on;
 			}
 			if (lay.mode == lay_mode::curve && false == plan.traces.empty() && false == plan.traces.back().offsets.empty())
 			{
diff --git a/application/editormodetrackshared.h b/application/editormodetrackshared.h
index 96002301..688c9fac 100644
--- a/application/editormodetrackshared.h
+++ b/application/editormodetrackshared.h
@@ -102,6 +102,22 @@ inline std::string curve_label(alignment::curve_report const &Curve, alignment::
 	return text + speed_of(curve_sharpest(Curve), Limits);
 }
 
+// how a curve laid goes on from the curve of the track it starts at, or into the one of the track it ends at; empty from a straight
+inline std::string curve_goes_on(alignment::curve_report const &Curve)
+{
+	std::vector<std::string> lines;
+	if (Curve.curvature_in > 0.0)
+		lines.push_back(Curve.transition_in < 1.0 ? format(STR_C("goes on from R %.0f m of the track it starts at"), 1.0 / Curve.curvature_in) :
+		                                            format(STR_C("goes on from R %.0f m of the track it starts at, a transition of %.0f m between them"), 1.0 / Curve.curvature_in, Curve.transition_in));
+	if (Curve.curvature_out > 0.0)
+		lines.push_back(Curve.transition_out < 1.0 ? format(STR_C("goes into R %.0f m of the track it ends at"), 1.0 / Curve.curvature_out) :
+		                                             format(STR_C("goes into R %.0f m of the track it ends at, a transition of %.0f m between them"), 1.0 / Curve.curvature_out, Curve.transition_out));
+	std::string text;
+	for (auto const &line : lines)
+		text += (text.empty() ? "" : "\n") + line;
+	return text;
+}
+
 // the transition curves and the cant the norms put in a layout, a compound curve where it goes on from an arc turning the same way
 inline std::string eased_of(std::optional<alignment::lay_result> const &Eased)
 {
diff --git a/editor/editorAlignment.cpp b/editor/editorAlignment.cpp
index ac2c1c1e..56cebbcc 100644
--- a/editor/editorAlignment.cpp
+++ b/editor/editorAlignment.cpp
@@ -112,8 +112,18 @@ struct compound_curve
 	double shortened{1.0};
 };
 
+// the curvature and the cant a curve goes on from at its start and into at its end, those of the curve of the adjoining track turning
+// its way; 0 on a straight
+struct curve_ends
+{
+	double from{0.0};
+	double to{0.0};
+	double from_cant{0.0};
+	double to_cant{0.0};
+};
+
 // Cants: of the arcs, the cants of the segments stay 0 without them
-compound_curve build_compound(double const Deflection, std::vector<compound_arc> const &Arcs, double const Lengthin, double const Lengthout, std::vector<double> const &Cants = {})
+compound_curve build_compound(double const Deflection, std::vector<compound_arc> const &Arcs, double const Lengthin, double const Lengthout, std::vector<double> const &Cants = {}, curve_ends const &Ends = {})
 {
 	compound_curve result;
 	if (Arcs.empty())
@@ -122,7 +132,7 @@ compound_curve build_compound(double const Deflection, std::vector<compound_arc>
 	for (auto const &arc : Arcs)
 		curvatures.push_back(1.0 / std::max(1.0, arc.radius));
 	auto const cant = [&](std::size_t const Arc) { return Arc < Cants.size() ? Cants[Arc] : 0.0; };
-	auto transitions{curvatures.front() * Lengthin + curvatures.back() * Lengthout};
+	auto transitions{(Ends.from + curvatures.front()) * Lengthin + (curvatures.back() + Ends.to) * Lengthout};
 	for (std::size_t i = 1; i < Arcs.size(); ++i)
 		transitions += (curvatures[i - 1] + curvatures[i]) * std::max(0.0, Arcs[i].transition);
 	transitions *= 0.5;
@@ -133,7 +143,7 @@ compound_curve build_compound(double const Deflection, std::vector<compound_arc>
 	double total{0.0};
 	for (auto const &arc : Arcs)
 		total += std::max(0.0, arc.share);
-	std::vector<std::array<double, 5>> segments{{0.0, curvatures.front(), Lengthin * f, 0.0, cant(0)}};
+	std::vector<std::array<double, 5>> segments{{Ends.from, curvatures.front(), Lengthin * f, Ends.from_cant, cant(0)}};
 	for (std::size_t i = 0; i < Arcs.size(); ++i)
 	{
 		if (i > 0)
@@ -141,7 +151,7 @@ compound_curve build_compound(double const Deflection, std::vector<compound_arc>
 		auto const share{total > 0.0 ? std::max(0.0, Arcs[i].share) / total : 1.0 / static_cast<double>(Arcs.size())};
 		segments.push_back({curvatures[i], curvatures[i], share * arcs / curvatures[i], cant(i), cant(i)});
 	}
-	segments.push_back({curvatures.back(), 0.0, Lengthout * f, cant(Arcs.size() - 1), 0.0});
+	segments.push_back({curvatures.back(), Ends.to, Lengthout * f, cant(Arcs.size() - 1), Ends.to_cant});
 	double x{0.0};
 	double y{0.0};
 	double heading{0.0};
@@ -375,6 +385,20 @@ double spirals_length(transition_shape const Shape, double const Deflection, dou
 	return Shape == transition_shape::clothoid ? 2.0 * Radius * half : 2.0 * Radius * std::tan(half);
 }
 
+namespace
+{
+
+// the transition between the curve of an adjoining track and the arc next to it, as between two arcs; none where the curvature differs
+// by 5 % at most and the cant by less than 5 mm, the curve going on at the radius of the adjoining one
+double between_curves(double const Speed, double const Curvature0, double const Cant0, double const Curvature1, double const Cant1, limits const &Limits)
+{
+	if (std::abs(Curvature1 - Curvature0) <= 0.05 * std::max(std::abs(Curvature0), std::abs(Curvature1)) && std::abs(Cant1 - Cant0) < 5.0)
+		return 0.0;
+	return transition_between(Speed, Curvature0, Cant0, Curvature1, Cant1, Limits);
+}
+
+} // namespace
+
 bool meets_norms(curve_report const &Curve, design const &Design)
 {
 	auto const &norms{Design.norms};
@@ -385,6 +409,16 @@ bool meets_norms(curve_report const &Curve, design const &Design)
 		return false;
 	if (false == Curve.spirals && sharpest < Curve.recommended.radius_min - 1e-6)
 		return false;
+	// going on from the curve of an adjoining track, or into it: the transition there between its curvature and cant and those of the
+	// arc next to it
+	if ((Curve.curvature_in > 0.0 || Curve.curvature_out > 0.0) && false == Curve.radii.empty() && Curve.cants.size() == Curve.radii.size())
+	{
+		auto const required = [&](double const Curvature, double const Cant, double const Radius, double const Arccant) {
+			return Curvature > 0.0 ? between_curves(Design.speed, Curvature, Cant, 1.0 / Radius, Arccant, norms) : transition_length(Design.speed, Radius, Arccant, norms);
+		};
+		return Curve.transition_in + 1e-6 >= required(Curve.curvature_in, Curve.cant_in, Curve.radii.front(), Curve.cants.front()) &&
+		       Curve.transition_out + 1e-6 >= required(Curve.curvature_out, Curve.cant_out, Curve.radii.back(), Curve.cants.back());
+	}
 	if (Curve.radii.size() > 1 && Curve.cants.size() == Curve.radii.size())
 		// a compound curve ramps the cant of its first arc in and the one of its last arc out
 		return Curve.transition_in + 1e-6 >= transition_length(Design.speed, Curve.radii.front(), Curve.cants.front(), norms) &&
@@ -439,6 +473,26 @@ void make_cants(design const &Design, result &R)
 		auto const exit{tail.kind == element_kind::transition_out || (tail.kind == element_kind::spiral && tail.curvature_end == 0.0 && tail.curvature_start > 0.0) ? tail.length : 0.0};
 		auto const cantin{element_cant(head, entry)};
 		auto const cantout{element_cant(tail, tail.length - exit)};
+		// a curve going on from the curve of the adjoining track, or into it, has its cant there from the first: no ramp at that end
+		auto const continuedin{head.kind == element_kind::spiral && head.curvature_start > 0.0};
+		auto const continuedout{tail.kind == element_kind::spiral && tail.curvature_end > 0.0};
+		if (continuedin || continuedout)
+		{
+			push(start, continuedin ? turn * cantin : 0.0);
+			for (auto i{first}; i <= last; ++i)
+			{
+				auto const &e{R.elements[i]};
+				for (auto const distance : {0.0, e.length})
+					push(e.chainage + distance, turn * element_cant(e, distance));
+			}
+			push(end, continuedout ? turn * element_cant(tail, tail.length) : 0.0);
+			if (false == continuedin && cantin >= 0.5)
+				R.ramps.push_back({static_cast<int>(k), start, start + entry, cantin, false});
+			if (false == continuedout && cantout >= 0.5)
+				R.ramps.push_back({static_cast<int>(k), end - exit, end, cantout, false});
+			reached = end;
+			continue;
+		}
 		if (std::max(cantin, cantout) < 0.5)
 		{
 			reached = end;
@@ -621,6 +675,9 @@ result fit_between(design const &Design)
 		double cant{0.0};
 		bool compound{false};
 		bool spirals{false};
+		// going on from the curve of the adjoining track: its size is fixed by the start or by the end, the curves next to it make room
+		bool curved{false};
+		curve_ends ends;
 		std::vector<compound_arc> arcs;
 		std::function<void(double, double &, double &)> tangents;
 	};
@@ -654,6 +711,116 @@ result fit_between(design const &Design)
 			r.errors.emplace_back(format(STR_C("Vertex %zu: a turn of about 180 or 360 degrees needs one more vertex"), k + 1));
 			return r;
 		}
+		// the curve going on from the curve of the adjoining track turning its way, at the start or at the end: a compound curve of the
+		// arcs it has, one or more, as large as begin it right at the start, or end it at the end
+		auto const from{k == 0 && Design.start_curved && Design.start_radius > 0.0 && Design.start_turn == side};
+		auto const to{k + 1 == count && Design.end_curved && Design.end_radius > 0.0 && Design.end_turn == side && false == from};
+		if ((from || to) && false == reverse && false == vertex.spirals)
+		{
+			fit.compound = true;
+			fit.curved = true;
+			fit.deflection = deflection;
+			fit.arcs = {{fit.radius, 0.0, 1.0, -1.0}};
+			if (vertex.compound && false == vertex.arcs.empty())
+			{
+				fit.arcs.front() = {fit.radius, 0.0, vertex.share, vertex.first_cant};
+				for (auto const &arc : vertex.arcs)
+					fit.arcs.push_back({std::max(1.0, arc.radius), std::max(0.0, arc.transition), arc.share, arc.cant});
+			}
+			if (from)
+			{
+				fit.ends.from = 1.0 / Design.start_radius;
+				fit.ends.from_cant = std::max(0.0, Design.start_cant);
+				// with no transition between them the cant of the adjoining track goes on into the arc
+				if (fit.transition_in < 1.0)
+					fit.arcs.front().cant = fit.ends.from_cant;
+			}
+			else
+			{
+				fit.ends.to = 1.0 / Design.end_radius;
+				fit.ends.to_cant = std::max(0.0, Design.end_cant);
+				if (fit.transition_out < 1.0)
+					fit.arcs.back().cant = fit.ends.to_cant;
+			}
+			auto const normalin{perpendicular(directionin) * static_cast<double>(side)};
+			auto const tangents_at = [&](double const Scale, double &Tangentin, double &Tangentout) {
+				auto arcs{fit.arcs};
+				for (auto &arc : arcs)
+					arc.radius *= Scale;
+				auto const shape{build_compound(deflection, arcs, fit.transition_in, fit.transition_out, {}, fit.ends)};
+				auto const end{directionin * shape.end.x + normalin * shape.end.y};
+				Tangentin = cross(directionout, end) / cross(directionout, directionin);
+				Tangentout = glm::dot(end - directionin * Tangentin, directionout);
+			};
+			// the straight it begins at, or ends at, all along the tangent: no straight between
+			auto const wanted{from ? glm::distance(polygon[0], polygon[1]) : glm::distance(polygon[count], polygon[count + 1])};
+			auto const miss = [&](double const Scale) {
+				double in;
+				double out;
+				tangents_at(Scale, in, out);
+				return (from ? in : out) - wanted;
+			};
+			// the radii grow with the tangent: from those given the way the miss says, doubled or halved until it changes its sign, then
+			// the root between, by the regula falsi of Illinois
+			auto low{1.0};
+			auto lowmiss{miss(low)};
+			auto high{low};
+			auto highmiss{lowmiss};
+			auto const smallest{5.0 / fit.radius};
+			auto const largest{1e6 / fit.radius};
+			while ((lowmiss < 0.0) == (highmiss < 0.0) && high < largest && low > smallest)
+			{
+				if (lowmiss < 0.0)
+				{
+					low = high;
+					lowmiss = highmiss;
+					high *= 2.0;
+					highmiss = miss(high);
+				}
+				else
+				{
+					high = low;
+					highmiss = lowmiss;
+					low *= 0.5;
+					lowmiss = miss(low);
+				}
+			}
+			if ((lowmiss < 0.0) == (highmiss < 0.0))
+			{
+				r.errors.emplace_back(from ? format(STR_C("Vertex %zu: no curve goes on from the curve of the adjoining track (R %.0f m) to the straight after it"), k + 1, Design.start_radius) :
+				                             format(STR_C("Vertex %zu: no curve goes on from the straight before it into the curve of the adjoining track (R %.0f m)"), k + 1, Design.end_radius));
+				return r;
+			}
+			auto scale{low};
+			for (int i = 0, kept = 0; i < 60; ++i)
+			{
+				scale = (low * highmiss - high * lowmiss) / (highmiss - lowmiss);
+				auto const value{miss(scale)};
+				if (std::abs(value) < 1e-7 || high - low < 1e-12 * high)
+					break;
+				if ((value < 0.0) == (lowmiss < 0.0))
+				{
+					low = scale;
+					lowmiss = value;
+					if (kept == -1)
+						highmiss *= 0.5;
+					kept = -1;
+				}
+				else
+				{
+					high = scale;
+					highmiss = value;
+					if (kept == 1)
+						lowmiss *= 0.5;
+					kept = 1;
+				}
+			}
+			for (auto &arc : fit.arcs)
+				arc.radius *= scale;
+			fit.radius = fit.arcs.front().radius;
+			tangents_at(1.0, fit.tangent_in, fit.tangent_out);
+			continue;
+		}
 		if (vertex.compound && false == vertex.arcs.empty())
 		{
 			fit.compound = true;
@@ -713,13 +880,27 @@ result fit_between(design const &Design)
 	for (std::size_t leg = 0; leg + 1 < polygon.size(); ++leg)
 	{
 		auto const available{glm::distance(polygon[leg], polygon[leg + 1]) + (leg == 0 ? startreserve : 0.0) + (leg == count ? endreserve : 0.0)};
-		auto const required{(leg > 0 ? fits[leg - 1].tangent_out : 0.0) + (leg < count ? fits[leg].tangent_in : 0.0)};
-		if (required <= available + 1e-6)
+		auto const before{leg > 0 ? fits[leg - 1].tangent_out : 0.0};
+		auto const after{leg < count ? fits[leg].tangent_in : 0.0};
+		if (before + after <= available + 1e-6)
 			continue;
-		auto const scale{available / required * (1.0 - 1e-9)};
-		if (leg > 0)
+		// a curve going on from the adjoining track keeps its size, the one on the other side of the straight makes room for it
+		auto const fixedbefore{leg > 0 && fits[leg - 1].curved};
+		auto const fixedafter{leg < count && fits[leg].curved};
+		if (fixedbefore != fixedafter)
+		{
+			auto const other{fixedbefore ? after : before};
+			if (other > 1e-9)
+			{
+				auto &kept{scales[fixedbefore ? leg : leg - 1]};
+				kept = std::min(kept, std::clamp((available - (fixedbefore ? before : after)) / other, 1e-3, 1.0) * (1.0 - 1e-9));
+			}
+			continue;
+		}
+		auto const scale{available / (before + after) * (1.0 - 1e-9)};
+		if (leg > 0 && false == fits[leg - 1].curved)
 			scales[leg - 1] = std::min(scales[leg - 1], scale);
-		if (leg < count)
+		if (leg < count && false == fits[leg].curved)
 			scales[leg] = std::min(scales[leg], scale);
 	}
 	for (std::size_t k = 0; k < count; ++k)
@@ -838,7 +1019,7 @@ result fit_between(design const &Design)
 		if (fit.compound)
 		{
 			auto const cants{arc_cants(fit.arcs, fit.cant)};
-			auto const shape{build_compound(deflection, fit.arcs, fit.transition_in, fit.transition_out, cants)};
+			auto const shape{build_compound(deflection, fit.arcs, fit.transition_in, fit.transition_out, cants, fit.ends)};
 			if (shape.shortened < 1.0)
 				r.warnings.emplace_back(format(STR_C("Vertex %zu: transition curves shortened to fit the deflection angle"), k + 1));
 			auto const normalin{perpendicular(directionin) * static_cast<double>(side)};
@@ -893,6 +1074,10 @@ result fit_between(design const &Design)
 			report.tangent_in = glm::distance(position, curvestart);
 			report.tangent_out = glm::distance(position, cursor);
 			report.cants = cants;
+			report.curvature_in = fit.ends.from;
+			report.cant_in = fit.ends.from_cant;
+			report.curvature_out = fit.ends.to;
+			report.cant_out = fit.ends.to_cant;
 			report.unbalanced = -std::numeric_limits<double>::max();
 			for (std::size_t i = 0; i < cants.size(); ++i)
 			{
@@ -913,10 +1098,22 @@ result fit_between(design const &Design)
 			// each transition long enough for the change of the curvature and of the cant along it, at the speed the sharpest arc
 			// allows, as the transitions of the norms are set between the arcs
 			auto const allowed{std::max(1.0, std::min(Design.speed, speed_limit(sharpest, norms)))};
-			auto const requiredin{transition_length(allowed, fit.arcs.front().radius, cants.front(), norms)};
-			auto const requiredout{transition_length(allowed, fit.arcs.back().radius, cants.back(), norms)};
-			if (report.transition_in + 1e-6 < requiredin || report.transition_out + 1e-6 < requiredout)
-				r.warnings.emplace_back(format(STR_C("Vertex %zu: transition curves shorter than the required %.0f m"), k + 1, std::max(requiredin, requiredout)));
+			// from the curve of an adjoining track, or into it, as between two arcs, at the speed the sharper of them allows
+			auto const slower = [&](double const Curvature) { return Curvature > 0.0 ? std::max(1.0, std::min(allowed, speed_limit(1.0 / Curvature, norms))) : allowed; };
+			auto const requiredin{fit.ends.from > 0.0 ? between_curves(slower(fit.ends.from), fit.ends.from, fit.ends.from_cant, 1.0 / fit.arcs.front().radius, cants.front(), norms) :
+			                                            transition_length(allowed, fit.arcs.front().radius, cants.front(), norms)};
+			auto const requiredout{fit.ends.to > 0.0 ? between_curves(slower(fit.ends.to), 1.0 / fit.arcs.back().radius, cants.back(), fit.ends.to, fit.ends.to_cant, norms) :
+			                                           transition_length(allowed, fit.arcs.back().radius, cants.back(), norms)};
+			// the transition between the curve of the adjoining track and the arc told apart from the one to the straight
+			auto const shortin{report.transition_in + 1e-6 < requiredin};
+			auto const shortout{report.transition_out + 1e-6 < requiredout};
+			auto const betweenin{fit.ends.from > 0.0};
+			auto const betweenout{fit.ends.to > 0.0};
+			if ((shortin && betweenin) || (shortout && betweenout))
+				r.warnings.emplace_back(format(STR_C("Vertex %zu: the transition curve between the curve of the adjoining track and R %.0f m is shorter than the required %.0f m"), k + 1,
+				                               shortin && betweenin ? fit.arcs.front().radius : fit.arcs.back().radius, shortin && betweenin ? requiredin : requiredout));
+			if ((shortin && false == betweenin) || (shortout && false == betweenout))
+				r.warnings.emplace_back(format(STR_C("Vertex %zu: transition curves shorter than the required %.0f m"), k + 1, std::max(shortin && false == betweenin ? requiredin : 0.0, shortout && false == betweenout ? requiredout : 0.0)));
 			for (std::size_t i = 1; i < fit.arcs.size(); ++i)
 			{
 				auto const required{transition_between(allowed, 1.0 / fit.arcs[i - 1].radius, cants[i - 1], 1.0 / fit.arcs[i].radius, cants[i], norms)};
@@ -1116,9 +1313,11 @@ result fit_between(design const &Design)
 		auto const theirs{(Turn != 0 ? Turn : Own < 0.0 ? -1 : 1) / Radius};
 		return std::abs(theirs - Own) > 0.05 * std::max(1.0 / Radius, std::abs(Own));
 	};
-	if (abrupt(Design.start_radius, Design.start_turn, curvature_at(false)))
+	// a design asked to go on from the curve where its curve turns its way leaves the end where it doesn't to the one laying it: it eases
+	// out of the curve there, or keeps the jump at the end of the diverging track of a switch, as the switch has it at its start
+	if (false == Design.start_curved && abrupt(Design.start_radius, Design.start_turn, curvature_at(false)))
 		r.warnings.emplace_back(format(STR_C("The adjoining track at the start is curved (R %.0f m), the curvature changes abruptly"), Design.start_radius));
-	if (abrupt(Design.end_radius, Design.end_turn, curvature_at(true)))
+	if (false == Design.end_curved && abrupt(Design.end_radius, Design.end_turn, curvature_at(true)))
 		r.warnings.emplace_back(format(STR_C("The adjoining track at the end is curved (R %.0f m), the curvature changes abruptly"), Design.end_radius));
 	make_cants(Design, r);
 
@@ -1150,6 +1349,9 @@ result compute(design const &Design)
 	extended.end = along_end(Design.end, Design.end_direction, Design.end_grade, endextension);
 	extended.start_reserve = 0.0;
 	extended.end_reserve = 0.0;
+	// a curve going on from the adjoining track begins right at the end, which isn't moved; an end moved is on a straight
+	extended.start_curved = Design.start_curved && startextension == 0.0;
+	extended.end_curved = Design.end_curved && endextension == 0.0;
 	if (extended.vertices.size() >= 2)
 	{
 		extended.vertices.front().offset += startextension;
@@ -2861,11 +3063,90 @@ result ease_bends(design &Design, std::vector<char> const &Corners, corner_radii
 	auto const low{std::max(10.0, std::min(Radii.low, Radii.high))};
 	auto const high{std::max(low, Radii.high)};
 
+	// a bend at the start, or at the end, turning the way of the curve of the adjoining track goes on from it: its curve begins right
+	// there, as large as the bend makes it, with the transitions and the cant of the norms between it and the adjoining curve and out of
+	// it to the straight. Its size fixed so, the curves next to it share the straight with it as with a curve left as it is
+	std::vector<char> fixed(count, 0);
+	for (std::size_t k = 0; k < count; ++k)
+	{
+		if (false == corner(k) || (k > 0 && k + 1 < count))
+			continue;
+		auto const in{polygon[k + 1] - polygon[k]};
+		auto const out{polygon[k + 2] - polygon[k + 1]};
+		if (glm::length(in) < 1e-6 || glm::length(out) < 1e-6)
+			continue;
+		int const side{cross(in, out) > 0.0 ? 1 : -1};
+		auto const from{k == 0 && Design.start_curved && Design.start_radius > 0.0 && Design.start_turn == side};
+		auto const to{k + 1 == count && Design.end_curved && Design.end_radius > 0.0 && Design.end_turn == side && false == from};
+		if (false == from && false == to)
+			continue;
+		// the bend alone between the end and the point after it, or before it, the straight there as long as the curve wants
+		auto single{Design};
+		single.vertices.assign(1, vertex{});
+		if (from)
+		{
+			single.end = {polygon[k + 2].x, Design.end.y, polygon[k + 2].y};
+			single.end_direction = glm::normalize(out);
+			single.end_curved = false;
+			single.end_reserve = 1e4;
+		}
+		else
+		{
+			single.start = {polygon[k].x, Design.start.y, polygon[k].y};
+			single.start_direction = glm::normalize(in);
+			single.start_curved = false;
+			single.start_reserve = 1e4;
+		}
+		auto const adjoining{from ? 1.0 / Design.start_radius : 1.0 / Design.end_radius};
+		auto const adjoiningcant{std::max(0.0, from ? Design.start_cant : Design.end_cant)};
+		auto &shape{single.vertices.front()};
+		shape.radius = std::max(1.0, Design.vertices[k].radius);
+		std::optional<curve_report> made;
+		// the transitions and the cant follow the radius, which the transitions move a little
+		for (int pass = 0; pass < 6; ++pass)
+		{
+			auto const allowed{std::max(1.0, std::min(speed, speed_limit(shape.radius, norms)))};
+			auto const recommended{recommend(allowed, shape.radius, norms)};
+			auto const slower{std::max(1.0, std::min(allowed, speed_limit(1.0 / adjoining, norms)))};
+			auto const along{recommended.transition};
+			auto const cant{ramped_cant(recommended.cant, along, allowed, norms)};
+			auto const between{between_curves(slower, adjoining, adjoiningcant, 1.0 / shape.radius, cant, norms)};
+			(from ? shape.transition_in : shape.transition_out) = between;
+			(from ? shape.transition_out : shape.transition_in) = along;
+			shape.cant = cant;
+			auto const laid{compute(single)};
+			if (false == laid.valid || laid.curves.size() != 1)
+			{
+				made.reset();
+				break;
+			}
+			auto const previous{shape.radius};
+			made = laid.curves.front();
+			shape.radius = made->radius;
+			if (std::abs(shape.radius - previous) < 0.01)
+				break;
+		}
+		if (false == made.has_value())
+			continue;
+		auto &vertex{Design.vertices[k]};
+		vertex.spirals = false;
+		vertex.radius = shape.radius;
+		vertex.transition_in = shape.transition_in;
+		vertex.transition_out = shape.transition_out;
+		vertex.cant = shape.cant;
+		vertex.reverse_turn = false;
+		vertex.compound = false;
+		vertex.share = 1.0;
+		vertex.arcs.clear();
+		fixed[k] = 1;
+		kept[k] = {made->tangent_in, made->tangent_out};
+	}
+
 	// the shapes each bend can take, the best first
 	std::vector<std::vector<corner_shape>> ladders(count);
 	for (std::size_t k = 0; k < count; ++k)
 	{
-		if (false == corner(k))
+		if (false == corner(k) || fixed[k] != 0)
 			continue;
 		auto const in{polygon[k + 1] - polygon[k]};
 		auto const out{polygon[k + 2] - polygon[k + 1]};
@@ -2955,7 +3236,7 @@ result ease_bends(design &Design, std::vector<char> const &Corners, corner_radii
 	auto const reach_of = [&](std::size_t const K, bool const Out) {
 		if (false == ladders[K].empty())
 			return ladders[K][picks[K]].reach;
-		return corner(K) ? 0.0 : kept[K][Out ? 1 : 0];
+		return corner(K) && fixed[K] == 0 ? 0.0 : kept[K][Out ? 1 : 0];
 	};
 	auto const best_within = [&](std::size_t const K, double const Room) {
 		auto const &ladder{ladders[K]};
@@ -3097,6 +3378,9 @@ result ease_corners(design &Design, std::vector<char> &Corners, corner_radii con
 				base.end_direction = glm::normalize(polygon[m + 2] - polygon[m + 1]);
 				base.start_reserve = 0.0;
 				base.end_reserve = 0.0;
+				// the curve of the row goes on from the curve of the adjoining track where the row begins at the start, or ends at the end
+				base.start_curved = Design.start_curved && k == 0;
+				base.end_curved = Design.end_curved && m + 1 == static_cast<int>(Design.vertices.size());
 				std::vector<glm::dvec2> points(polygon.begin() + k + 1, polygon.begin() + m + 2);
 				// two bends don't show the curve between them: the curve goes through the line their two curves laid, with no
 				// straight between them, from where the first begins to where the second ends, the straights either side its room
@@ -3120,6 +3404,8 @@ result ease_corners(design &Design, std::vector<char> &Corners, corner_radii con
 					base.end_direction = glm::normalize(plan_of(after.direction));
 					base.start_reserve = from - (first > 0 ? curves[first - 1].to : 0.0);
 					base.end_reserve = (last + 1 < curves.size() ? curves[last + 1].from : line.length) - to;
+					base.start_curved = base.start_curved && from < 1e-6;
+					base.end_curved = base.end_curved && to > line.length - 1e-6;
 					within = kPointsWithin;
 				}
 				auto const fit{Fit ? Fit(base, points) : std::optional<trace_stretch>{fit_trace_stretch(base, points, 0, false)}};
@@ -3185,6 +3471,16 @@ std::optional<trace_stretch> stretch_of(design const &Design, std::vector<glm::d
 	stretch.vertices = Design.vertices;
 	for (std::size_t k = 0; k < stretch.vertices.size() && k < laid.vertices.size(); ++k)
 		stretch.vertices[k].position = laid.vertices[k];
+	// a curve going on from an adjoining one with the radii it was laid with, which begin it at the end
+	for (auto const &curve : laid.curves)
+		if ((curve.curvature_in > 0.0 || curve.curvature_out > 0.0) && curve.vertex >= 0 && curve.vertex < static_cast<int>(stretch.vertices.size()))
+		{
+			auto &vertex{stretch.vertices[curve.vertex]};
+			auto const scale{curve.radius / std::max(1.0, vertex.radius)};
+			vertex.radius = curve.radius;
+			for (auto &arc : vertex.arcs)
+				arc.radius *= scale;
+		}
 	double sum{0.0};
 	for (auto const &projection : project(laid, Points))
 	{
@@ -3196,15 +3492,12 @@ std::optional<trace_stretch> stretch_of(design const &Design, std::vector<glm::d
 	return stretch;
 }
 
-// how far the points are from the line the design lays, a point clicked by mistake far off pulling it less than the square of its
-// departure would
-bool stretch_residuals(design Trial, std::vector<glm::dvec2> const &Points, std::vector<double> &Residuals)
+// how far the points are from the line laid, a point clicked by mistake far off pulling it less than the square of its departure would
+bool laid_residuals(result const &Laid, std::vector<glm::dvec2> const &Points, std::vector<double> &Residuals)
 {
-	Trial.norms.checked = false;
-	auto const laid{compute(Trial)};
-	if (false == laid.valid)
+	if (false == Laid.valid)
 		return false;
-	auto const line{sample_plan(laid, 0.0, laid.length, std::clamp(laid.length / 300.0, 0.5, 4.0))};
+	auto const line{sample_plan(Laid, 0.0, Laid.length, std::clamp(Laid.length / 300.0, 0.5, 4.0))};
 	Residuals.clear();
 	for (auto const &point : Points)
 	{
@@ -3215,11 +3508,19 @@ bool stretch_residuals(design Trial, std::vector<glm::dvec2> const &Points, std:
 	return true;
 }
 
+// the same for the line the design lays
+bool stretch_residuals(design Trial, std::vector<glm::dvec2> const &Points, std::vector<double> &Residuals)
+{
+	Trial.norms.checked = false;
+	return laid_residuals(compute(Trial), Points, Residuals);
+}
+
 // the same for a design of one compound curve, its shape made straight away as fit_between makes it, many times quicker than the whole
 // design laid: the fits of compound curves try it some thousand times
 bool compound_residuals(design const &Trial, std::vector<glm::dvec2> const &Points, std::vector<double> &Residuals)
 {
-	if (Trial.vertices.size() != 1 || false == Trial.vertices.front().compound || Trial.vertices.front().arcs.empty())
+	// a curve going on from an adjoining one is placed by its end, not by the vertex: laid as a whole
+	if (Trial.vertices.size() != 1 || false == Trial.vertices.front().compound || Trial.vertices.front().arcs.empty() || Trial.start_curved || Trial.end_curved)
 		return stretch_residuals(Trial, Points, Residuals);
 	glm::dvec2 corner;
 	if (false == tangent_intersection(Trial, corner))
@@ -3300,6 +3601,113 @@ void plain_curve(vertex &Vertex, double const Radius, double const Transition, d
 	Vertex.cant = Transition > 0.0 ? ramped_cant(recommend(allowed, Radius, Norms).cant, Transition, allowed, Norms) : 0.0;
 }
 
+// the cant of the norms for a curve going on from the curve of an adjoining track, or into it, as much as its transitions ramp: the one
+// to the straight from 0, the one between it and the adjoining curve from the cant of that one, which goes on into the arc with none
+double curved_cant(double const Radius, double const Between, double const Out, double const Adjoining, double const Speed, limits const &Norms)
+{
+	if (Between < 1.0)
+		return Adjoining;
+	auto const allowed{std::max(1.0, std::min(Speed, speed_limit(Radius, Norms)))};
+	auto const cant{ramped_cant(recommend(allowed, Radius, Norms).cant, Out, allowed, Norms)};
+	auto const reach{std::min(Between * 1000.0 / (Norms.ramp_factor * allowed), Norms.cant_rate * 3.6 * Between / allowed)};
+	if (std::abs(cant - Adjoining) <= reach)
+		return cant;
+	auto const ramped{cant > Adjoining ? Adjoining + std::floor(reach / 5.0) * 5.0 : Adjoining - std::floor(reach / 5.0) * 5.0};
+	return std::max(0.0, ramped);
+}
+
+// the transitions of the curve of the vertex going on from the curve of the adjoining track at the start, or into the one at the end,
+// following the points best: its radius the one which begins it there, its cant that of the norms as far as the transitions ramp it
+void fit_curved(design &Design, std::size_t const Vertex, std::vector<glm::dvec2> const &Points, bool const Fromstart)
+{
+	auto const speed{std::max(1.0, Design.speed)};
+	auto const fromstart{Fromstart};
+	auto const adjoining{std::max(kTraceRadiusMin, fromstart ? Design.start_radius : Design.end_radius)};
+	auto const adjoiningcant{std::max(0.0, fromstart ? Design.start_cant : Design.end_cant)};
+	auto const longest{longest_transition(speed, adjoining, Design.norms)};
+	// the radius is sought from the one laid last, a step of the fit moving it little
+	auto radius{adjoining};
+	// the square roots of the lengths of the transitions, between the curves and to the straight, a 30th of them: the step the fit takes
+	// its derivatives with moving the curve more than the chords the points are measured against do; one parameter: none between them,
+	// the curve going on at the radius of the adjoining one
+	constexpr double kScale{30.0};
+	auto const length_of = [](double const Parameter) { return kScale * kScale * Parameter * Parameter; };
+	auto const parameter_of = [](double const Length) { return std::sqrt(Length) / kScale; };
+	auto const shaped = [&](std::vector<double> const &Parameters, design &Trial) {
+		Trial = Design;
+		auto &curve{Trial.vertices[Vertex]};
+		curve = {curve.position, curve.offset, radius};
+		auto const between{Parameters.size() > 1 ? std::min(length_of(Parameters[0]), longest) : 0.0};
+		auto const out{std::min(length_of(Parameters.back()), longest)};
+		curve.transition_in = fromstart ? between : out;
+		curve.transition_out = fromstart ? out : between;
+		curve.cant = 0.0;
+	};
+	auto const laid_with = [&](result const &Laid) {
+		for (auto const &curve : Laid.curves)
+			if (curve.vertex == static_cast<int>(Vertex))
+				radius = curve.radius;
+	};
+	residuals_of const residuals{[&](std::vector<double> const &Parameters, std::vector<double> &Residuals) {
+		design trial;
+		shaped(Parameters, trial);
+		trial.norms.checked = false;
+		auto const laid{compute(trial)};
+		laid_with(laid);
+		return laid_residuals(laid, Points, Residuals);
+	}};
+	// the transition between the curves short or none, as where the curve goes on at the radius of the adjoining one, or as long as the
+	// one to the straight; this one as long as the norms ask for at the radius of the adjoining curve. The square roots of the lengths,
+	// a length of nought holding the step at nought
+	auto const allowed{std::max(1.0, std::min(speed, speed_limit(adjoining, Design.norms)))};
+	auto const out{std::clamp(recommend(allowed, adjoining, Design.norms).transition, 10.0, 0.9 * longest)};
+	std::vector<double> best;
+	auto lowest{std::numeric_limits<double>::max()};
+	for (auto const between : {2.0, 0.5 * out})
+	{
+		radius = adjoining;
+		std::vector<double> parameters{parameter_of(between), parameter_of(out)};
+		if (auto const cost{least_squares(parameters, residuals)}; cost < lowest)
+		{
+			lowest = cost;
+			best = parameters;
+		}
+	}
+	// the curve going on at the radius of the adjoining one, with no transition between them, where it keeps to the points about as well:
+	// a short transition the fit leaves only follows points clicked a little off
+	{
+		radius = adjoining;
+		std::vector<double> parameters{parameter_of(out)};
+		auto const cost{least_squares(parameters, residuals)};
+		auto const points{static_cast<double>(std::max<std::size_t>(1, Points.size()))};
+		// the radius it begins with the one of the adjoining curve, within 5 %, else the curvature would jump between them
+		design trial;
+		shaped(parameters, trial);
+		trial.norms.checked = false;
+		laid_with(compute(trial));
+		auto const along{std::abs(radius - adjoining) <= 0.05 * adjoining};
+		if (along && cost < std::numeric_limits<double>::max() && (best.empty() || std::sqrt(cost / points) <= std::sqrt(lowest / points) + 0.01))
+		{
+			lowest = cost;
+			best = parameters;
+		}
+	}
+	if (best.empty())
+		return;
+	design fitted;
+	shaped(best, fitted);
+	auto &curve{fitted.vertices[Vertex]};
+	curve.transition_in = std::round(curve.transition_in);
+	curve.transition_out = std::round(curve.transition_out);
+	auto const laid{compute(fitted)};
+	if (false == laid.valid)
+		return;
+	laid_with(laid);
+	curve.radius = radius;
+	curve.cant = fromstart ? curved_cant(radius, curve.transition_in, curve.transition_out, adjoiningcant, speed, fitted.norms) : curved_cant(radius, curve.transition_out, curve.transition_in, adjoiningcant, speed, fitted.norms);
+	Design = fitted;
+}
+
 // the radius and the length of the transitions of the curve of the vertex following the points best, the rest of the design kept: the
 // transitions of a line on the photo are what they are, the norms may have asked for others
 void fit_curve(design &Design, std::size_t const Vertex, std::vector<glm::dvec2> const &Points)
@@ -3572,7 +3980,29 @@ trace_stretch fit_trace_stretch(design const &Base, std::vector<glm::dvec2> cons
 		single.vertices.assign(1, vertex{});
 		auto &curve{single.vertices.front()};
 		curve.transition_in = curve.transition_out = curve.cant = 0.0;
-		if (auto const arc{fit_trace(single, 0, Points, 1)}; arc.valid)
+		// a curve going on from the curve of the adjoining track at the start, or into the one at the end, turning its way: the
+		// transitions the points show, the radius the one which begins it there; the radii of a compound curve where they're asked for
+		// or one doesn't keep to the points
+		int const side{cross(startdirection, enddirection) > 0.0 ? 1 : -1};
+		auto const fromstart{Base.start_curved && Base.start_radius > 0.0 && Base.start_turn == side};
+		auto const curved{fromstart || (Base.end_curved && Base.end_radius > 0.0 && Base.end_turn == side)};
+		if (curved)
+		{
+			curve.radius = fromstart ? Base.start_radius : Base.end_radius;
+			fit_curved(single, 0, Points, fromstart);
+			one = stretch_of(single, Points);
+			auto const loose{one.has_value() && (one->rms > kStretchClose || one->worst > kPointsWithin)};
+			if (one.has_value() && Radii != 1 && (Radii > 1 || loose))
+				if (auto const fit{fit_trace(single, 0, Points, Radii > 1 ? Radii : 2)}; fit.valid && fit.fitted.compound)
+				{
+					auto several{single};
+					several.vertices.front() = fit.fitted;
+					fit_compound(several, 0, Points);
+					if (auto const compound{stretch_of(several, Points)}; compound.has_value() && (Radii > 1 || compound->rms < 0.75 * one->rms))
+						one = compound;
+				}
+		}
+		else if (auto const arc{fit_trace(single, 0, Points, 1)}; arc.valid)
 		{
 			curve = arc.fitted;
 			fit_curve(single, 0, Points);
@@ -3695,8 +4125,10 @@ trace_stretch fit_trace_stretch(design const &Base, std::vector<glm::dvec2> cons
 			// none where a curve ran to the end of the radii tried, turns hardly at all, or doesn't fit between the straights: the
 			// points made the fit find two curves where they show one
 			auto const laid{compute(two)};
+			// a curve of the two going on from the curve of an adjoining track has its transitions tied together here, to the straight
+			// and between the curves alike: none such, the one curve going on from it is fitted on its own
 			auto const sound{laid.valid && laid.radius_warnings.empty() && laid.curves.size() == 2 && std::all_of(laid.curves.begin(), laid.curves.end(), [](curve_report const &Curve) {
-				return Curve.radius > 1.05 * kTraceRadiusMin && Curve.radius < 0.95 * kTraceRadiusMax && Curve.deflection > 0.25 * kPi / 180.0;
+				return Curve.radius > 1.05 * kTraceRadiusMin && Curve.radius < 0.95 * kTraceRadiusMax && Curve.deflection > 0.25 * kPi / 180.0 && Curve.curvature_in <= 0.0 && Curve.curvature_out <= 0.0;
 			})};
 			// one compound curve rather than two turning the same way with a short straight between them; two such only where the
 			// straight is long and they keep to the points much closer
diff --git a/editor/editorAlignment.hpp b/editor/editorAlignment.hpp
index 859e6864..da32cd16 100644
--- a/editor/editorAlignment.hpp
+++ b/editor/editorAlignment.hpp
@@ -98,6 +98,16 @@ struct design
 	// known; a design going on at the curvature of the adjoining track doesn't change it abruptly
 	int start_turn{0};
 	int end_turn{0};
+	// the curve of the first vertex goes on from the curve of the adjoining track at the start, where it turns its way, as a track laid on
+	// from a curved free end: it begins right at the start, with no straight before it, its transition in going from the curvature and
+	// the cant of the adjoining track (start_radius, start_turn, start_cant) to those of its first arc. The radii of its arcs are the
+	// ones which begin it there, the transitions and the shares as given. The same for the curve of the last vertex at the end; a curve
+	// of the only vertex goes on from the start alone
+	bool start_curved{false};
+	bool end_curved{false};
+	// mm, the cant of the adjoining track at the start and at the end, leaning into its turn
+	double start_cant{0.0};
+	double end_cant{0.0};
 	// length of the straight beyond the start and the end, which the curves can take over
 	double start_reserve{0.0};
 	double end_reserve{0.0};
@@ -175,6 +185,11 @@ struct curve_report
 	recommendation recommended;
 	bool spirals{false}; // two transition curves with no arc between them
 	double cant{0.0};
+	// the curvature and the cant of the curve of the adjoining track it goes on from at its start, and into at its end; 0 from a straight
+	double curvature_in{0.0};
+	double cant_in{0.0};
+	double curvature_out{0.0};
+	double cant_out{0.0};
 };
 
 struct profile_point
diff --git a/editor/editorAlignmentStore.cpp b/editor/editorAlignmentStore.cpp
index 5f6a73cc..b9b7f19d 100644
--- a/editor/editorAlignmentStore.cpp
+++ b/editor/editorAlignmentStore.cpp
@@ -130,7 +130,13 @@ void mark(scene::layer_handle const Layer)
 		lines.push_back(format("source %s origin %.4f shape %s speed %.1f", entry.source.c_str(), entry.origin, shape_name(design.shape), design.speed) + (entry.fit > 0.0 ? format(" fit %.3f", entry.fit) : std::string{}));
 		auto const startdirection{local_direction(context, design.start, design.start_direction)};
 		auto const enddirection{local_direction(context, design.end, design.end_direction)};
-		lines.push_back(format("ends %.9f %.9f %.9f %.9f %.6f %.6f %.3f %.3f", startdirection.x, startdirection.y, enddirection.x, enddirection.y, design.start_grade, design.end_grade, design.start_radius, design.end_radius));
+		auto ends{format("ends %.9f %.9f %.9f %.9f %.6f %.6f %.3f %.3f", startdirection.x, startdirection.y, enddirection.x, enddirection.y, design.start_grade, design.end_grade, design.start_radius, design.end_radius)};
+		// the sides the adjoining tracks turn to, and the curves going on from them with their cants, written since there are such
+		if (design.start_turn != 0 || design.end_turn != 0)
+			ends += format(" turns %d %d", design.start_turn, design.end_turn);
+		if (design.start_curved || design.end_curved)
+			ends += format(" curved %d %d %.1f %.1f", design.start_curved ? 1 : 0, design.end_curved ? 1 : 0, design.start_cant, design.end_cant);
+		lines.push_back(ends);
 		auto const &norms{design.norms};
 		lines.push_back(format("norms %.1f %.3f %.1f %.1f %.2f %.3f %.2f %.2f %.3f", norms.gauge, norms.unbalanced, norms.cant_max, norms.cant_rate, norms.ramp_factor, norms.jerk, norms.tangent_min_time, norms.arc_min, norms.arc_min_factor));
 		lines.push_back(format("pieces %d %.3f", design.transition_pieces, design.arc_piece_angle));
@@ -378,6 +384,16 @@ void read_part(record &Entry, std::string const &Keyword, std::istringstream &Li
 		Line >> startdirection.x >> startdirection.y >> enddirection.x >> enddirection.y >> design.start_grade >> design.end_grade >> design.start_radius >> design.end_radius;
 		design.start_direction = world_direction(Context, Context.to_local(design.start), startdirection);
 		design.end_direction = world_direction(Context, Context.to_local(design.end), enddirection);
+		for (std::string key; Line >> key;)
+		{
+			if (key == "turns")
+				Line >> design.start_turn >> design.end_turn;
+			if (int start{0}, end{0}; key == "curved" && Line >> start >> end >> design.start_cant >> design.end_cant)
+			{
+				design.start_curved = (start != 0);
+				design.end_curved = (end != 0);
+			}
+		}
 	}
 	else if (Keyword == "norms")
 	{
diff --git a/lang/editor_pl.po b/lang/editor_pl.po
index a630aa5e..9d0adcda 100644
--- a/lang/editor_pl.po
+++ b/lang/editor_pl.po
@@ -12152,3 +12152,39 @@ msgstr "Esc dwa razy przy układaniu"
 
 msgid "Drop the points clicked and not laid yet"
 msgstr "Porzuca kliknięte, jeszcze nieułożone punkty"
+
+# laying on from a curved free end: the curve next to it goes on from its curvature
+
+msgid "Vertex %zu: no curve goes on from the curve of the adjoining track (R %.0f m) to the straight after it"
+msgstr "Wierzchołek %zu: żaden łuk nie przejdzie od łuku przylegającego toru (R %.0f m) do prostej za nim"
+
+msgid "Vertex %zu: no curve goes on from the straight before it into the curve of the adjoining track (R %.0f m)"
+msgstr "Wierzchołek %zu: żaden łuk nie przejdzie od prostej przed nim w łuk przylegającego toru (R %.0f m)"
+
+msgid "Goes on from the curve of the track at the start (R %.0f m)"
+msgstr "Kontynuuje łuk toru na początku (R %.0f m)"
+
+msgid "Goes into the curve of the track at the end (R %.0f m)"
+msgstr "Przechodzi w łuk toru na końcu (R %.0f m)"
+
+msgid "The curve begins right at the end of the fragment, at the curvature of the track adjoining there, where it turns the same way; its radius is the one which begins it there, the transition at that end goes between the two curves"
+msgstr "Łuk zaczyna się dokładnie na końcu odcinka, z krzywizną przylegającego tam toru, jeśli skręca w tę samą stronę; jego promień to ten, przy którym zaczyna się właśnie tam, a krzywa przejściowa na tym końcu łączy oba łuki"
+
+msgid "goes on from R %.0f m of the track it starts at"
+msgstr "kontynuuje R %.0f m toru, od którego się zaczyna"
+
+msgid "goes on from R %.0f m of the track it starts at, a transition of %.0f m between them"
+msgstr "kontynuuje R %.0f m toru, od którego się zaczyna, z krzywą przejściową %.0f m między nimi"
+
+msgid "goes into R %.0f m of the track it ends at"
+msgstr "przechodzi w R %.0f m toru, na którym się kończy"
+
+msgid "goes into R %.0f m of the track it ends at, a transition of %.0f m between them"
+msgstr "przechodzi w R %.0f m toru, na którym się kończy, z krzywą przejściową %.0f m między nimi"
+
+msgid "Curve %d %s"
+msgstr "Łuk %d %s"
+
+msgid "Vertex %zu: the transition curve between the curve of the adjoining track and R %.0f m is shorter than the required %.0f m"
+msgstr "Wierzchołek %zu: krzywa przejściowa między łukiem przylegającego toru a R %.0f m jest krótsza niż wymagane %.0f m"
+
diff --git a/tests/unit/test_alignment.cpp b/tests/unit/test_alignment.cpp
index 3ebb3d54..9f1b33a7 100644
--- a/tests/unit/test_alignment.cpp
+++ b/tests/unit/test_alignment.cpp
@@ -3,6 +3,7 @@
 #include "editor/editorAlignment.hpp"
 
 #include <algorithm>
+#include <array>
 #include <cmath>
 #include <string>
 
@@ -67,6 +68,56 @@ std::vector<glm::dvec2> traced(alignment::result const &Line, double const Spaci
 	return points;
 }
 
+// a line from the origin along x through segments of the curvature going evenly from the first to the second (to the left positive) over
+// the length, as the end it comes to and the heading there; small steps of Simpson
+struct line_end {
+	glm::dvec2 position{0.0};
+	double heading{0.0};
+};
+line_end walked(std::vector<std::array<double, 3>> const &Segments) {
+	line_end end;
+	for (auto const &[from, to, length] : Segments) {
+		int const steps{std::max(2, static_cast<int>(std::ceil(length / 0.25)) * 2)};
+		auto const h{length / steps};
+		auto const angle = [&, from = from, to = to, length = length](double const S) { return end.heading + from * S + (to - from) * S * S / (2.0 * length); };
+		glm::dvec2 sum{0.0};
+		for (int i = 0; i <= steps; ++i) {
+			double const weight = (i == 0 || i == steps) ? 1.0 : (i % 2 ? 4.0 : 2.0);
+			sum += weight * glm::dvec2{std::cos(angle(i * h)), std::sin(angle(i * h))};
+		}
+		end.position += sum * (h / 3.0);
+		end.heading = angle(length);
+	}
+	return end;
+}
+
+// the curvature of the line at the chainage, positive to the left, from the headings half a metre either side
+double curvature_of(alignment::result const &Line, double const Chainage) {
+	auto const a{std::clamp(Chainage - 0.25, 0.0, Line.length)};
+	auto const b{std::clamp(Chainage + 0.25, 0.0, Line.length)};
+	auto const from{alignment::evaluate(Line, a).direction};
+	auto const to{alignment::evaluate(Line, b).direction};
+	return (std::atan2(to.z, to.x) - std::atan2(from.z, from.x)) / (b - a);
+}
+
+// a design from the origin along x, on from a curve to the left of the radius, to the straight the segments end at, 200 m along it; one
+// vertex where the straights meet
+alignment::design curved_from(double const Radius, std::vector<std::array<double, 3>> const &Segments, double const Speed) {
+	auto const end{walked(Segments)};
+	alignment::design design;
+	design.speed = Speed;
+	design.start = {0.0, 0.0, 0.0};
+	design.start_direction = heading(0.0);
+	auto const beyond{end.position + heading(end.heading) * 200.0};
+	design.end = {beyond.x, 0.0, beyond.y};
+	design.end_direction = heading(end.heading);
+	design.start_radius = Radius;
+	design.start_turn = 1;
+	design.start_curved = true;
+	design.vertices.emplace_back();
+	return design;
+}
+
 // the stretch traced as the lay tool asks for it: from the start of the line along its first straight, to the last point along the
 // straight through the last two
 alignment::design stretch_base(alignment::design const &Line, std::vector<glm::dvec2> const &Points) {
@@ -468,3 +519,231 @@ TEST_CASE("alignment: a cant ramp moved off the transition curve onto the straig
 	auto const turned{std::max_element(paths.begin(), paths.end(), [](segment_data const &A, segment_data const &B) { return std::abs(A.rolls[1]) < std::abs(B.rolls[1]); })};
 	CHECK(std::abs(turned->rolls[1]) == doctest::Approx(glm::degrees(std::asin(60.0 / design.norms.gauge))).epsilon(1e-3));
 }
+
+TEST_CASE("alignment: a curve laid on from the diverging track of a switch begins at its end with its curvature") {
+	auto const adjoining = [](alignment::result const &Line) {
+		return std::any_of(Line.warnings.begin(), Line.warnings.end(), [](std::string const &Warning) { return Warning.find("adjoining track at the start") != std::string::npos; });
+	};
+	// R 300 on for 100 m, then a transition of 40 m out to the straight, at 40 km/h
+	auto design{curved_from(300.0, {{1.0 / 300.0, 1.0 / 300.0, 100.0}, {1.0 / 300.0, 0.0, 40.0}}, 40.0)};
+	auto &vertex{design.vertices.front()};
+	vertex.radius = 1000.0;
+	vertex.transition_in = 0.0;
+	vertex.transition_out = 40.0;
+	auto const line{alignment::compute(design)};
+	REQUIRE(line.valid);
+	REQUIRE(line.curves.size() == 1);
+	auto const &curve{line.curves.front()};
+	// the radius is the one which begins the curve at the start, whatever was given
+	CHECK(curve.radius == doctest::Approx(300.0).epsilon(1e-3));
+	CHECK(curve.curvature_in == doctest::Approx(1.0 / 300.0));
+	// no straight before it: the curvature of the switch from the very start, which is where it was
+	CHECK(line.elements.front().kind != alignment::element_kind::straight);
+	CHECK(curvature_of(line, 0.25) == doctest::Approx(1.0 / 300.0).epsilon(0.01));
+	auto const start{alignment::evaluate(line, 0.0)};
+	CHECK(std::abs(start.position.x) < 1e-6);
+	CHECK(std::abs(start.position.z) < 1e-6);
+	CHECK(std::abs(start.direction.z) < 1e-6);
+	CHECK_FALSE(adjoining(line));
+	CHECK(alignment::meets_norms(curve, design));
+	// the line through the end as given
+	auto const end{alignment::evaluate(line, line.length)};
+	CHECK(glm::distance(glm::dvec2{end.position.x, end.position.z}, glm::dvec2{design.end.x, design.end.z}) < 1e-3);
+
+	// the track before turning the other way: the curve from a straight, the jump of the curvature left to the one laying it, which eases
+	// out of the curve there; a design not asked to go on from it, as the plan of a line laid before, warns of it
+	auto other{design};
+	other.start_turn = -1;
+	auto const jump{alignment::compute(other)};
+	REQUIRE(jump.valid);
+	CHECK(jump.curves.front().curvature_in == doctest::Approx(0.0));
+	CHECK_FALSE(adjoining(jump));
+	other.start_curved = false;
+	CHECK(adjoining(alignment::compute(other)));
+}
+
+TEST_CASE("alignment: the cant of the curved track adjoining goes on into the curve with no transition between them") {
+	auto design{curved_from(600.0, {{1.0 / 600.0, 1.0 / 600.0, 150.0}, {1.0 / 600.0, 0.0, 80.0}}, 100.0)};
+	design.start_cant = 60.0;
+	auto &vertex{design.vertices.front()};
+	vertex.radius = 600.0;
+	vertex.transition_out = 80.0;
+	vertex.cant = 100.0;
+	auto const line{alignment::compute(design)};
+	REQUIRE(line.valid);
+	// the cant of the track adjoining from the very start, ramped out along the transition to the straight
+	CHECK(alignment::evaluate(line, 0.0).cant == doctest::Approx(60.0));
+	CHECK(alignment::evaluate(line, 50.0).cant == doctest::Approx(60.0));
+	auto const out{line.elements.back().kind == alignment::element_kind::straight ? line.elements[line.elements.size() - 2] : line.elements.back()};
+	CHECK(alignment::evaluate(line, out.chainage + out.length * 0.5).cant == doctest::Approx(30.0).epsilon(0.02));
+	CHECK(alignment::evaluate(line, out.chainage + out.length + 1.0).cant == doctest::Approx(0.0));
+	REQUIRE(line.ramps.size() == 1);
+	CHECK(line.ramps.front().from == doctest::Approx(out.chainage));
+	// the paths roll with the cant from the first one
+	auto const paths{alignment::pieces(line, design, alignment::minimum_pieces(line, design))};
+	REQUIRE_FALSE(paths.empty());
+	CHECK(paths.front().rolls[0] == doctest::Approx(glm::degrees(std::asin(60.0 / design.norms.gauge))).epsilon(1e-3));
+}
+
+TEST_CASE("alignment: a curve traced on from the diverging track of a switch keeps its curvature from the start") {
+	// the curve on the photo: R 300 from the end of the switch for 80 m, a transition of 25 m out, then the straight, at 40 km/h
+	auto truth{curved_from(300.0, {{1.0 / 300.0, 1.0 / 300.0, 80.0}, {1.0 / 300.0, 0.0, 25.0}}, 40.0)};
+	auto &vertex{truth.vertices.front()};
+	vertex.radius = 300.0;
+	vertex.transition_out = 25.0;
+	auto const line{alignment::compute(truth)};
+	REQUIRE(line.valid);
+	auto const points{traced(line, 10.0, 0.02)};
+
+	auto const base{stretch_base(truth, points)};
+	auto const fit{alignment::fit_trace_stretch(base, points, 0, true)};
+
+	REQUIRE(fit.valid);
+	REQUIRE(fit.vertices.size() == 1);
+	auto const &curve{fit.vertices.front()};
+	CHECK(curve.radius == doctest::Approx(300.0).epsilon(0.02));
+	CHECK(curve.transition_in < 8.0);
+	CHECK(curve.transition_out == doctest::Approx(25.0).epsilon(0.2));
+	CHECK(fit.rms < 0.03);
+	// clicked exactly, the diverging track read as R 300.9 as the editor reads a switch: the curve goes on at its radius with no transition
+	// between them and with the cant of the switch, none
+	auto const exact{traced(line, 10.0, 0.0)};
+	auto exactbase{stretch_base(truth, exact)};
+	exactbase.start_radius = 300.9;
+	auto const along{alignment::fit_trace_stretch(exactbase, exact, 0, true)};
+	REQUIRE(along.valid);
+	REQUIRE(along.vertices.size() == 1);
+	CHECK(along.vertices.front().transition_in == doctest::Approx(0.0));
+	CHECK(along.vertices.front().transition_out == doctest::Approx(25.0).epsilon(0.05));
+	CHECK(along.vertices.front().radius == doctest::Approx(300.0).epsilon(0.005));
+	CHECK(along.vertices.front().cant == doctest::Approx(0.0));
+	CHECK(along.rms < 0.005);
+	// laid as fitted: the curvature of the switch at the very start
+	auto laid{base};
+	laid.vertices = fit.vertices;
+	auto const shape{alignment::compute(laid)};
+	REQUIRE(shape.valid);
+	CHECK(shape.elements.front().kind != alignment::element_kind::straight);
+	CHECK(curvature_of(shape, 0.25) == doctest::Approx(1.0 / 300.0).epsilon(0.02));
+
+	// from a track turning the other way the curve is fitted from a straight, as before
+	auto other{base};
+	other.start_turn = -1;
+	auto const straight{alignment::fit_trace_stretch(other, points, 0, true)};
+	REQUIRE(straight.valid);
+	REQUIRE_FALSE(straight.vertices.empty());
+	auto apart{other};
+	apart.vertices = straight.vertices;
+	auto const from{alignment::compute(apart)};
+	REQUIRE(from.valid);
+	CHECK(from.curves.front().curvature_in == doctest::Approx(0.0));
+}
+
+TEST_CASE("alignment: a curve traced on from a curved free end through a transition into a larger radius") {
+	// R 300 at the free end, a transition of 30 m into R 500 for 60 m, 40 m out to the straight, at 60 km/h
+	auto truth{curved_from(300.0, {{1.0 / 300.0, 1.0 / 500.0, 30.0}, {1.0 / 500.0, 1.0 / 500.0, 60.0}, {1.0 / 500.0, 0.0, 40.0}}, 60.0)};
+	auto &vertex{truth.vertices.front()};
+	vertex.radius = 500.0;
+	vertex.transition_in = 30.0;
+	vertex.transition_out = 40.0;
+	auto const line{alignment::compute(truth)};
+	REQUIRE(line.valid);
+	REQUIRE(line.curves.size() == 1);
+	CHECK(line.curves.front().radius == doctest::Approx(500.0).epsilon(1e-3));
+
+	// clicked exactly, the curve found again
+	auto const exact{traced(line, 10.0, 0.0)};
+	auto const fit{alignment::fit_trace_stretch(stretch_base(truth, exact), exact, 0, true)};
+	REQUIRE(fit.valid);
+	REQUIRE(fit.vertices.size() == 1);
+	auto const &curve{fit.vertices.front()};
+	CHECK(curve.radius == doctest::Approx(500.0).epsilon(0.01));
+	CHECK(curve.transition_in == doctest::Approx(30.0).epsilon(0.05));
+	CHECK(curve.transition_out == doctest::Approx(40.0).epsilon(0.05));
+	CHECK(fit.rms < 0.01);
+
+	// clicked 2 cm off: the straight after the curve, through the last two points, a little off too, the curve keeps to the points as well
+	auto const points{traced(line, 10.0, 0.02)};
+	auto const noisy{alignment::fit_trace_stretch(stretch_base(truth, points), points, 0, true)};
+	REQUIRE(noisy.valid);
+	REQUIRE(noisy.vertices.size() == 1);
+	CHECK(noisy.vertices.front().radius == doctest::Approx(500.0).epsilon(0.03));
+	CHECK(noisy.rms < 0.025);
+}
+
+TEST_CASE("alignment: a bend clicked ahead of a curved free end, turning its way, is eased with a curve going on from it") {
+	alignment::design design;
+	design.speed = 60.0;
+	design.start_direction = heading(0.0);
+	design.start_radius = 300.0;
+	design.start_turn = 1;
+	design.start_curved = true;
+	// the bend 150 m ahead, 20 degrees to the left, the end 300 m after it
+	alignment::vertex bend;
+	bend.position = {150.0, 0.0};
+	design.vertices.push_back(bend);
+	auto const end{bend.position + heading(20.0 * pi / 180.0) * 300.0};
+	design.end = {end.x, 0.0, end.y};
+	design.end_direction = heading(20.0 * pi / 180.0);
+	std::vector<char> corners{1};
+	auto const line{alignment::ease_corners(design, corners, {3000.0, 6000.0})};
+
+	REQUIRE(line.valid);
+	REQUIRE(line.curves.size() == 1);
+	auto const &curve{line.curves.front()};
+	CHECK(line.elements.front().kind != alignment::element_kind::straight);
+	CHECK(curvature_of(line, 0.25) == doctest::Approx(1.0 / 300.0).epsilon(0.02));
+	// all of the straight before the bend taken by the curve, larger than the one it goes on from, through a transition between them
+	CHECK(curve.tangent_in == doctest::Approx(150.0).epsilon(1e-4));
+	CHECK(curve.radius > 400.0);
+	CHECK(curve.transition_in > 5.0);
+	CHECK(alignment::meets_norms(curve, design));
+	CHECK(line.vertices.front().x == doctest::Approx(150.0));
+	CHECK(std::abs(line.vertices.front().y) < 1e-9);
+	// the design keeps the radius it's laid with
+	CHECK(design.vertices.front().radius == doctest::Approx(curve.radius).epsilon(1e-6));
+
+	// a second bend after it: the curve going on from the free end keeps its size, the next one makes room for it
+	auto two{design};
+	two.vertices = {bend, bend};
+	two.vertices[1].position = bend.position + heading(20.0 * pi / 180.0) * 220.0;
+	auto const after{two.vertices[1].position + heading(-5.0 * pi / 180.0) * 300.0};
+	two.end = {after.x, 0.0, after.y};
+	two.end_direction = heading(-5.0 * pi / 180.0);
+	two.vertices.front().offset = 150.0;
+	two.vertices.back().offset = 300.0;
+	std::vector<char> both{1, 1};
+	auto const pair{alignment::ease_corners(two, both, {3000.0, 6000.0})};
+	REQUIRE(pair.valid);
+	REQUIRE(pair.curves.size() == 2);
+	CHECK(pair.curves[0].radius == doctest::Approx(curve.radius).epsilon(1e-3));
+	CHECK(pair.curves[0].tangent_out + pair.curves[1].tangent_in <= 220.0 + 1e-3);
+	CHECK(curvature_of(pair, 0.25) == doctest::Approx(1.0 / 300.0).epsilon(0.02));
+}
+
+TEST_CASE("alignment: a curve laid into a curved free end ends at it with its curvature") {
+	// a straight of 100 m, a transition of 40 m into R 400 to the right, the arc 60 m on to the free end
+	auto const end{walked({{0.0, 0.0, 100.0}, {0.0, -1.0 / 400.0, 40.0}, {-1.0 / 400.0, -1.0 / 400.0, 60.0}})};
+	alignment::design design;
+	design.speed = 80.0;
+	design.start_direction = heading(0.0);
+	design.end = {end.position.x, 0.0, end.position.y};
+	design.end_direction = heading(end.heading);
+	design.end_radius = 400.0;
+	design.end_turn = -1;
+	design.end_curved = true;
+	alignment::vertex vertex;
+	vertex.radius = 2000.0;
+	vertex.transition_in = 40.0;
+	design.vertices.push_back(vertex);
+	auto const line{alignment::compute(design)};
+	REQUIRE(line.valid);
+	REQUIRE(line.curves.size() == 1);
+	CHECK(line.curves.front().radius == doctest::Approx(400.0).epsilon(1e-3));
+	CHECK(line.curves.front().curvature_out == doctest::Approx(1.0 / 400.0));
+	CHECK(line.elements.back().kind != alignment::element_kind::straight);
+	CHECK(curvature_of(line, line.length - 0.25) == doctest::Approx(-1.0 / 400.0).epsilon(0.01));
+	auto const last{alignment::evaluate(line, line.length)};
+	CHECK(glm::distance(glm::dvec2{last.position.x, last.position.z}, end.position) < 1e-3);
+	CHECK(std::none_of(line.warnings.begin(), line.warnings.end(), [](std::string const &Warning) { return Warning.find("adjoining track at the end") != std::string::npos; }));
+}