# Turbo-Muon: Accelerating Orthogonality-Based Optimization with Pre-Conditioning

Thibaut Boissin, Thomas Massena, Franck Mamalet, Mathieu Serrurier

<figure><img src="image_1.png" /></figure>

To cite this version:

Thibaut Boissin, Thomas Massena, Franck Mamalet, Mathieu Serrurier. Turbo-Muon: Accelerating Orthogonality-Based Optimization with Pre-Conditioning. 2025. hal-05390446

HAL Id: hal-05390446

https://hal.science/hal-05390446v1

Preprint submitted on 3 Dec 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_2.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
# Turbo-Muon: Accelerating Orthogonality-Based Optimization with Pre-Conditioning

Thibaut Boissin¹,²,† Thomas Massena²,³,† Franck Mamalet¹ Mathieu Serrurier²

¹ Institut de Recherche Technologique Saint-Exupery, France

² IRIT, France

³ Innovation & Research Division, SNCF, France

## Abstract

Orthogonality-based optimizers, such as Muon, have recently shown strong performance across large-scale training and community-driven efficiency challenges. However, these methods rely on a costly gradient orthogonalization step. Even efficient iterative approximations such as Newton-Schulz remain expensive, typically requiring dozens of matrix multiplications to converge. We introduce a preconditioning procedure that accelerates Newton-Schulz convergence and reduces its computational cost. We evaluate its impact and show that the overhead of our preconditioning can be made negligible. Furthermore, the faster convergence it enables allows us to remove one iteration out of the usual five without degrading approximation quality. Our publicly available implementation achieves up to a 2.8x speedup in the Newton-Schulz approximation. We also show that this has a direct impact on end-to-end training runtime with 5-10% improvement in realistic training scenarios across two efficiency-focused tasks. On challenging language or vision tasks, we validate that our method maintains equal or superior model performance while improving runtime. Crucially, these improvements require no hyperparameter tuning and can be adopted as a simple drop-in replacement. Our code is publicly available on github.

## 1. Introduction

Orthogonalization of weight updates has recently become a central ingredient in several optimizers [5, 6]. The most prominent example is the Muon optimizer [16], which has been shown to consistently surpass AdamW [18, 25] across diverse training regimes [38] and has been adopted in large foundation models such as Kimi-K2 and GLM-4.5 [17, 40]. Recent large-scale evaluations further report favorable scaling of Muon for LLM training [24, 31]. In Muon and its

variants, updates are projected toward the orthogonal manifold to enable faster convergence, stabilize optimization, and enable robust hyperparameter transfer across model scales [4, 6, 22, 27].

However, the computational cost of this projection remains the primary barrier to broad adoption at scale. Exact orthogonalization via SVD, while numerically precise, is impractical on modern accelerators due to its high cost and instability for large matrices in low precision. In practice, state of the art methods therefore rely on efficient but imprecise iterative schemes like the Newton-Schulz (NS) (also known as Björck) method [7, 10].

In these methods, wall-clock overhead scales with the number of iterative steps needed to achieve a target polar error (i.e., the Frobenius distance to the closest orthogonal matrix), creating a direct tension between runtime and optimization quality [32].

<figure><img src="image_3.png" /><figcaption>Figure 1. Practical implementations of orthogonalization face a trade-off between polar error and computation time. Thanks to preconditioning, our method drastically reduces the polar error of the Newton-Schulz algorithm. This improves the tradeoff between convergence and runtime, effectively lowering the overhead of the Muon optimizer.</figcaption></figure>

<footnote>†Core contributors.</footnote>
**This paper.** We introduce a preconditioned Newton–Schulz formulation based on almost-orthogonal (AOL) preconditioning [28]. Our key observation is that this preconditioner yields a substantially better initial approximation to the polar factor, especially for large matrices. In practice, this precision gain allows us to remove one Newton–Schulz iteration while improving or maintaining the numerical accuracy of the original algorithm, which typically runs in five iterations. Beyond this, the main computation cost of the preconditioner lies in an operation that can be reused, making its cost negligible. This results in an approach that yields an improved tradeoff between computation time and orthogonalization quality, as seen in Figure 1.

Finally, we test our method on a computer vision (CIFAR-10) and a language model training (nano-GPT) task and find consistent speed and convergence gains over already highly efficient baselines. Importantly, we improve training time by using a drop-in replacement for the orthogonalization step in Muon [16], our method improves runtime while preserving or improving downstream optimization performance.

## 2. Related Works

**Orthogonality based optimizers** form a recent class of training algorithms that enforce or approximate orthogonal updates to improve conditioning and stability during deep network optimization. The foundational work of Muon [16] introduced the idea of orthogonalizing parameter updates via iterative matrix normalization, such as the Newton–Schulz method, yielding isotropic update directions and smoother convergence dynamics. Follow-ups like Deriving Muon [4] and Old Optimizer, New Norm [5] offered theoretical insights linking these methods to optimization under alternative geometries and norms. Scalable implementations such as Dion [1] extended the approach to distributed settings, while Gluon [30] and AdaMuon [33] incorporated adaptivity and layer-wise refinements, bridging the gap between theoretical LMO frameworks and practical large-model training. Empirical studies [15, 17, 38] further demonstrated that such orthogonalization can accelerate convergence, stabilize training under heavy-tailed gradients, and enhance performance across architectures from GPT-2 Nano to billion-parameter models. Together, these works position orthogonality-based optimization as a promising direction for efficient and stable large-scale learning.

**Orthogonalization Methods.** A variety of orthogonalization schemes have been proposed to construct weight matrices with orthogonal constraints. The Modified Gram-Schmidt QR factorization [21] finds the polar factor with an iterative process (one iteration per row). The Cayley transform [8] establishes a bijection between skew-symmetric and orthogonal matrices through $(I - A)(I + A)^{-1}$, though it incurs the cost of matrix inversion. The Exponential

map [35] also leverages skew-symmetric matrices, generating $Q = \exp(A)$ while typically approximating the exponential via truncated series. Alternatively, the Cholesky-based method [13] orthogonalizes a matrix with a triangular decomposition $MM^\top = LL^\top$ (where $L$ is triangular) and solving for $L^{-1}M$, offering efficiency when numerical stability is maintained. Finally, the iterative Newton-Schulz algorithm [3, 7] (also known as Björck–Bowie algorithm) projects matrices toward the Stiefel manifold via the computation of matrix polynomials, achieving fast convergence under spectral normalization. More recently, authors of [10, 16] extended this algorithm with order five polynomials, achieving faster convergence. While these methods provide complementary trade-offs between accuracy, stability, and computational cost, the latter two have gained substantial popularity due to their scalability, making these operations feasible even at large scales [17].

## 3. Background and Motivation

**Definitions.** Let $X \in \mathbb{R}^{n \times n}$ denote a square matrix (all results generalize to the non-square case). The singular value decomposition (SVD) of $X$ is given by

$$X = U \Sigma V^\top,$$

where $U, V \in \mathbb{R}^{n \times n}$ are orthogonal matrices and $\Sigma = \text{diag}(\sigma_1, \dots, \sigma_n)$ is a diagonal matrix containing the singular values $\sigma_1 \ge \dots \ge \sigma_n \ge 0$. This also defines the spectral norm of a matrix : $\|X\|_2 = \sigma_1$.

A matrix $X$ is said to be *orthogonal* if it satisfies

$$X^\top X = X X^\top = I.$$

For non-square matrices, only one of these two equalities can hold, in which case the matrix is referred to as *pseudo-orthogonal*. To quantify deviations from orthogonality, we define the *orthogonality error* as

$$\varepsilon_{\text{ortho}}(\mathbf{X}) = \|\mathbf{X}^{\top}\mathbf{X} - \mathbf{I}\|_{F}.$$

In the context of this paper, we seek the closest orthogonal matrix to a given matrix $X$, with respect to the Frobenius norm. This matrix is the *polar factor*, given by

$$\text{PolarFactor}(\mathbf{X}) = \mathbf{Q} = U\mathbf{V}^\top.$$

As we focus on the iterative Newton-Schulz algorithm, we denote the approximation after the $t^{th}$ iteration $NS_t(X)$. To assess approximation quality, we define the normalized *polar error* as:

$$\varepsilon_{\text{polar}}(NS_t, \mathbf{X}) = \frac{\|NS_t(\mathbf{X}) - \mathbf{Q}\|_F}{\sqrt{n}}.$$

