Researchers at Tilde Research have released Aurora, a new optimizer for training neural networks that addresses a structural flaw in the widely-used Muon optimizer. The flaw quietly kills off a significant fraction of MLP neurons during training and keeps them permanently dead. Aurora comes with a 1.1B parameter pretraining experiment, a new state-of-the-art result on the modded-nanoGPT speedrun benchmark, and open codes.

What is Muon?

To understand Aurora, it helps to first understand Muon. The Muon optimizer attracted attention in the ML community after outperforming AdamW in wall-clock time to convergence on the nanoGPT speedrun competition — a community benchmark that measures how fast you can train a GPT-style model to a target validation loss. Since then, Muon has been adopted in frontier-scale model training by several research groups.

Muon’s key algorithmic step is computing the polar factor of the gradient matrix. For a gradient matrix G with thin Singular Value Decomposition (SVD) G = UΣVᵀ, Muon computes polar(G) = UVᵀ, which is the closest semi-orthogonal matrix to G in the Frobenius norm. This orthogonalized gradient is then used to update the weights: W ← W − η UVᵀ for a learning rate η. The use of matmul-only iterative algorithms to compute the polar factor is what makes Muon practical at scale.

The NorMuon Puzzle: Row Normalization Helps, But Why?

Before Aurora, NorMuon led the modded-nanoGPT speedrun. It introduced a row-normalization step—similar to Adam’s per-parameter scaling—that adjusted the polar factor by its inverse RMS norm. While this often pulls the update away from a strictly orthogonal gradient, NorMuon still yields impressive results. The Tilde team set out to understand exactly what gap in Muon’s formulation NorMuon was addressing.

The Core Problem: Row-Norm Anisotropy and Neuron Death in Tall Matrices

The research team discovered that the Muon optimizer unintentionally “kills” a large portion of neurons in tall weight matrices, such as those found in SwiGLU-based MLP layers. Because it is mathematically impossible for these specific matrix shapes to stay perfectly orthogonal while keeping row updates even, the optimizer ends up giving massive updates to some neurons while virtually ignoring others. This results in a “death spiral” where under-performing neurons receive less signal over time, eventually becoming permanently inactive.

The research study revealed that by the 500th training step, more than one in four neurons are effectively dead. This isn’t just a local issue; the lack of activity in these neurons starves subsequent layers of necessary data, spreading the inefficiency throughout the model. Aurora solves this by using a new mathematical approach that enforces uniform updates across all neurons without sacrificing the benefits of orthogonalization.

The Intermediate Step: U-NorMuon

Before arriving at Aurora, the research introduces an intermediate fix called U-NorMuon. The key observation is that NorMuon normalizes each row to unit norm (norm = 1), but this is actually the wrong target for a tall matrix. For a column-orthogonal tall matrix, the mathematically correct average row norm is √(n/m), not 1. U-NorMuon corrects this by normalizing tall matrix rows to have norm √(n/m) instead of 1.

In experiments at 340M scale, U-NorMuon outperforms both Muon and standard NorMuon and completely eliminates the neuron death phenomenon — leverage scores become approximately isotropic throughout training. Crucially, U-NorMuon propagates this benefit to layers it doesn’t directly touch: keeping up/gate rows alive ensures isotropic gradient flow into the down-projection, stabilizing its column leverage without any direct intervention.

However, U-NorMuon still has a problem: it forcefully overrides the polar factor with uniform row norms, sacrificing polar factor precision, which is both theoretically undesirable and empirically costly in the Muon framework (the paper shows that Muon achieves monotonically lower loss with more precise orthogonalization). This is the motivation for Aurora.

Aurora: Steepest Descent Under Two Joint Constraints

Aurora reformulates the update-selection problem from scratch. Rather than running orthogonalization and then patching it with row normalization, Aurora asks: what is the optimal update under the joint constraint of left semi-orthogonality and uniform row norms?

Formally, for tall matrices, Aurora solves:

$U ∗ =arg U max ​ Tr(G ⊤ U)s.t.U ⊤ U=I n ​ ,∥U i: ​ ∥ 2 = m n ​ ∀i$

The research shows that these two constraints together force all singular values of U to exactly equal 1. This means the joint constraint still produces a valid left semi-orthogonal update, not a compromised one. This is the key insight that separates Aurora from NorMuon and U-NorMuon: it achieves row-norm uniformity and orthogonality simultaneously rather than trading one off against the other.

The research also provides two algorithmic implementations of Aurora’s solution. The Riemannian Aurora uses a gradient projection approach restricted to the joint Stiefel/equal-row-leverage manifold. The vanilla Aurora is a simpler, more practical implementation. Both are open-sourced. For non-tall (wide and square) matrices, row-norm uniformity is already implied by orthogonality, so Aurora leaves those parameters unchanged.

