JuliaManifolds · kellertuer · Jun 9, 2026 · Jun 9, 2026 · Jun 9, 2026 · Jun 9, 2026
diff --git a/Changelog.md b/Changelog.md
@@ -6,6 +6,12 @@ The file was started with Version `0.4`.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.40] unreleased
+
+### Fixed
+
+* miscellaneous broken links in the documentation. (#614)
+
 ## [0.5.39] June 3, 2026
 
 ### Fixed

diff --git a/docs/src/helpers/exports.md b/docs/src/helpers/exports.md
@@ -1,6 +1,6 @@
 # [Exports](@id sec-exports)
 
-Exports aim to provide a consistent generation of images of your results. For example if you [record](@ref subsec-record-states) the trace your algorithm walks on the [Sphere](https://juliamanifolds.github.io/Manifolds.jl/stable/manifolds/sphere.html), you can easily export this trace to a rendered image using [`asymptote_export_S2_signals`](@ref) and render the result with [Asymptote](https://sourceforge.net/projects/asymptote/).
+Exports aim to provide a consistent generation of images of your results. For example if you [record](@ref subsec-record-states) the trace your algorithm walks on the [Sphere](https://juliamanifolds.github.io/Manifolds.jl/stable/manifolds/sphere/), you can easily export this trace to a rendered image using [`asymptote_export_S2_signals`](@ref) and render the result with [Asymptote](https://sourceforge.net/projects/asymptote/).
 Despite these, you can always [record](@ref subsec-record-states) values during your iterations,
 and export these, for example to `csv`.
 

diff --git a/docs/src/index.md b/docs/src/index.md
@@ -89,7 +89,7 @@ Together they form a [plan](plans/index.md).
 
 This project is build upon [ManifoldsBase.jl](@extref ManifoldsBase :doc:`index`), a generic interface to implement manifolds. Certain functions are extended for specific manifolds from [Manifolds.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/), but all other manifolds from that package can be used here, too.
 
-The notation in the documentation aims to follow the same [notation](https://juliamanifolds.github.io/Manifolds.jl/stable/misc/notation.html) from these packages.
+The notation in the documentation aims to follow the same [notation](https://juliamanifolds.github.io/Manifolds.jl/stable/misc/notation/) from these packages.
 
 ### Visualization
 
@@ -106,4 +106,4 @@ which are both available online for free
 ```@bibliography
 Pages = ["index.md"]
 Canonical=false
-```
+```
diff --git a/docs/src/notation.md b/docs/src/notation.md
@@ -1,6 +1,6 @@
 # Notation
 
-In this package,the notation introduced in [Manifolds.jl Notation](https://juliamanifolds.github.io/Manifolds.jl/latest/misc/notation.html) is used
+In this package, the notation introduced in [Manifolds.jl Notation](https://juliamanifolds.github.io/Manifolds.jl/latest/misc/notation/) is used
 with the following additional parts.
 
 | Symbol | Description | Also used | Comment |

diff --git a/docs/src/solvers/NelderMead.md b/docs/src/solvers/NelderMead.md
@@ -35,4 +35,4 @@ The [`NelderMead`](@ref) solver requires the following functions of a manifold t
 * An [`inverse_retract!`](@extref ManifoldsBase :doc:`retractions`)`(M, X, p, q)`; it is recommended to set the [`default_inverse_retraction_method`](@extref `ManifoldsBase.default_inverse_retraction_method-Tuple{AbstractManifold}`) to a favourite retraction. If this default is set, a `inverse_retraction_method=` does not have to be specified.
 * The [`distance`](@extref `ManifoldsBase.distance-Tuple{AbstractManifold, Any, Any}`)`(M, p, q)` when using the default stopping criterion, which includes [`StopWhenPopulationConcentrated`](@ref).
 * Within the default initialization [`rand`](@extref Base.rand-Tuple{AbstractManifold})`(M)` is used to generate the initial population
-* A [`mean`](https://juliamanifolds.github.io/Manifolds.jl/stable/features/statistics.html#Statistics.mean-Tuple{AbstractManifold,%20AbstractVector,%20AbstractVector,%20ExtrinsicEstimation})`(M, population)` has to be available, for example by loading [`Manifolds.jl`](https://juliamanifolds.github.io/Manifolds.jl/stable/) and its [statistics](https://juliamanifolds.github.io/Manifolds.jl/stable/features/statistics.html) tools
+* A [`mean`](https://juliamanifolds.github.io/Manifolds.jl/stable/features/statistics/#Statistics.mean-Tuple{AbstractManifold,%20AbstractVector,%20AbstractVector,%20ExtrinsicEstimation})`(M, population)` has to be available, for example by loading [`Manifolds.jl`](https://juliamanifolds.github.io/Manifolds.jl/stable/) and its [statistics](https://juliamanifolds.github.io/Manifolds.jl/stable/features/statistics/) tools
diff --git a/tutorials/CountAndCache.qmd b/tutorials/CountAndCache.qmd
@@ -10,7 +10,7 @@ introductory tutorial [🏔️ Get started with Manopt.jl](getstarted.md).
 ## Introduction
 
 There are surely many ways to keep track for example of how often the cost function is called,
-for example with a [functor](https://docs.julialang.org/en/v1/manual/methods/#Function-like-objects), as we used in an example in [How to Record Data](https://manoptjl.org/stable/tutorials/HowtoRecord.html)
+for example with a [functor](https://docs.julialang.org/en/v1/manual/methods/#Function-like-objects), as we used in an example in [How to Record Data](https://manoptjl.org/stable/tutorials/HowToRecord/)
 
 ```{julia}
 #| eval: false
@@ -357,4 +357,4 @@ Pkg.status()
 #| output: asis
 using Dates
 println("This tutorial was last rendered $(Dates.format(now(), "U d, Y, HH:MM:SS")).");
-```
+```
diff --git a/tutorials/EmbeddingObjectives.qmd b/tutorials/EmbeddingObjectives.qmd
@@ -35,7 +35,7 @@ using LinearAlgebra, Random, Colors, Plots
 Random.seed!(123)
 ```
 
-We consider the cost function on the [`Grassmann`](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/grassmann.html) manifold given by
+We consider the cost function on the [`Grassmann`](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/grassmann/) manifold given by
 
 ```{julia}
 n = 5
@@ -211,4 +211,4 @@ Pkg.status()
 #| output: asis
 using Dates
 println("This tutorial was last rendered $(Dates.format(now(), "U d, Y, HH:MM:SS")).");
-```
+```
diff --git a/tutorials/HowToRecord.qmd b/tutorials/HowToRecord.qmd
@@ -55,7 +55,7 @@ grad_f(M, p) = sum(1 / n * grad_distance.(Ref(M), data, Ref(p)))
 
 ## First examples
 
-For the high level interfaces of the solvers, like [`gradient_descent`](https://manoptjl.org/stable/solvers/gradient_descent.html) we have to set `return_state` to `true` to obtain the whole [solver state](https://manoptjl.org/stable/plans/state/) and not only the resulting minimizer.
+For the high level interfaces of the solvers, like [`gradient_descent`](https://manoptjl.org/stable/solvers/gradient_descent/) we have to set `return_state` to `true` to obtain the whole [solver state](https://manoptjl.org/stable/plans/state/) and not only the resulting minimizer.
 
 Then we can easily use the `record=` option to add recorded values. This keyword accepts [`RecordAction`](https://manoptjl.org/stable/plans/record/#Manopt.RecordAction)s
 as well as several symbols as shortcuts, for example `:Cost` to record the cost, or if your options have a field `f`, `:f` would record that entry.
@@ -118,7 +118,7 @@ To illustrate a complicated example let's record:
 * the iteration number, cost and gradient field, but only every sixth iteration;
 * the iteration at which we stop.
 
-We first generate the problem and the state, to also illustrate the low-level works when not using the high-level interface [`gradient_descent`](https://manoptjl.org/stable/solvers/gradient_descent.html).
+We first generate the problem and the state, to also illustrate the low-level works when not using the high-level interface [`gradient_descent`](https://manoptjl.org/stable/solvers/gradient_descent/).
 
 ```{julia}
 p = DefaultManoptProblem(M, ManifoldGradientObjective(f, grad_f))
@@ -397,4 +397,4 @@ Pkg.status()
 #| output: asis
 using Dates
 println("This tutorial was last rendered $(Dates.format(now(), "U d, Y, HH:MM:SS")).");
-```
+```
diff --git a/tutorials/ImplementOwnManifold.qmd b/tutorials/ImplementOwnManifold.qmd
@@ -12,7 +12,7 @@ CurrentModule = Manopt
 When you have used a few solvers from [`Manopt.jl`](https://manoptjl.org/) for example like in the opening
 tutorial [🏔️ Get started with Manopt.jl](getstarted.md)
 and also familiarized yourself with how to work with manifolds in general at
-[🚀 Get Started with `Manifolds.jl`](https://juliamanifolds.github.io/Manifolds.jl/stable/tutorials/getstarted.html),
+[🚀 Get Started with `Manifolds.jl`](https://juliamanifolds.github.io/Manifolds.jl/stable/tutorials/getstarted/),
 you might come across the point that you want to
 ``[implementing a manifold](@extref :doc:`tutorials/implement-a-manifold`)``{=commonmark}
 yourself and use it within [`Manopt.jl`](https://manoptjl.org/).
@@ -112,7 +112,7 @@ pts = [ r/norm(p) .* p for p in pts]
 
 Then, before starting with optimization, we need the distance on the manifold,
 to define the cost function, as well as the logarithmic map to defined the gradient.
-For both, we here use the “lazy” approach of using the [Sphere](https://juliamanifolds.github.io/Manifolds.jl/stable/manifolds/sphere.html) as a fallback.
+For both, we here use the “lazy” approach of using the [Sphere](https://juliamanifolds.github.io/Manifolds.jl/stable/manifolds/sphere/) as a fallback.
 Finally, we have to provide information about how points and tangent vectors are stored on the
 manifold by implementing their ``[`representation_size`](@extref `ManifoldsBase.representation_size-Tuple{AbstractManifold}`)``{=commonmark} function, which is often required when allocating memory.
 While we could
@@ -141,7 +141,7 @@ grad_f(M,q) = sum( - log(M, q, p) for p in pts)
 
 The documentation usually lists the necessary functions in a
 section “Technical Details” close to the end of the documentation of a solver,
-for our case that is [The gradient descent's Technical Details](https://manoptjl.org/stable/solvers/gradient_descent.html#Technical-Details),
+for our case that is [The gradient descent's Technical Details](https://manoptjl.org/stable/solvers/gradient_descent/#sec-gradient-descent-technical-details),
 
 They list all details, but we can start even step by step here if we are a bit careful.
 
@@ -243,7 +243,7 @@ But we for example automatically also get the possibility to obtain debug inform
 gradient_descent(M, f, grad_f, p0; debug = [:Iteration, :Cost, :Stepsize, 25, :GradientNorm, :Stop, "\n"]);
 ```
 
-see [How to Print Debug Output](https://manoptjl.org/stable/tutorials/HowToDebug.html)
+see [How to Print Debug Output](https://manoptjl.org/stable/tutorials/HowToDebug/)
 for more details.
 
 ## Technical details
@@ -271,4 +271,4 @@ println("This tutorial was last rendered $(Dates.format(now(), "U d, Y, HH:MM:SS
 Pages = ["ImplementOwnManifold.md"]
 Canonical=false
 ```
-````
+````
diff --git a/tutorials/StochasticGradientDescent.qmd b/tutorials/StochasticGradientDescent.qmd
@@ -3,8 +3,8 @@ title: How to run stochastic gradient descent
 author: Ronny Bergmann
 ---
 
-This tutorial illustrates how to use the [`stochastic_gradient_descent`](https://manoptjl.org/stable/solvers/stochastic_gradient_descent.html)
-solver and different [`DirectionUpdateRule`](https://manoptjl.org/stable/solvers/gradient_descent.html#Direction-Update-Rules-1)s to introduce
+This tutorial illustrates how to use the [`stochastic_gradient_descent`](https://manoptjl.org/stable/solvers/stochastic_gradient_descent/)
+solver and different [`DirectionUpdateRule`](https://manoptjl.org/stable/solvers/gradient_descent/#Direction-update-rules)s to introduce
 the average or momentum variant, see [Stochastic Gradient Descent](https://en.wikipedia.org/wiki/Stochastic_gradient_descent).
 
 Computationally, we look at a very simple but large scale problem,
@@ -17,7 +17,7 @@ for given points ``` ``p_i ∈\mathcal M``, ``i=1,…,N`` ```{=commonmark} this
 ```
 
 which of course can be (and is) solved by a gradient descent, see the introductory
-tutorial or [Statistics in Manifolds.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/features/statistics.html).
+tutorial or [Statistics in Manifolds.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/features/statistics/).
 If $N$ is very large, evaluating the complete gradient might be quite expensive.
 A remedy is to evaluate only one of the terms at a time and choose a random order for these.
 
@@ -111,7 +111,7 @@ MG = MomentumGradient(; direction=StochasticGradient());
 @benchmark stochastic_gradient_descent($M, $gradf, p=$p0; direction=$MG)
 ```
 
-And on the other hand the [`AverageGradient`](https://manoptjl.org/stable/solvers/gradient_descent.html#Manopt.AverageGradient) computes an average of the last `n` gradients. This is done by
+And on the other hand the [`AverageGradient`](https://manoptjl.org/stable/solvers/gradient_descent/#Manopt.AverageGradient) computes an average of the last `n` gradients. This is done by
 
 ```{julia}
 p_opt4 = stochastic_gradient_descent(
@@ -126,7 +126,7 @@ AG = AverageGradient(; n=10, direction=StochasticGradient(M));
 Note that the default `StoppingCriterion` is a fixed number of iterations which helps the comparison here.
 
 For both update rules we have to internally specify that we are still in the stochastic setting,
-since both rules can also be used with the `IdentityUpdateRule` within [`gradient_descent`](file:///Users/ronny/Repositories/Julia/Manopt.jl/docs/build/solvers/gradient_descent.html).
+since both rules can also be used with the `IdentityUpdateRule` within [`gradient_descent`](https://manoptjl.org/stable/solvers/gradient_descent/).
 
 For this not-that-large-scale example we can of course also use a gradient descent with `ArmijoLinesearch`,
 
@@ -158,4 +158,4 @@ Pkg.status()
 #| output: asis
 using Dates
 println("This tutorial was last rendered $(Dates.format(now(), "U d, Y, HH:MM:SS")).");
-```
+```
diff --git a/tutorials/getstarted.qmd b/tutorials/getstarted.qmd
@@ -67,7 +67,7 @@ using ManifoldDiff: grad_distance, prox_distance
 Random.seed!(42);
 ```
 
-Now assume we are on the [Sphere](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/sphere.html)
+Now assume we are on the [Sphere](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/sphere/)
 $\mathcal M = \mathbb S^2$ and we generate some random points “around” some initial point $p$
 
 ```{julia}
@@ -215,7 +215,7 @@ Manopt.set_parameter!(:Mode, "")
 
 ## Example 2: computing the median of symmetric positive definite matrices
 
-For the second example let's consider the manifold of [$3 × 3$ symmetric positive definite matrices](https://juliamanifolds.github.io/Manifolds.jl/stable/manifolds/symmetricpositivedefinite.html) and again 100 random points
+For the second example let's consider the manifold of [$3 × 3$ symmetric positive definite matrices](https://juliamanifolds.github.io/Manifolds.jl/stable/manifolds/symmetricpositivedefinite/) and again 100 random points
 
 ```{julia}
 N = SymmetricPositiveDefinite(3)
@@ -306,4 +306,4 @@ println("This tutorial was last rendered $(Dates.format(now(), "U d, Y, HH:MM:SS
 Pages = ["getstarted.md"]
 Canonical=false
 ```
-````
+````