These metrics will be used throughout the paper to evaluate orthogonalization accuracy.
**Existing methods, strengths and limitations** The original *Muon* formulation introduced the Newton–Schulz (NS) variant of the Björck iteration, which relies on quintic polynomial expansions to approximate the polar factor efficiently [16]. Building on this, [10] proposed iteration-dependent polynomial coefficients, allowing convergence within 5 or 6 steps—a significant improvement over the fixed-coefficient scheme. This idea was later extended and accelerated by [12] and [2], who analyzed optimal polynomial families and convergence regimes for orthogonalization.

In parallel, [1] introduced *Dion*, a distributed implementation supporting model sharding (i.e. splitting a large neural network model into smaller parts) and tensor-parallel decomposition. Besides their optimizer, they provide an efficient implementation of *Muon* featuring Triton kernels [36], efficiently exploiting the matrix’s symmetric structure to reduce redundant computation and memory access. While these contributions collectively enhance the scalability of orthogonality-based optimizers, the computational cost of orthogonalization still remains a limiting factor. Also, in practice, Newton–Schulz iterations require dense matrix–matrix products, which creates nontrivial interactions with sharded training leading to compute and communication bottlenecks in extreme scale settings [9]. Hence, each reduction in cost directly broadens the applicability of orthogonality-based optimizers to increasingly large models.

**Newton-Schulz Iteration** In order to circumvent the limitations of exact methods, practical applications often rely on approximate methods. Notably, [7], demonstrated that the following scheme:

$$X_{k+1} = (1 - \beta)X_k - \beta X_k X_k^T X_k \quad (1)$$

Converges if $\|X_0\|_2 \le 1$ (in spectral norm) for $\beta \in [0, 0.5]$. More recently, [16] exposed a variant that uses 5th order polynomials:

$$X_{k+1} = aX_k + bX_k X_k^T X_k + cX_k X_k^T X_k X_k^T X_k \quad (2)$$

Which is computed in practice in three steps:

$$A_k = X_k^T X_k \quad (3)$$

$$B_k = bA_k + cA_k A_k \quad (4)$$

$$X_{k+1} = aX_k + X_k B_k \quad (5)$$

This formulation opens the door to new optimizations: [10] showed that $(a, b, c)$ coefficients can be changed across iterations, using $(a_k, b_k, c_k)$ instead of a constant $(a, b, c)$. [2] and [12] both explored the convergence of these algorithms alongside methods to find efficient polynomial factors. Notably, they observed that the most suitable parameters rely on hypotheses on the smallest singular values of $X$. Through-

<figure><img src="image_4.png" /><figcaption>Figure 2. Comparing pre-conditioning methods: AOL consistently outperforms the usual Frobenius normalization. When matrices get larger.</figcaption></figure>

out this paper and in our experiments, we refer to three main accessible variants of the Newton-Schulz algorithm<fnref n="1" />:

* **Muon** [16]: the original Newton-Schulz implementation, written in plain pytorch. It typically uses five iterations, with constant polynomial factor.

* **Muon+** [1]: a more efficient implementation, integrating Triton kernels [36] and adaptive polynomial factors from [10], computed for five iterations.<fnref n="2" />

* **Turbo-Muon**: our approach, combining a preconditioning method with an additional fused Triton kernel to further reduce runtime and maintain high numerical precision. Turbo-Muon uses four iterations by default that inherit the polynomial factors from Muon+.

This selection allows us to observe the impact of theoretical improvements (such a adaptive polynomial factor) and design choices (such as Triton kernels). Other approaches such as [2, 12] are discussed in App. D.

# 4. Methodology

Existing improvements of Newton-Schulz focus either on the polynomial steps being applied [2, 12], or on efficient implementations of the algorithm [1]. However, all practical implementations start with an overlooked step: normalizing the input matrix by its Frobenius norm. This ensures that the Newton-Schulz iterative scheme converges[7]. In this work, we explore an alternative normalization scheme and observe significant improvements for the convergence of the first Newton-Schulz iterations. Moreover, this better performance allows the removal of the iterative Newton-Schulz step without loss of precision.

<footnote n="1">¹Our experiments used the code from github.com/KellerJordan/Muon and github.com/microsoft/dion for baseline evaluation.</footnote>

<footnote n="2">²Dion is a distributed variant of *Muon* (with non-trivial modifications), we only compare here to their implementation of the Newton-Schulz algorithm to keep results comparable.</footnote>
**Algorithm 1 First iteration of N-S in (Muon/Muon+)**

**Require:** Initial point: $X_0 \in \mathbb{R}^{n \times n}$, $(a, b, c)$ NS factors

1: $s = 1/\|X_0\|_F$ ▷ Frobenius scaling factor

2: $X_1 = X_0 s$

3: $A_1 = X_1^\top X_1$ ▷ Eq. (3)

4: $B_1 = bA_1 + cA_1A_1$ ▷ Eq. (4)

5: $X_2 = aX_1 + X_1B_1$ ▷ Eq. (5)

... ▷ Next iteration of NS (no rescaling)

**4.1. Almost Orthogonal Preconditioning**

To ensure $\|X_0\|_2 \le 1$, existing implementations perform an initial normalization step $X_0/\|X_0\|_F$. While this guarantees convergence, in practice it often leads to $\|X_0\|_2 \ll 1$ and does not modify the condition number, since the ratio $\sigma_{min}/\sigma_{max}$ remains unchanged.

In contrast, the “Almost Orthogonal Layer” (AOL) parametrization introduced by [28] provides a lightweight alternative to normalization that simultaneously enforces $\|X_0\|_2 \le 1$ while improving the resulting matrix conditioning. In the following, we define:

$$ \text{AOL}(X_0) = X.\text{diag}\left(\sum_j |X_0^\top X_0|_{(i,j)}\right)^{-1/2} \quad (6) $$

Where the inverse square root of the row sum of the Gram matrix acts as a scaling vector applied column-wise to $X$. This brings the matrix closer to an orthogonal form. In Fig. 2, we compare the normalized polar error for the two normalization methods when applied to matrices sampled from a normal distribution (sizes ranging from 16 to 2048, with 32 matrices per trial). Indeed, as specified in Prach and Lampert [28], AOL converges to the polar factor if the matrix is near column-orthogonal and is of full rank. Importantly, this phenomenon can occur naturally on random high-dimensional matrices, as a byproduct of concentration phenomena which tend to enforce near orthogonality (see Section 3.2.4 of [37]).

**Preconditioning for free.** The AOL parametrization computation involves one matrix multiplication, one sum reduction over the rows (with the fast inverse square root computed element-wise), and an element-wise rescaling.

$$ A_0 = X_0^\top X_0 \qquad (\text{matmul}) \quad (7) $$

$$ s_{(i)} = \frac{1}{\sqrt{\sum_j |A_0|_{(i,j)}}} \qquad (\text{reduction}) \quad (8) $$

$$ X_1 = X_0 s \qquad (\text{rescaling}) \quad (9) $$

**Algorithm 2 First iteration of N-S (Turbo-Muon)**

**Require:** Initial point: $X_0 \in \mathbb{R}^{n \times n}$, $(a, b, c)$ NS factors

1: $A_0 = X_0^\top X_0$ ▷ Eq. (3) and Eq. (7)

2: $s = (1/\sqrt{\|A_0\|_1})_{i \in [0, n-1]}$ ▷ AOL scaling vector

3: $X_1 = X_0 s$

4: $A_1 = s^\top A_0 s$ ▷ Update A to avoid recomputation

5: $B_1 = bA_1 + cA_1A_1$ ▷ Eq. (4)

6: $X_2 = aX_1 + X_1B_1$ ▷ Eq. (5)

... ▷ Next iteration of NS (no rescaling)

On the other hand, the Frobenius normalization involves two steps:

$$ s = \frac{1}{\sqrt{\sum_{i,j} X_{0i,j}^2}} \qquad (\text{reduction}) \quad (10) $$

$$ X_1 = X_0 s \qquad (\text{rescaling}) \quad (11) $$