Results

Aurora was used to train a 1.1B model that achieves 100x data efficiency on open-source internet data and outperforms larger models on general evals like HellaSwag. At 1B scale, Aurora achieves large gains over both Muon and NorMuon. On the modded-nanoGPT optimization speedrun, Aurora’s submitted run outperforms the prior state-of-the-art (which was NorMuon). Untuned Aurora carries only a 6% compute overhead over traditional Muon and is designed as a drop-in replacement.

The research team also found that Aurora’s performance gains scale with MLP width, suggesting it is particularly effective for networks with large MLP expansion factors — which is consistent with the neuron death hypothesis, since wider MLPs have more tall matrices and more opportunity for leverage anisotropy to compound.

Marktechpost’s Visual Explainer

.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}
#ag2 *{box-sizing:border-box;margin:0;padding:0}
#ag2{font-family:var(–font-sans);padding:1.5rem 0}
#ag2 .phase-bar{display:flex;border:1px solid #000;overflow:hidden;margin-bottom:1.25rem}
#ag2 .pseg{flex:1;padding:5px 4px;font-size:10px;text-align:center;border-right:1px solid #000;letter-spacing:.06em;text-transform:uppercase;color:#555;transition:background .15s,color .15s}
#ag2 .pseg:last-child{border-right:none}
#ag2 .pseg.on{background:#000;color:#fff}
#ag2 .ngrid{display:grid;grid-template-columns:repeat(8,1fr);gap:3px}
#ag2 .cell{aspect-ratio:1;transition:background .25s}
#ag2 .dead{background:#f3f4f6;border:1px solid #d1d5db}
#ag2 .play-btn{border:1px solid #000;background:#fff;padding:5px 14px;font-size:12px;cursor:pointer;color:#000;font-family:inherit;letter-spacing:.04em}
#ag2 .play-btn:hover{background:#000;color:#fff}
#ag2 .grid-panel{border:1px solid #000;padding:14px}
#ag2 .grid-panel.aurora{border-color:#1d4ed8}
#ag2 .panel-title{font-size:11px;font-weight:500;letter-spacing:.09em;text-transform:uppercase;color:#000}
#ag2 .panel-title.blue{color:#1d4ed8}
#ag2 .stat{font-size:11px;color:#555}
#ag2 .note{font-size:11px;color:#555;margin-top:8px;line-height:1.5}
#ag2 .note.blue{color:#1d4ed8}
#ag2 .leg-row{display:flex;gap:1rem;align-items:center;flex-wrap:wrap}
#ag2 .leg-item{display:flex;align-items:center;gap:5px}
#ag2 .leg-dot{width:13px;height:13px;flex-shrink:0}
#ag2 .leg-label{font-size:11px;color:#555}
#ag2 .leg-section{font-size:10px;text-transform:uppercase;letter-spacing:.08em;color:#aaa;min-width:40px}

Aurora vs Muon: interactive guide showing neuron death during model training, corrected version

const N = 64;
function sr(s){const x=Math.sin(s+1)*10000;return x-Math.floor(x);}

const dstep = Array.from({length:N},(_,i)=>
sr(i*7+13)<0.27 ? Math.floor(60+sr(i*3+5)*400) : Infinity
);

function blueCell(lev){
const t=Math.max(0,Math.min(lev,1));
return `rgb(${Math.round(191+(29-191)*t)},${Math.round(219+(78-219)*t)},${Math.round(254+(216-254)*t)})`;
}