In practice, the cost of Eq. (8) and Eq. (10) is equivalent and so is the cost of Eq. (9) and Eq. (11). This means that the main computational overhead comes from matrix multiplication used to compute Eq. (7). While this cost is non-negligible, we can notice the similarity between Eq. (7) and Eq. (3). It is then possible to cache the result of the matrix multiplication for reuse in the first step of the Newton-Schulz algorithm. Then, $A_0$ can be updated to obtain $A_1$ with an elementwise multiplication (line 4 in Algorithm 2):

$$ A_1 = X_1^\top X_1 = (X_0 s)^\top (X_0 s) = s^\top A_0 s $$

Therefore, the computational load of AOL can be made similar to the original cost of the Frobenius normalization, with an additional elementwise multiplication. The description of the main differences between Muon and Turbo-Muon are depicted in Algorithms 1 and 2.

**4.2. What is the Impact of AOL Preconditioning on Iterative Methods ?**

The observation made in Sec. 4.1 and Fig. 2 motivate the use of AOL as a preconditioner with the goal of removing one iteration from the Newton-Schulz scheme. Our objective is to determine whether iterative approaches to estimating the polar factor exhibit improved performance when preceded by AOL preconditioning in the Muon settings. In this section, we conduct empirical studies on the effects of AOL preconditioning on the convergence of the Turbo-Muon algorithm towards the ideal polar factor matrix. Our study shows that under widely adopted practical constraints (i.e, using five iterations), our approach yields better approximations of the polar factor on a variety of different random matrices.

**Adequate preconditioning reduces the polar error.** We sampled batches of 32 matrices from a normal distribu-
<figure><img src="image_5.png" /><figcaption>(a) **Preconditioning is effective for large matrices:** Applying AOL before the algorithm improves convergence speed, especially for large matrices. In this context, an iteration can be removed while still achieving an improved convergence.</figcaption></figure>

<figure><img src="image_6.png" /><figcaption>(b) **Breakdown of our speedup:** Building atop Muon+, which includes Triton kernels and dynamic polynomial parameters (1.7x faster), our approach adds an extra Triton kernel that unlocks moderate gains (2.2x faster). Finally, removing one iteration out of 5 also improves runtime (2.8x faster).</figcaption></figure>

<caption>**Figure 3.** **Turning preconditioning into runtime:** Applying AOL before the algorithm improves its convergence speed (a). This can be used to remove an iteration while achieving a similar polar error. Removing one iteration out of 5 improves the runtime of the algorithm (b), making optimizers like Muon more scalable to large matrices.</caption>

tion<fnref n="3" /> and compared three standard implementations listed in Sec. 2. We then compute the polar error using the singular value decomposition (as defined in Sec. 3). Fig. 3a shows how the dynamic polynomial parameters from [1] reduce the polar error from the baseline of [16]. Additionally, AOL pre-conditioning (Turbo-Muon iter=5 in Fig. 3a) further reduces the polar error significantly. Importantly, our approach lowers the polar error enough to afford the removal of one iteration (Turbo-Muon iter=4), while still achieving a competitive or improved polar error.

**Removing one iteration and its impact on runtime.** The default Newton-Schulz setting in Muon uses five iterations. Importantly, we have shown that we can leverage AOL preconditioning to remove Newton-Schulz iteration without losing out on approximation quality w.r.t Muon and Muon+. Indeed, removing a single iteration reduces the total computational cost by ≈ 20%. This becomes particularly advantageous with large matrices, where each iteration follows a time complexity of ≈ $O(n^3)$. Alongside this cost reduction, we leverage the Triton kernels proposed in [1, 23], which improves compute time by using the symmetric nature of the operations used in Eq. (3) and Eq. (4): since $X^T X$ is symmetric, only one triangular part needs to be computed, effectively saving half of the required computation. However, Eq. (5) used a torch operator that induces a duplicate load of $X$, while this has a small impact on the overall runtime per

se, fixing this issue with a dedicated Triton kernel has a multiplicative effect with the removal of one iteration, leading to increased speedups.

**Stress testing our approach** Importantly, we show that the conclusions of our empirical convergence experiments remain valid in settings where matrices are drawn from more heavy-tailed distributions. More specifically, in Appendix B, we run our experiments on matrices sampled from a Levy distribution, since. This choice is motivated by observations made in [34], who observed that the tail index ranges from 1.0 to 1.8 in typical training of classification neural networks, [20] has shown similar observations on language transformers.

# 5. Experiments: Training with Turbo-Muon

While orthogonalization lies at the core of optimizers such as Muon, it is not the sole factor determining end-to-end performance. In this section, we assess how our proposed variant improves practical training efficiency without requiring hyperparameter retuning. We first identify the regimes in which the method delivers the most pronounced gains. We then evaluate whether one Newton-Schulz iteration can be safely removed without compromising convergence or final loss in full training runs.

**Runtime improvements for medium-scale training** In practice, the optimizer step accounts for only a small fraction

<footnote n="3">³Experiments in App. B shows that our results holds for realistic gradient distributions.</footnote>
<table><thead><tr><th>Variant</th><th>ms/step</th><th>Speedup</th></tr></thead><tbody><tr><td colspan="3"><strong>Muon variants</strong></td></tr><tr><td>Muon</td><td>1378.54 ± 12.35</td><td>1.000x</td></tr><tr><td>Muon+</td><td>1308.09 ± 8.36</td><td>1.054x</td></tr><tr><td>Turbo-Muon</td><td>1261.93 ± 6.89</td><td>1.092x</td></tr><tr><td colspan="3"><strong>Dion (Muon-derived, large-scale oriented)</strong></td></tr><tr><td>dion-1</td><td>3477.93 ± 57.22</td><td>0.397x</td></tr><tr><td>dion-1/4</td><td>1678.71 ± 14.64</td><td>0.821x</td></tr><tr><td>dion-1/16</td><td>1229.01 ± 14.55</td><td>1.122x</td></tr></tbody></table>

(a) Turbo-Muon unlocks step-time speedups at medium scale. We report training throughput (ms per optimization step) when simulating the training of a 1.3B-parameter model on an A100 80GB GPU with a batch size of 32k tokens per GPU, a setting where Muon's overhead is clearly exposed, and Dion's low rank induces a perceptible loss degradation. The speedup column indicates performance relative to Muon, with higher values corresponding to faster training.

<table><thead><tr><th>Turbo-Muon</th><th>Muon+</th><th>Muon</th></tr></thead><tbody><tr><td>3.35 ± 0.002 (1it)</td><td>3.35 ± 0.003 (2it)</td><td>3.34 ± 0.002 (2it)</td></tr><tr><td>3.32 ± 0.001 (2it)</td><td>3.31 ± 0.002 (3it)</td><td>3.30 ± 0.002 (3it)</td></tr><tr><td>3.29 ± 0.001 (3it)</td><td>3.29 ± 0.003 (4it)</td><td>3.29 ± 0.005 (4it)</td></tr><tr><td>3.28 ± 0.001 (4it)</td><td>3.28 ± 0.003 (5it)</td><td>3.28 ± 0.001 (5it)</td></tr></tbody></table>

(b) Our approach allows the removal of one Newton-Schulz iteration: We trained a 144M GPT model on the FineWeb dataset[26] up to the performance of GPT-2 and reported validation loss. We reused the fastest existing training script and replaced the Newton-Schulz implementation without changing any other parameters. Each line compared Turbo-Muon with baselines that have one extra iteration.

Figure 4. Turbo-Muon can make realistic training faster without impact on final loss. Fig. 4a shows that it can achieve non-negligible speedups on medium-scale training, with runtime improvements nearing 10% of the total step runtime. Fig. 4b shows that our approach does not induce perceptible loss degradation when an iteration is removed.

of total training computational cost, which is usually dominated by forward and backward propagation. Nonetheless, Muon's orthogonalization introduces a measurable overhead compared to AdamW. This overhead decreases as the batch size increases, since Muon's computational cost is independent of the batch dimension, while the model's forward cost scales linearly with it. Larger batches, therefore, improve time-to-target performance and typically move Muon past AdamW on the compute-efficiency frontier [31], especially as Muon exhibits a larger critical batch size[38].

At large model scales, however, global batch size cannot grow indefinitely without sharding, which significantly affects compute efficiency. Naïve replication can increase per-step flops by up to 5x, while more advanced strategies such as sharded matrix multiplication or layer sharding can suffer from bandwidth saturation. The resulting trade-off is tightly linked to the per-device batch size, which limits the amortization of Muon's overhead [9], leading to an overhead typically around 10-20%.

Within this context, our preconditioned Newton-Schulz method reduces the cost of the orthogonalization subroutine by approximately 3x at fixed polar accuracy. The resulting end-to-end gains are most pronounced at medium scales—where batch size is reduced but full sharding is unnecessary. This regime is illustrated in Fig. 4a: On a 1.3B language model, one A100 with 80G memory, can achieve a batch size of 32k tokens without sharding. In this context, Muon's cost is non-negligible, but optimizers tailored for extreme scales, such as Dion[1], are not yet efficient: Dion's low-rank updates—which shine at larger scales—still degrade convergence. Our drop-in preconditioned NS offers a competitive trade-off by reducing computational cost without compromising accuracy.

**Impact on end-to-end training.** We adopt the Modified NanoGPT benchmark [15] as our reference protocol. This setup “speed-runs” a 124M-parameter GPT on FineWeb to a validation cross-entropy 3.28-replicating the estimated performances of GPT-2 [29]– in less than 3 minutes on 8xNVIDIA H100, consuming roughly 0.73B tokens. The benchmark attributes these gains to combined architectural, optimization, and systems changes, such as rotary embeddings, QK-norm, ReLU², sliding-window/flash attention, an FP8 LM head, and the Muon optimizer. This benchmark is not the context where our approach would yield the most significant gains, as the model and batch sizes are tuned to make Muon overhead as small as possible. This benchmark is especially relevant as it is, up to date, the most efficient end-to-end training of its category. Additionally, it places a strong emphasis on reproducible runtime measurement, enabling us to precisely evaluate whether our approach can also yield performance gains in end-to-end training even in highly efficient settings.

In our setting, we reused the most recent training recipe and adapted it to select the implementation and the number of iterations. All other hyperparameters were left at their original value to validate that our approach can be used without any further modification. We ran all experiments on 4xH100 and reported the average loss and runtimes over ten runs for each setting (Fig. 4b). An important point is that, on each line, Turbo-Muon is evaluated with one fewer iteration and achieves equivalent performance.

Even in this heavily optimized setting, our approach yields superior results in both runtime and performance, demonstrating that our algorithm can enhance training efficiency without requiring any modifications to the hyperparameters. A direct comparison with the exact training recipe
reduced the total runtime from 273.75 ± 0.14 seconds to 266 ± 0.10 seconds. More details can be found in App. E.

**From Language to Vision: Transformers to CNNs** To evaluate the validity of AOL preconditioning in a different setting, we also demonstrate empirical gains on small-scale training tasks, such as the CIFAR-10 speed-running task[14]. This task consists of reaching 94% validation accuracy on the CIFAR10 classification task [19], in the minimum possible time, on a single A100 GPU. Importantly, in this task, we optimize a convolutional neural network (CNN). In this setting, the Muon optimizer reshapes the gradient update on convolution layers to matrices to orthogonalize them iteratively. In this setting, we demonstrate that AOL preconditioning yields a modest runtime improvement while maintaining the same performance, even on this significantly different task. We obtain the following results:

<table><caption>Table 1. Speedrunning results on the CIFAR-10 dataset using the implementation of [14] averages across 20 runs.</caption><thead><tr><th>Method</th><th>Validation accuracy (%)</th><th>Runtime (s)</th></tr></thead><tbody><tr><td>Muon</td><td>94.01 ± 0.1</td><td>2.66</td></tr><tr><td>Turbo-Muon</td><td>94.01 ± 0.1</td><td><b>2.64</b></td></tr></tbody></table>

Despite an already highly optimized implementation, achieving a further runtime reduction from 2.66 s to 2.64 s via a simple drop-in replacement is nontrivial. More importantly, these experiments substantiate the broad applicability of Turbo-Muon across heterogeneous training configurations, with consistent gains observed in both the NanoGPT and CIFAR-10 speedruns.

## 6. Beyond Iterative Approximates: On the Asymptotic Behavior of Turbo-Muon

In the previous sections, we've demonstrated that $\varepsilon_{\text{polar}}(\text{NS}_t \circ \text{AOL}, \mathbf{X}) \lesssim \varepsilon_{\text{polar}}(\text{NS}_t, \mathbf{X})$ in the widely adopted practical settings where $t \le 5$. This means that the polar error is of the same order as the usual error made by approximation algorithms. However, the nature of this error remains to be determined: When does the remaining polar error come from a lack of orthogonality? Or when does it come from a discrepancy between $\text{PolarFactor}(\text{AOL}(\mathbf{X}))$ and $\text{PolarFactor}(\mathbf{X})$? In the latter case, can this new type of error bias the global optimization process? In this section, we quantify how AOL pre-conditioning can introduce a bias and prove that this eventual bias still yields a strict descent direction.

**Characterizing the remaining polar error.** We can quantify the bias error induced by AOL preconditioning, by computing precisely $\text{PolarFactor}(X) = Q$ and

<figure><img src="image_7.png" /><figcaption>Figure 5. Understanding the nature of the remaining polar error. We decompose the polar error of the Turbo-Muon algorithm as an approximation error that depends on the number of NS iterations, along with a bias error that is introduced by AOL pre-conditioning. Results are measured on 100 random normal matrices.</figcaption></figure>

$\text{PolarFactor}(\text{AOL}(X)) = Q_{\text{aol}}:$

$$ \varepsilon_{\text{bias}}(\text{AOL}, \mathbf{X}) = \frac{\|\mathbf{Q} - \mathbf{Q}_{\text{aol}}\|_{F}}{\sqrt{n}} $$

This can be interpreted as the irreducible error that cannot be reduced after full convergence of the Newton-Schulz algorithm with AOL pre-conditioning, since it converges towards $Q_{\text{aol}}$. Similarly, we can define:

$$ \varepsilon_{\text{approx}}(\text{NS}_t, \text{AOL}(\mathbf{X})) = \frac{\|\mathbf{Q}_{\text{aol}} - \text{NS}_t \circ \text{AOL}(\mathbf{X})\|_{F}}{\sqrt{n}} $$

Which represents the approximation error between $\text{NS}_t(\text{AOL}(X))$ and $Q_{\text{aol}}$. These two definitions connect to the polar error with a direct application of the triangle inequality:

$$ \varepsilon_{\text{polar}}(\text{NS}_t \circ \text{AOL}, \mathbf{X}) \le \underbrace{\varepsilon_{\text{bias}}(\text{AOL}, \mathbf{X})}_{\text{irreducible bias}} + \underbrace{\varepsilon_{\text{approx}}(\text{NS}_t, \text{AOL}(\mathbf{X}))}_{\text{approximation error}} $$

This allows us to view the approximation error of the polar factor of X by Turbo-Muon as a convergence-related error $\varepsilon_{\text{approx}}$ and a bias-related error $\varepsilon_{\text{bias}}$ term, which are dependent on the original matrix X. Importantly, we assume that $\lim_{t \to \infty} \varepsilon_{\text{approx}}(\text{NS}_t, \mathbf{X}) = 0$, as proven in [7]. To illustrate this phenomenon, in Fig. 5, we run an experiment where we orthogonalize the same batch of 100 random matrices using Newton-Schulz iterative steps. Since existing methods had coefficients computed for only five iterations, we recomputed those using the method from Amsel et al. [2]. For each number of iterations, we quantify $\varepsilon_{\text{bias}}(\text{AOL}, \mathbf{X})$ (in dashed green) alongside $\varepsilon_{\text{approx}}(\text{NS}_t, \text{AOL}(\mathbf{X}))$ (in dark green), finally, total polar error is compared with the polar error obtained without pre-conditioning, assuming that
<table><caption>**Table 2. The measured εbias does not impact final performance:** We measure the final accuracy (%) of the trained classifier on the CIFAR-10 dataset with and without AOL preconditioning after tNS steps. We log the values of εapprox and εbias once every 10 train batches and report average values across 80 training runs.</caption><thead><tr><th>Method</th><th>t<sub>NS</sub></th><th>Accuracy (%)</th><th>ε<sub>approx</sub></th><th>ε<sub>bias</sub></th></tr></thead><tbody><tr><td>Turbo-Muon</td><td>15</td><td>94.08 ± 0.1%</td><td>5.5 × 10<sup>-4</sup></td><td>0.1</td></tr><tr><td>Turbo-Muon</td><td>25</td><td>94.07 ± 0.1%</td><td>3.6 × 10<sup>-4</sup></td><td>0.1</td></tr><tr><td>Turbo-Muon</td><td>40</td><td>94.05 ± 0.1%</td><td>2.1 × 10<sup>-4</sup></td><td>0.1</td></tr><tr><td>Muon</td><td>15</td><td>94.06 ± 0.1%</td><td>1.5 × 10<sup>-2</sup></td><td>0.0</td></tr><tr><td>Muon</td><td>25</td><td>94.06 ± 0.1%</td><td>1.1 × 10<sup>-2</sup></td><td>0.0</td></tr><tr><td>Muon</td><td>40</td><td>94.04 ± 0.1%</td><td>7.4 × 10<sup>-3</sup></td><td>0.0</td></tr></tbody></table>