function buildGrid(id){
const g=document.getElementById(id);
g.innerHTML='';
for(let i=0;i{
const on=step>=lo&&(i===phases.length-1?step<=10000:step=lo&&step=6000) phIdx=4;

let dead=0;
for(let i=0;i<N;i++) if(dstep[i]<=step) dead++;

for(let i=0;i<N;i++){
const mc=document.getElementById(`ag2-mgridc${i}`);
const ac=document.getElementById(`ag2-agridc${i}`);
const isDead=dstep[i]0?’stat’ + ‘ alert’:’stat’;
dl.style.fontWeight=dead>0?’500′:’400′;
dl.style.color=dead>0?’#000′:’#555′;
document.getElementById(‘ag2-mnote’).textContent=phNotes[phIdx];

drawChart(‘ag2-mc’,step,false,dead);
drawChart(‘ag2-ac’,step,true,0);
}

function drawChart(id,step,isAurora,deadCount){
const canvas=document.getElementById(id);
const W=Math.max(canvas.getBoundingClientRect().width,120);
const H=72;
canvas.width=W*devicePixelRatio;
canvas.height=H*devicePixelRatio;
canvas.style.height=H+’px’;
const ctx=canvas.getContext(‘2d’);
ctx.scale(devicePixelRatio,devicePixelRatio);
ctx.clearRect(0,0,W,H);

const bins=12;
const counts=new Array(bins).fill(0);

for(let i=0;i<N;i++){
let lev;
if(isAurora){
lev=0.65+sr(i*5+1)*0.1;
} else {
const isDead=dstep[i]{
if(c===0) return;
const bh=(c/maxC)*(axisY-4);
const x=i*bw+1;
const y=axisY-bh;
const t=i/(bins-1);
ctx.fillStyle=(!isAurora&&i0)?’#e5e7eb’:blueCell(isAurora?0.7:t*0.85+0.15);
ctx.fillRect(x,y,Math.max(bw-2,1),bh);
});

ctx.strokeStyle=”#e5e7eb”;
ctx.lineWidth=0.5;
ctx.beginPath();ctx.moveTo(0,axisY);ctx.lineTo(W,axisY);ctx.stroke();

ctx.fillStyle=”#9ca3af”;
ctx.font=”9px sans-serif”;
ctx.fillText(‘0’,1,H-3);
ctx.fillText(‘high’,W-22,H-3);

if(!isAurora&&deadCount>0){
ctx.fillStyle=”#9ca3af”;
ctx.fillText(‘← dead’,2,axisY-3);
}
}

const slider=document.getElementById(‘ag2-slider’);
slider.addEventListener(‘input’,()=>update(parseInt(slider.value)));

let playing=false,timer=null;
const playBtn=document.getElementById(‘ag2-play’);

function tick(){
const cur=parseInt(slider.value);
const next=cur>=10000?0:Math.min(cur+100,10000);
slider.value=next;
update(next);
if(playing) timer=setTimeout(tick,35);
}

playBtn.addEventListener(‘click’,()=>{
playing=!playing;
playBtn.textContent=playing?’⏸ pause’:’▶ play’;
if(playing) tick(); else clearTimeout(timer);
});

update(0);

let rt;
window.addEventListener(‘resize’,()=>{
clearTimeout(rt);
rt=setTimeout(()=>{
const s=parseInt(slider.value);
const d=Array.from({length:N},(_,i)=>dstep[i]a+b,0);
drawChart(‘ag2-mc’,s,false,d);
drawChart(‘ag2-ac’,s,true,0);
},100);
});

Key Takeaways

• Muon’s polar factor update inherits row-norm anisotropy on tall matrices, causing over 25% of MLP neurons to permanently die as early as step 500 of training.
• Aurora solves this by finding the optimal update under a joint constraint of left semi-orthogonality and uniform row norms — achieving both simultaneously rather than trading one off against the other.
• At 1.1B scale, Aurora achieves 100x data efficiency on open-source internet data, outperforms larger models on HellaSwag, and sets a new SoTA on the modded-nanoGPT speedrun.
• Aurora is a near-drop-in replacement for Muon with only 6% compute overhead, and its gains scale with MLP width.

Check out the Paper and GitHub Repo Also, feel free to follow us on Twitter and don’t forget to join our 150k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us

The post Tilde Research Introduces Aurora: A Leverage-Aware Optimizer That Fixes a Hidden Neuron Death Problem in Muon appeared first on MarkTechPost.

Nations like Kenya are looking to scale up their ability to meet Africa’s artificial intelligence needs. Recently, the likes of Zambia, Zimbabwe and most recently Ghana turned down deals to store citizens’ data in the United States. For France, a summit like the Africa Forward one in the Kenyan capital Nairobi is an opportunity to offer a third way between US and Chinese tech. We bring you a special edition of The Debate from the summit in Nairobi.

British Prime Minister Keir Starmer is facing the most serious political challenge of his leadership after significant Labour Party losses in local elections triggered growing internal unrest. More than 70 Labour lawmakers have publicly called for Starmer to either announce a timetable for his departure or resign altogether, reflecting widening dissatisfaction within the governing party. […]

The post Keir Starmer Faces Growing Pressure as Labour Leadership Questions Intensify appeared first on Modern Diplomacy.

Sony’s Reon Pocket Pro Plus uses a cooled metal plate on your neck, promising stronger cooling, better stability, and up to 10 hours of battery life.

A US transparency advocacy group has opened a temporary exhibition in New York with only one text on display: a print-out of all the files released by the US Department of Justice — roughly 3.5 million pages — relating to financier and convicted sex criminal Jeffrey Epstein.