Newton-Schulz is perfectly unbiased (in dark blue). We observe that while Turbo-Muon is indeed biased, its bias is compensated by the superior approximation speed it confers in practically adopted low t settings. When t is high, the beneficial effects of pre-conditioning are absorbed while the bias remains. For reference, nine iterations of Newton-Schulz require 27 matrix multiplications in total.

**Characterizing AOL preconditioning when $t \to \infty$.** We have shown that the bias effect is negligible in the low iteration number of Newton-Schulz usually used in Muon. But we might want to evaluate the effect it could induce in regimes where a high number of Newton-Schulz iterative steps are used. We show that in fact the biased estimation of the polar factor introduced by AOL pre-conditioning still ensures that we recover a weight update that corresponds to a steepest descent direction. For reference, as explained in [5], the steepest descent update in spectral norm is (informally) defined as:

$$ \arg\min_{\Delta W} \left[ \langle G, \Delta W \rangle + \frac{\lambda}{2} \max \|\Delta W\|_2^2 \right] = \text{PolarFactor}(G). \quad (12) $$

with G the gradient and λ sharpness. Therefore, given that AOL pre-conditioning can be written as AOL(X) = Xs with s as vector with $s_i > 0$, using Equation 6. We have that the Turbo-Muon update solves a steepest descent in an induced norm that is dependent of s (c.f. Definition 1 of Bernstein and Newhouse [5]). Moreover, in practice, s forms a vector of strictly positive entries. Therefore, the weight updates of Turbo-Muon yield a strict descent direction. This means that even the worst case of an input that maximizes εbias cannot lead to a divergence of the training process. More details are provided in Appendix A.1.

**Confirming That the Estimation Bias Does Not Affect Training** In order to empirically validate the theoretical

result asserting that this estimation bias should not alter the training convergence, we investigate the training dynamics for an unconventionally high number of Newton-Schulz iterative steps. We train a neural network on the CIFAR-10 dataset with and without AOL preconditioning. Across each run we vary the number of iterative NS steps and compute coefficients for the NS iterations according to the number of chosen steps (using the method from [2]). The high number of steps we choose here leads to an unrealistically long training time. But ensures that the orthogonalized weight updates are extremely close estimates of PolarFactor(X) and PolarFactor(AOL(X)). Table 2 depicts the results for $15 \le t_{NS} \le 40$, and shows that while both Turbo-Muon and Muon converge toward their respective iterative objective, the bias induced by the AOL-preconditioning has no impact on the quality of training.

While it is unclear if AOL preconditioning confers an advantage in high t regimes. It is rather apparent than training a neural network with Turbo-Muon 's weight updates is valid in theory and in practice. Furthermore, usual practical implementations of orthogonality-based optimization rely on a relatively small amount of iterative steps to retrieve an approximation of the closest orthogonal matrix, where AOL preconditioning really shines.

## 7. Conclusion and Perspectives

In this work, we propose AOL preconditioning as a novel approach to improving the efficiency of orthogonality-based optimizers like Muon. Under practical approximation budgets (i.e., $t \le 5$), we show that AOL preconditioning yields both faster and more accurate orthogonalization. Empirically, AOL reduces the initial polar error significantly compared to Frobenius normalization on large random matrices (Fig. 2), and enables the removal of one Newton-Schulz iteration while still achieving equal or lower error than the five-step Muon and Muon+ baselines (Fig. 3a). These convergence gains translate directly into runtime improvements: across realistic training settings, Turbo-Muon provides step-time speedups of 8–10% at medium scale (Fig. 4a) and reduces the end-to-end runtime of the NanoGPT benchmark without any hyperparameter changes (Fig. 4b). Finally, we demonstrate that these improvements hold across both language modeling and vision tasks, confirming that AOL-based preconditioning yields consistent benefits in already highly optimized training pipelines. Finally, we explore if AOL preconditioning is suitable for exact estimation of the polar factor, and show that AOL preconditioning asymptotically approximates a steepest descent direction with greatly increased iterative convergence (as observed in Tab. 2).
Acknowledgments

This work was carried out within the DEEL project,⁴ which is part of IRT Saint Exupéry and the ANITI AI cluster. The authors acknowledge the financial support from DEEL's Industrial and Academic Members and the France 2030 program - Grant agreements n°ANR-10-AIRT-01 and n°ANR-23-IACL-0002.

This work was granted access to the HPC resources of IDRIS under the allocation 2025-AD011016381 made by GENCI.

References

[1] Kwangjun Ahn, Byron Xu, Natalie Abreu, Ying Fan, Gagik Magakyan, Pratyusha Sharma, Zheng Zhan, and John Langford. Dion: Distributed orthonormalized updates. arXiv preprint arXiv:2504.05295, 2025. 2, 3, 5, 6, 15

[2] Noah Amsel, David Persson, Christopher Musco, and Robert M Gower. The polar express: Optimal matrix sign methods and their application to the muon algorithm. arXiv preprint arXiv:2505.16932, 2025. 3, 7, 8, 15, 16

[3] Cem Anil, James Lucas, and Roger Grosse. Sorting out lipschitz function approximation. In International Conference on Machine Learning, pages 291–301. PMLR, 2019. 2

[4] Jeremy Bernstein. Deriving muon, 2025, 2025. 1, 2

[5] Jeremy Bernstein and Laker Newhouse. Old optimizer, new norm: An anthology. In OPT 2024: Optimization for Machine Learning, 2024. 1, 2, 8, 11

[6] Jeremy Bernstein and Laker Newhouse. Modular duality in deep learning. In Proceedings of the 42nd International Conference on Machine Learning, pages 3920–3930. PMLR, 2025. 1

[7] Åke Björck and Clazett Bowie. An iterative algorithm for computing the best estimate of an orthogonal matrix. SIAM Journal on Numerical Analysis, 8(2):358–364, 1971. 1, 2, 3, 7

[8] Arthur Cayley. Sur quelques Propriétés des Déterminants Gauches, page 332–336. Cambridge University Press, 1846. 2

[9] Essential-AI. Layer sharding for large-scale training with muon, 2025, 2025. 3, 6

[10] Cesista Franz Louis, Jiacheng You, and Jordan. Keller. Squeezing 1-2% efficiency gains out of muon by optimizing the newton-schulz coefficients, 2025, 2025. 1, 2, 3, 15

[11] Semen Aronovich Gershgorin. über die abgrenzung der eigenwerte einer matrix. Izvestiya Rossiiskoi Akademii Nauk. Seriya Matematicheskaya, 6:749–754, 1931. 13

[12] Ekaterina Grishina, Matvey Smirnov, and Maxim Rakhuba. Accelerating Newton-Schulz Iteration for Orthogonalization via Chebyshev-type Polynomials, 2025. arXiv:2506.10935 [math]. 3, 15, 16

[13] Kai Hu, Klas Leino, Zifan Wang, and Matt Fredrikson. A recipe for improved certifiable robustness. In International Conference on Learning Representations, 2023. 2

[14] Keller Jordan. cifar10-airbench. https://github.com/KellerJordan/cifar10-airbench, 2024. GitHub repository. 7

[15] Jordan Keller, Bernstein Jeremy, Rappazzo Brendan, Vlado Boza, Jiacheng You, Cesista Franz, and Koszarsky. Braden. modded-nanogpt: Speedrunning the nanogpt baseline, 2024, 2024. 2, 6

[16] Jordan Keller, Jin Yuchen, Boza Vlado, You Jiacheng, Cesista Franz, Newhouse Laker, and Bernstein Jeremy. Muon: An optimizer for hidden layers in neural networks, 2024, 2024. 1, 2, 3, 5

[17] Kimi-AI, Bai Yifan, Bao Yiping, Chen Guanduo, Chen Jiahao, Chen Ningxin, Chen Ruijue, Chen Yanru, Chen Yuankun, and et al. Yutian, Chen. Kimi k2: Open agentic intelligence, 2025. Kimi k2: Open agentic intelligence. arXiv preprint arXiv:2507.20534, 2025. 1, 2

[18] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. 1

[19] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. 7

[20] Frederik Kunstner, Alan Milligan, Robin Yadav, Mark Schmidt, and Alberto Bietti. Heavy-tailed class imbalance and why adam outperforms gradient descent on language models. Advances in Neural Information Processing Systems, 37: 30106–30148, 2024. 5, 14

[21] Pierre Simon LaPlace. Théorie analytique des probabilités. Courcier, 1820. 2

[22] Tim Large, Yang Liu, Minyoung Huh, Hyojin Bahng, Phillip Isola, and Jeremy Bernstein. Scalable optimization in the modular norm. Advances in Neural Information Processing Systems, 37:73501–73548, 2024. 1

[23] Tianyang Lin. Flash-muon: An efficient implementation of muon optimizer, 2025. 5

[24] Jingyuan Liu, Jianlin Su, Xingcheng Yao, Zhejun Jiang, Guokun Lai, Yulun Du, Yidao Qin, Weixin Xu, Enzhe Lu, Junjie Yan, et al. Muon is scalable for llm training. arXiv preprint arXiv:2502.16982, 2025. 1

[25] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2017. 1

[26] Guilherme Penedo, Hynek Kydlíček, Anton Lozhkov, Margaret Mitchell, Colin A Raffel, Leandro Von Werra, Thomas Wolf, et al. The fineweb datasets: Decanting the web for the finest text data at scale. Advances in Neural Information Processing Systems, 37:30811–30849, 2024. 6

[27] Thomas Pethick, Wanyun Xie, Kimon Antonakopoulos, Zhenyu Zhu, Antonio Silveti-Falls, and Volkan Cevher. Training deep learning models with norm-constrained lms. arXiv preprint arXiv:2502.07529, 2025. 1

[28] Bernd Prach and Christoph H Lampert. Almost-orthogonal layers for efficient general-purpose lipschitz networks. In European Conference on Computer Vision, pages 350–365. Springer, 2022. 2, 4

[29] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019. 6

⁴https://www.deel.ai/
[30] Artem Riabinin, Egor Shulgin, Kaja Gruntkowska, and Peter Richtárik. Gluon: Making Muon & Scion Great Again! (Bridging Theory and Practice of LMO-based Optimizers for LLMs), 2025. arXiv:2505.13416 [cs]. 2

[31] Ishaan Shah, Anthony M Polloreno, Karl Stratos, Philip Monk, Adarsh Chaluvaraju, Andrew Hojel, Andrew Ma, Anil Thomas, Ashish Tanwer, Darsh J Shah, et al. Practical efficiency of muon for pretraining. arXiv preprint arXiv:2505.02222, 2025. 1, 6

[32] Egor Shulgin, Sultan AlRashed, Francesco Orabona, and Peter Richtárik. Beyond the ideal: Analyzing the inexact muon update. arXiv preprint arXiv:2510.19933, 2025. 1

[33] Chongjie Si, Debing Zhang, and Wei Shen. AdaMuon: Adaptive Muon Optimizer, 2025. arXiv:2507.11005 [cs] version: 1. 2

[34] Umut Simsekli, Levent Sagun, and Mert Gurbuzbalaban. A tail-index analysis of stochastic gradient noise in deep neural networks. In International Conference on Machine Learning, pages 5827-5837. PMLR, 2019. 5, 13, 14

[35] Sahil Singla and Soheil Feizi. Skew orthogonal convolutions. In International Conference on Machine Learning, pages 9756-9766. PMLR, 2021. 2

[36] Philippe Tillet, Hsiang-Tsung Kung, and David Cox. Triton: an intermediate language and compiler for tiled neural network computations. In Proceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages, pages 10-19, 2019. 3

[37] Roman Vershynin. High-dimensional probability, 2009. 4

[38] Kaiyue Wen, David Hall, Tengyu Ma, and Percy Liang. Fantastic Pretraining Optimizers and Where to Find Them, 2025. arXiv:2509.02046 [cs]. 1, 2, 6

[39] Wikipedia. Lévy distribution - Wikipedia, the free encyclopedia. http://en.wikipedia.org/w/index.php?title=L%3C3%A9vy%20distribution&oldid=1322680363, 2025. 14

[40] Aohan Zeng, Xin Lv, Qinkai Zheng, Zhenyu Hou, Bin Chen, Chengxing Xie, Cunxiang Wang, Da Yin, Hao Zeng, Jiajie Zhang, et al. Glm-4.5: Agentic, reasoning, and coding (arc) foundation models. arXiv preprint arXiv:2508.06471, 2025. 1
## A. About the convergence of Turbo-Muon

In this section, we build upon the work of Bernstein and Newhouse [5], as they show that Muon's update (without accumulations) solves a steepest descent direction in a $\ell_2 \to \ell_2$ induced operator norm. As a starting point, we define how the norm induced by our preconditioning differs from the original one. We show in App. A.1 that preconditioning does not bias the overall optimization process. In App. A.2, we give elements of interpretation about the meaning of AOL preconditioning for optimization.

Following [5] we have that steepest descent updates in alternative norms are defined as solutions to the following problem:

$$ \arg \min_{\Delta W \in \mathbb{R}^{m \times n}} \left[ \langle G, \Delta W \rangle + \frac{\lambda}{2} \max \| \Delta W \|_{\alpha \to \beta}^2 \right], \quad (13) $$

where $\langle \cdot, \cdot \rangle$ denotes the Frobenius inner product. For any matrix $M \in \mathbb{R}^{m \times n}$, and normed spaces $(\mathbb{R}^{d_{in}}, \| \cdot \|_{\alpha})$ and $(\mathbb{R}^{d_{out}}, \| \cdot \|_{\beta})$, the “$\alpha$ to $\beta$”, we recall the induced operator norm as:

$$ \|M\|_{\alpha \to \beta} = \max_{x \in \mathbb{R}^{d_{in}}} \frac{\|Mx\|_{\beta}}{\|x\|_{\alpha}}. \quad (14) $$

Importantly, as explicit in Proposition 5 of [5]. When $\alpha = 2$ and $\beta = 2$, we have that the solution to Equation 13 is:

$$ \Delta W_{\| \cdot \|_{\ell_2 \to \ell_2}} = -\eta \text{PolarFactor}(G), $$

with $\eta$ the sum of the singular values of $G$ divided by $\lambda$. In this paper, we introduce the Turbo-Muon update as PolarFactor($G.S$). With $S$ the diagonal matrix composed of AOL preconditioning coefficients (previously denoted as $s$), which are strictly positive and bounded in practice. Here we show that this update is the solution of a slightly different steepest descent problem formulated using a rescaled norm.

**Proposition 1 (Turbo-Muon Steepest Descent).** For any gradient matrix $G \in \mathbb{R}_{\backslash 0}^{m \times n}$ of SVD decomposition $G = U.\Sigma.V^T$ with $U$ and $V$ unitary, and any sharpness $\lambda > 0$, consider the problem:

$$ \arg \min_{\Delta W \in \mathbb{R}^{m \times n}} \left[ \langle G, \Delta W \rangle_F + \frac{\lambda}{2} \max \| \Delta W \|_{S \to \ell_2}^2 \right] \\ \text{with } \|M\|_{S \to \ell_2} := \sup_{x \in \mathbb{R}_{\backslash 0}^d} \frac{\|M.S^{-1}.x\|_2}{\|x\|_2}. \quad (15) $$

this problem is solved with a step size $\eta = \frac{1}{\lambda} \text{tr}(\Sigma)$ and an update:

$$ \Delta W_{\| \cdot \|_{S \to \ell_2}} = -\eta \text{PolarFactor}(G.S), \quad (16) $$

This solution is unique if and only if $G$ is of full rank. We assume $S$ to be a matrix whose diagonal is filled with rescaling values obtained from Eq. (6) (strictly positive and bounded diagonal).

This proposition effectively generalizes Turbo-Muon as an optimizer that performs steepest descent steps in an induced norm that is dependent of AOL rescalings, as per the framework of [5].

*Proof.* Here, we start from Proposition 5 of Bernstein and Newhouse [5], i.e:

$$ \arg \min_{\Delta W \in \mathbb{R}^{m \times n}} \left[ \langle X, \Delta W \rangle + \frac{\lambda}{2} \max \| \Delta W \|_{2 \to 2}^2 \right] = -\eta \text{PolarFactor}(X) \quad (17) $$

with $X$ of SVD $X = U.\Sigma.V^T$ and $\eta = \frac{1}{\lambda} \text{tr}(\Sigma)$. By choosing $X = G.S$, this equates to:

$$ \arg \min_{\Delta W \in \mathbb{R}^{m \times n}} \left[ \langle G.S, \Delta W \rangle + \frac{\lambda}{2} \max \| \Delta W \|_{2 \to 2}^2 \right] = -\eta \text{PolarFactor}(G.S) \quad (18) $$

Using the cyclic property of the trace along with the symmetry of $S$, the inner Frobenius product on the left-hand side of this expression can be modified to obtain:
$$ \arg\min_{\Delta W \in \mathbb{R}^{m \times n}} \left[ \langle G, \Delta W.S \rangle + \frac{\lambda}{2} \max \|\Delta W\|_{2 \to 2}^2 \right] = -\eta \text{PolarFactor}(G.S) \quad (19) $$

Which is also equivalent to:

$$ \begin{gathered} \arg\min_{\Delta W \in \mathbb{R}^{m \times n}} \left[ \langle G, \Delta W.S \rangle + \frac{\lambda}{2} \max \|\Delta W.S\|_{S \to 2}^2 \right] = -\eta \text{PolarFactor}(G.S) \quad (20) \\ \text{with } \|M\|_{S \to \ell_2} := \sup_{x \in \mathbb{R}^d} \frac{\|M.S^{-1}.x\|_2}{\|x\|_2}. \end{gathered} $$

by defining the appropriate induced operator norm. Since, in that case, we have: $\|\Delta W\|_{\ell_2 \to \ell_2}^2 = \|\Delta W.S\|_{S \to \ell_2}$. Therefore, we have:

$$ \arg\min_{\Delta W' \in \mathbb{R}^{m \times n}} \left[ \langle G, \Delta W' \rangle + \frac{\lambda}{2} \max \|\Delta W'\|_{S \to 2}^2 \right] = -\eta \text{PolarFactor}(G.S), \quad (21) $$

by reparametrization with $\Delta W' = \Delta W.S$. To conclude, we have:

$$ \Delta W_{\|\cdot\|_{S \to \ell_2}} = -\eta \text{PolarFactor}(G.S), \quad (22) $$

with $\eta$ unchanged, where we recover the form of the Turbo-Muon update. $\square$

<figure><img src="image_8.png" /></figure>

## A.1. Proof: AOL preconditioning cannot lead to Muon divergence

Previously, we have shown that Turbo-Muon recovers steepest descent in a rescaled induced operator norm. However, this norm is dependent on $S$, the AOL rescalings of the gradient. Using only the general properties of the matrix $S$, we will answer the following question: if preconditioning induces the steepest descent in a different norm, can this bias the global optimization process?

**Lemma 1.** Let $S$ a diagonal matrix of strictly positive and bounded entries, we have that, $\forall G \in \mathbb{R}_{\ge 0}^{m \times n}$:

$$ \langle G, \text{PolarFactor}(G.S) \rangle > 0. \quad (23) $$

Meaning that the projected update recovered by Turbo-Muon is always “aligned” with the raw gradient $G$. Thus yielding a strict descent direction.

*Proof.* Write $X := G.S$. By definition of the (left) polar factor,

$$ \text{PolarFactor}(X) = X (X^\top X)^{-1/2}, $$

where $(\cdot)^{-1/2}$ denotes the unique positive-semidefinite inverse square root on the support of $X^\top X$. Hence

$$ \begin{aligned} \langle G, \text{PolarFactor}(G.S) \rangle &= \operatorname{tr}(G^\top \text{PolarFactor}(X)) \\ &= \operatorname{tr}(S^{-1} X^\top \text{PolarFactor}(X)), \end{aligned} $$

since $G^\top = S^{-1}X^\top$ and $S^{-1} > 0$ (as per Eq. (6)). Using $X^\top \text{PolarFactor}(X) = X^\top X (X^\top X)^{-1/2} = (X^\top X)^{1/2}$, we get

$$ \langle G, \text{PolarFactor}(GS) \rangle = \operatorname{tr}(S^{-1} (X^\top X)^{1/2}). $$

The matrix $(X^\top X)^{1/2} \succeq 0$ and is nonzero because $G \neq 0$ and $S$ is invertible, while $S^{-1} > 0$. For positive semidefinite $S \neq 0$ and positive definite $T$, $\operatorname{tr}(TS) = \operatorname{tr}(T^{1/2}ST^{1/2}) > 0$. Therefore $\operatorname{tr}(S^{-1}(X^\top X)^{1/2}) > 0$ and the claim follows. The argument does not require $G$ to be square or full rank. If $X$ is rank deficient, interpret $(X^\top X)^{-1/2}$ as the Moore-Penrose inverse square root, so the identity $X^\top \text{PolarFactor}(X) = (X^\top X)^{1/2}$ holds on the support of $X^\top X$, and the same positivity conclusion applies. $\square$

<figure><img src="image_9.png" /></figure>
<figure><img src="image_10.png" /><figcaption>Figure 6. We reproduced the Fig. 1 using heavy-tailed distributions. Despite an overall degradation in the resulting polar error, Turbo-Muon outperforms existing approaches by a significant margin.</figcaption></figure>

## A.2. About Turbo-Muon Rescaling

In this section, we analyze the geometric properties of the rescaling matrix $S$ used in Turbo-Muon preconditioning. Importantly, this rescaling induces a norm that adapts to the structural coherence of the gradients, effectively normalizing the worst-case spectral contribution of feature clusters.

The rescaling matrix $S$ is derived from the Gram matrix of the gradient, $H = G^T G$. Geometrically, the entry $H_{jk} = \langle g_j, g_k \rangle$ quantifies the correlation between the gradient updates of feature column $j$ and feature column $k$. High values indicate that these features are being pushed in similar directions by the loss function. To extract a scalar measure of feature stability from this matrix without expensive eigendecompositions, we use the Gershgorin Circle Theorem [11]. The theorem states that the eigenvalues of $H$ are strictly bounded by its row sums. We define the Gershgorin Coherence Bound $\Lambda_j$ for the $j$-th feature as:

$$ \Lambda_j \triangleq \sum_{k=1}^{n} |(G^T G)_{jk}| = \underbrace{|(G^T G)_{jj}|}_{\text{Feature Energy}} + \underbrace{\sum_{k \neq j} |(G^T G)_{jk}|}_{\text{Structural Redundancy}} \quad (24) $$

This quantity $\Lambda_j$ serves as an upper bound on the strength and redundancy of feature $j$ as it captures the magnitude of the feature's own gradient, but its constructive interference with all other correlated features in the layer. By defining the scaling as $S = \text{diag}(\Lambda)^{-1/2}$, the optimization process $\Delta W = \text{PolarFactor}(G.S)$ corresponds to steepest descent in an induced operator norm $\| \cdot \|_{\ell_2 \to S}$, that is explicitly shaped by these coherence bounds. We distinguish the following cases during optimization:

* **Penalization of Coherence:** When a group of features collapses (i.e., learns highly correlated representations), the off-diagonal terms in $G^T G$ grow large. Consequently, the Gershgorin bound $\Lambda$ increases, and the effective step size $s_i$ for those features decreases.

* **Amplification of Orthogonality:** Conversely, for features that are orthogonal to others, the redundancy term vanishes and the scaling is determined only by the feature's own energy, allowing for relatively larger updates.

Therefore, the steepest descent of Turbo-Muon ensures that the worst-case curvature estimate of every feature channel—bounded by the Gershgorin disk—is at most 1, resulting in a stabilized spectral update that is robust to feature collapse.

**Broadening the theoretical horizon.** While Turbo-Muon and standard Muon yield near identical updates under efficient iterative Newton-Schulz approximation, our derivation highlights the specific geometric role of structural rescaling. Building on the formalism established in this section, future work could further generalize this class of correlation-aware constraints, potentially uncovering a broader family of geometrically informed efficient spectral optimizers.

## B. What About Real Gradients ?

### B.1. Heavy tailed matrices

In this section, we run the complementary experiments from Sec. 4.2 and Sec. 6 on matrices sampled from a Levy distribution of parameters $\alpha$ and $\beta$. This choice is motivated by observations made in Simsekli et al. [34], which found that the tail index
<figure><img src="image_11.png" /><figcaption>(a) Levy distribution: $\alpha = 1.0, \beta = 0$</figcaption></figure>

<figure><img src="image_12.png" /><figcaption>(b) Levy distribution: $\alpha = 1.5, \beta = 0$</figcaption></figure>

<figure><img src="image_13.png" /><figcaption>(c) Levy distribution: $\alpha = 2.0, \beta = 0$</figcaption></figure>

Figure 7. We reproduced the Fig. 3a using heavy-tailed distributions. Despite an overall degradation in the resulting polar error, Turbo-Muon outperforms existing approaches by a significant margin.

<figure><img src="image_14.png" /><figcaption>(a) Levy distribution: $\alpha = 1.0, \beta = 0$</figcaption></figure>

<figure><img src="image_15.png" /><figcaption>(b) Levy distribution: $\alpha = 1.5, \beta = 0$</figcaption></figure>

<figure><img src="image_16.png" /><figcaption>(c) Levy distribution: $\alpha = 2.0, \beta = 0$</figcaption></figure>

Figure 8. Reproduction of Fig. 5 with heavy tailed distributions. This extreme regime–where the singular value decomposition is at its numerical limit– shows that the tail index correlates with the bias error induced by our preconditioning.

of gradients belongs to $\alpha \in [1.0, 1.8]$ in typical training of classification neural networks. Independently, Kunstner et al. [20] has also shown similar observations on transformers trained on language modeling tasks.

In this section, we reproduce the protocol of Fig. 1 from the main paper and report results using three different tail-indices $\{1.0, 1.5, 2.0\}$ in Fig. 6, ensuring we cover realistic values. We set $\beta = 0$ since, despite the fact that the gradient expectation over timesteps is non null, we made the assumption that its expectation over neurons is null: high values for $\beta$ induce a rank collapse toward rank 0 (ie, a constant), which is unrealistically pathological. Intuitively, when $\alpha = 2.0$, the distribution is nearly Gaussian, and for $\alpha \le 1.0$, estimation of the mean becomes an inconsistent estimator[39]. For all tested values of $\alpha$, Turbo-Muon outperforms Muon/Muon+ by a significant margin in realistic settings ($t \le 5$).

Similarly, we reproduced the result of Fig. 3a from the main paper for Levy distributions and reported results in Fig. 7. Again, we observe a global degradation of performances, with a lower degradation for Turbo-Muon. Notably, in these experiments, we observed that the PyTorch implementation of the singular value decomposition was unstable in these regimes, especially for large matrices. Thus limiting these experiments to matrices of size 512 $\times$ 512.

Interestingly, in these regimes, the orthogonality error of Turbo-Muon is very low, highlighting that the remaining error is not due to a lack of convergence but to an increased bias for poorly conditioned matrices. This can be observed by reproducing the Fig. 8 experiment from the paper: for instance, when $\alpha = 1$, the polar bias can reach up to 0.15, which is significantly higher than the bias found with matrices sampled from normal distributions. Yet the drastically improved convergence still leads to a lower polar error compared to Muon+, which requires nine iterations (27 matrix multiplications) to reach a lower polar error than Turbo-Muon. The polar bias observed in Tab. 2 suggests that empirical gradients have a tail index $1.0 \le \alpha \le 1.5$, which is coherent with the observations of Simsekli et al. [34].

## C. Result for various matrix size

In this section, we show that the results displayed in Fig. 1 of the main paper hold for various matrix sizes sampled from the Normal distribution. Interestingly, two effects are observed: on one side, our preconditioning yields improvements in the polar
<figure><img src="image_17.png" /><figcaption>Figure 9. Reproduction of Fig. 1 for various matrix sizes. In all settings, Turbo-Muon outperforms Muon and Muon+ by a significant margin.</figcaption></figure>

error (shifting Turbo-Muon on the vertical axis), especially for large matrices; however, this effect becomes smaller for small matrices. On the other side, the triton kernel of Eq. (5) improves runtime (shifting Turbo-Muon on the horizontal axis) on small matrices, as those lead to communication-bound kernels. Similarly, this effect becomes smaller for large matrices, as those lead to compute-bound kernels. This combination ensures a dominance of Turbo-Muon in all configurations.

## D. About the tuning of Newton-Schulz coefficients

In this paper, we use dynamic polynomial coefficients to run Newton-Schulz iterations, which means that each step uses different values for *a*, *b*, *c*. However, the implementation of Muon+ [1] uses coefficients computed explicitly for a fixed number of 5 iterations. To adapt the algorithm to a lower number of iterations, we employed a straightforward strategy as we reduced the number of iterations by retaining only the *n* last polynomial coefficients. The motivation behind this choice was to isolate the effect of AOL preconditioning as the only factor responsible for the reduction in polar error between Muon+ and Turbo-Muon. In this section, we demonstrate, through additional experiments, that our strategy is indeed highly effective in regimes with a low number of iterations.

### D.1. Ablation

The difference between Muon and Muon+ shows the undeniable impact of using explicitly computed polynomial coefficients for a fixed number of steps. However, the improvement between the coefficients introduced by [10] and the coefficients introduced by [2, 12] is more nuanced, and is mainly observed on heavy-tailed distributions. Yet, the application of those polynomial coefficients to Turbo-Muon yields a negative impact. We hypothesize the root cause to be due to the assumption about the minimum singular value, required to compute the coefficients. Therefore, we leave the computation of optimal coefficients for Turbo-Muon as potential future work.
<figure><img src="image_18.png" /><figcaption>Figure 10. Coefficients from [2] are suboptimal when combined with AOL-preconditioning. We recomputed the optimal coefficient for each number of iterations, using default parameters ($l = 10^{-3}$, cushion = 0.024, and safety_factor = $2 \times 10^{-2}$). For both Muon+ and Turbo-Muon, we report the performance using Polar Express (PE) and compare it with the original. On heavy-tailed distributions, these coefficients improve the performance of Muon+ but degrade the performance of Turbo-Muon.</figcaption></figure>

## E. Direct comparison with nanoGPT fastest training procedure

While the experiment depicted in Fig. 4b compared Muon, Muon+, and Turbo-Muon, we noted that the nano-GPT speedrun script used the implementation of Muon+ with a different set of NS coefficients from [2, 12] (Depicted as Muon+ (PE) in App. D). Given the additional insights of the experiments of App. D, this choice could be seen as biased in favor of Turbo-Muon. To alleviate any doubts, we reproduced this experiment using the Polar Express factors tested in App. D, which would favor the baseline over Turbo-Muon.

In this setting, we compare Turbo-Muon (PE) with four iterations with Muon+ (PE) with five iterations. order to remove one iteration, we applied the same strategy that was used between Muon+ and Turbo-Muon, which is discussed in App. D. In order to run this training on 4xH100 instead of 8, we used a gradient accumulation of 2 to match the original results. We performed 10 trials in a row in order to measure variance on the final validation loss and the total runtime. This was done for both the baseline and our improved version to obtain comparable results.

<table><caption>Table 3. Direct comparison against the original training procedure. Results reported for 10 trials for each variant.</caption><thead><tr><th>method</th><th>iterations</th><th>val loss</th><th>val loss std</th><th>runtime</th><th>runtime std</th></tr></thead><tbody><tr><td>Muon+ (PE)</td><td>5it</td><td>3.2774</td><td>0.0014</td><td>273.75s</td><td>0.14</td></tr><tr><td>Turbo-Muon (PE)</td><td>4it</td><td>3.2791</td><td>0.0013</td><td>266.65s</td><td>0.10</td></tr></tbody></table>

Interestingly, we can observe a degradation of only 0.0017 in the final loss. These results can be observed through the lenses of observations made in App. D: where we observed that factors obtained from [2, 12] underperformed when combined with AOL preconditioning. However, this degradation is smaller than the degradation observed when removing one iteration as done in Fig. 4b.