diff --git a/app/dist/index.html b/app/dist/index.html
index f62a03ca755ff06e25366c9516df89b96271c41c..675e2b77c8e6f0d3b50c7bbead3f6ed159878be2 100644
--- a/app/dist/index.html
+++ b/app/dist/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html><html lang="en" data-theme="light" data-toc-auto-collapse="1"> <head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Maintain the unmaintainable:
 1M python loc, 400+ models</title><meta name="description" content="A peek into software engineering for the transformers library"><link rel="canonical" href="http://localhost:4321/"><meta property="og:type" content="article"><meta property="og:title" content="Maintain the unmaintainable:
-1M python loc, 400+ models"><meta property="og:description" content="A peek into software engineering for the transformers library"><meta property="og:url" content="http://localhost:4321/"><meta property="og:image" content="/thumb.auto.jpg"><meta property="article:published_time" content="October 2, 2025"><meta property="article:author" content="Pablo Montalvo"><meta property="article:author" content="Lysandre Debut"><meta property="article:author" content="Pedro Cuenca"><meta property="article:author" content="Yoni Gozlan"><meta name="twitter:card" content="summary_large_image"><meta name="twitter:title" content="Maintain the unmaintainable:
-1M python loc, 400+ models"><meta name="twitter:description" content="A peek into software engineering for the transformers library"><meta name="twitter:image" content="/thumb.auto.jpg"><script type="application/ld+json">{"@context":"https://schema.org","@type":"Article","headline":"Maintain the unmaintainable:\n1M python loc, 400+ models","description":"A peek into software engineering for the transformers library","datePublished":"October 2, 2025","author":[{"@type":"Person","name":"Pablo Montalvo"},{"@type":"Person","name":"Lysandre Debut"},{"@type":"Person","name":"Pedro Cuenca"},{"@type":"Person","name":"Yoni Gozlan"}],"keywords":"transformers, engineering, design-philosophy","mainEntityOfPage":"http://localhost:4321/","image":["/thumb.auto.jpg"]}</script><script>
+1M python loc, 400+ models"><meta property="og:description" content="A peek into software engineering for the transformers library"><meta property="og:url" content="http://localhost:4321/"><meta property="og:image" content="/thumb.auto.jpg"><meta property="article:published_time" content="October 6, 2025"><meta property="article:author" content="Pablo Montalvo"><meta property="article:author" content="Lysandre Debut"><meta property="article:author" content="Pedro Cuenca"><meta property="article:author" content="Yoni Gozlan"><meta name="twitter:card" content="summary_large_image"><meta name="twitter:title" content="Maintain the unmaintainable:
+1M python loc, 400+ models"><meta name="twitter:description" content="A peek into software engineering for the transformers library"><meta name="twitter:image" content="/thumb.auto.jpg"><script type="application/ld+json">{"@context":"https://schema.org","@type":"Article","headline":"Maintain the unmaintainable:\n1M python loc, 400+ models","description":"A peek into software engineering for the transformers library","datePublished":"October 6, 2025","author":[{"@type":"Person","name":"Pablo Montalvo"},{"@type":"Person","name":"Lysandre Debut"},{"@type":"Person","name":"Pedro Cuenca"},{"@type":"Person","name":"Yoni Gozlan"}],"keywords":"transformers, engineering, design-philosophy","mainEntityOfPage":"http://localhost:4321/","image":["/thumb.auto.jpg"]}</script><script>
       (() => {
         try {
           const saved = localStorage.getItem("theme");
@@ -13,7 +13,7 @@
         } catch {}
       })();
     </script><script type="module" src="/scripts/color-palettes.js"></script><!-- TO MANAGE PROPERLY --><script src="https://cdn.plot.ly/plotly-3.0.0.min.js" charset="utf-8"></script><link rel="stylesheet" href="/_astro/index.C8LanvBP.css"><script type="module" src="/_astro/hoisted.DK-CdsVg.js"></script>
-<script type="module" src="/_astro/page.CH0W_C1Z.js"></script></head> <body> <button id="theme-toggle" aria-label="Toggle color theme" data-astro-cid-x3pjskd3> <svg class="icon light" width="20" height="20" viewBox="0 0 24 24" aria-hidden="true" focusable="false" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" data-astro-cid-x3pjskd3> <circle cx="12" cy="12" r="5" data-astro-cid-x3pjskd3></circle> <line x1="12" y1="1" x2="12" y2="4" data-astro-cid-x3pjskd3></line> <line x1="12" y1="20" x2="12" y2="23" data-astro-cid-x3pjskd3></line> <line x1="1" y1="12" x2="4" y2="12" data-astro-cid-x3pjskd3></line> <line x1="20" y1="12" x2="23" y2="12" data-astro-cid-x3pjskd3></line> <line x1="4.22" y1="4.22" x2="6.34" y2="6.34" data-astro-cid-x3pjskd3></line> <line x1="17.66" y1="17.66" x2="19.78" y2="19.78" data-astro-cid-x3pjskd3></line> <line x1="4.22" y1="19.78" x2="6.34" y2="17.66" data-astro-cid-x3pjskd3></line> <line x1="17.66" y1="6.34" x2="19.78" y2="4.22" data-astro-cid-x3pjskd3></line> </svg> <svg class="icon dark" width="20" height="20" viewBox="0 0 24 24" aria-hidden="true" focusable="false" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" data-astro-cid-x3pjskd3> <path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z" data-astro-cid-x3pjskd3></path> </svg>  </button>  <section class="hero" data-astro-cid-bbe6dxrz> <h1 class="hero-title" data-astro-cid-bbe6dxrz>Maintain the unmaintainable:<br/>1M python loc, 400+ models</h1> <div class="hero-banner" data-astro-cid-bbe6dxrz> <figure class="html-embed"><div class="html-embed__card is-frameless"><div id="frag-xhjmcshfqu"><style>
+<script type="module" src="/_astro/page.CH0W_C1Z.js"></script></head> <body> <button id="theme-toggle" aria-label="Toggle color theme" data-astro-cid-x3pjskd3> <svg class="icon light" width="20" height="20" viewBox="0 0 24 24" aria-hidden="true" focusable="false" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" data-astro-cid-x3pjskd3> <circle cx="12" cy="12" r="5" data-astro-cid-x3pjskd3></circle> <line x1="12" y1="1" x2="12" y2="4" data-astro-cid-x3pjskd3></line> <line x1="12" y1="20" x2="12" y2="23" data-astro-cid-x3pjskd3></line> <line x1="1" y1="12" x2="4" y2="12" data-astro-cid-x3pjskd3></line> <line x1="20" y1="12" x2="23" y2="12" data-astro-cid-x3pjskd3></line> <line x1="4.22" y1="4.22" x2="6.34" y2="6.34" data-astro-cid-x3pjskd3></line> <line x1="17.66" y1="17.66" x2="19.78" y2="19.78" data-astro-cid-x3pjskd3></line> <line x1="4.22" y1="19.78" x2="6.34" y2="17.66" data-astro-cid-x3pjskd3></line> <line x1="17.66" y1="6.34" x2="19.78" y2="4.22" data-astro-cid-x3pjskd3></line> </svg> <svg class="icon dark" width="20" height="20" viewBox="0 0 24 24" aria-hidden="true" focusable="false" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" data-astro-cid-x3pjskd3> <path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z" data-astro-cid-x3pjskd3></path> </svg>  </button>  <section class="hero" data-astro-cid-bbe6dxrz> <h1 class="hero-title" data-astro-cid-bbe6dxrz>Maintain the unmaintainable:<br/>1M python loc, 400+ models</h1> <div class="hero-banner" data-astro-cid-bbe6dxrz> <figure class="html-embed"><div class="html-embed__card is-frameless"><div id="frag-mcf2krsdweb"><style>
 @import url('https://fonts.googleapis.com/css2?family=Inter:wght@500;600&display=swap');
 
 .banner-container {
@@ -212,7 +212,7 @@ document.addEventListener('DOMContentLoaded', () => {
 // Fit on first paint (no zoom UI for banner)
 window.addEventListener('resize', () => location.reload());
 </script>
-</div></div></figure> <p class="hero-desc" data-astro-cid-bbe6dxrz>A peek into software engineering for the transformers library</p> </div> </section> <header class="meta" aria-label="Article meta information" data-astro-cid-bbe6dxrz> <div class="meta-container" data-astro-cid-bbe6dxrz> <div class="meta-container-cell" data-astro-cid-bbe6dxrz> <h3 data-astro-cid-bbe6dxrz>Authors</h3> <div class="authors" data-astro-cid-bbe6dxrz>  <span data-astro-cid-bbe6dxrz> <a href="https://huggingface.co/Molbap" data-astro-cid-bbe6dxrz>Pablo Montalvo</a>  </span> <span data-astro-cid-bbe6dxrz>,&nbsp;</span> <span data-astro-cid-bbe6dxrz> <a href="https://huggingface.co/Lysandre" data-astro-cid-bbe6dxrz>Lysandre Debut</a>  </span> <span data-astro-cid-bbe6dxrz>,&nbsp;</span> <span data-astro-cid-bbe6dxrz> <a href="https://huggingface.co/pcuenq" data-astro-cid-bbe6dxrz>Pedro Cuenca</a>  </span> <span data-astro-cid-bbe6dxrz>,&nbsp;</span> <span data-astro-cid-bbe6dxrz> <a href="https://huggingface.co/yonigozlan" data-astro-cid-bbe6dxrz>Yoni Gozlan</a>  </span>  </div> </div> <div class="meta-container-cell meta-container-cell--affiliations" data-astro-cid-bbe6dxrz> <h3 data-astro-cid-bbe6dxrz>Affiliation</h3> <p data-astro-cid-bbe6dxrz> <a href="https://huggingface.co" target="_blank" rel="noopener noreferrer" data-astro-cid-bbe6dxrz> Hugging Face </a> </p> </div>  <div class="meta-container-cell meta-container-cell--published" data-astro-cid-bbe6dxrz> <h3 data-astro-cid-bbe6dxrz>Published</h3> <p data-astro-cid-bbe6dxrz>October 2, 2025</p> </div> <!-- {doi && (
+</div></div></figure> <p class="hero-desc" data-astro-cid-bbe6dxrz>A peek into software engineering for the transformers library</p> </div> </section> <header class="meta" aria-label="Article meta information" data-astro-cid-bbe6dxrz> <div class="meta-container" data-astro-cid-bbe6dxrz> <div class="meta-container-cell" data-astro-cid-bbe6dxrz> <h3 data-astro-cid-bbe6dxrz>Authors</h3> <div class="authors" data-astro-cid-bbe6dxrz>  <span data-astro-cid-bbe6dxrz> <a href="https://huggingface.co/Molbap" data-astro-cid-bbe6dxrz>Pablo Montalvo</a>  </span> <span data-astro-cid-bbe6dxrz>,&nbsp;</span> <span data-astro-cid-bbe6dxrz> <a href="https://huggingface.co/Lysandre" data-astro-cid-bbe6dxrz>Lysandre Debut</a>  </span> <span data-astro-cid-bbe6dxrz>,&nbsp;</span> <span data-astro-cid-bbe6dxrz> <a href="https://huggingface.co/pcuenq" data-astro-cid-bbe6dxrz>Pedro Cuenca</a>  </span> <span data-astro-cid-bbe6dxrz>,&nbsp;</span> <span data-astro-cid-bbe6dxrz> <a href="https://huggingface.co/yonigozlan" data-astro-cid-bbe6dxrz>Yoni Gozlan</a>  </span>  </div> </div> <div class="meta-container-cell meta-container-cell--affiliations" data-astro-cid-bbe6dxrz> <h3 data-astro-cid-bbe6dxrz>Affiliation</h3> <p data-astro-cid-bbe6dxrz> <a href="https://huggingface.co" target="_blank" rel="noopener noreferrer" data-astro-cid-bbe6dxrz> Hugging Face </a> </p> </div>  <div class="meta-container-cell meta-container-cell--published" data-astro-cid-bbe6dxrz> <h3 data-astro-cid-bbe6dxrz>Published</h3> <p data-astro-cid-bbe6dxrz>October 6, 2025</p> </div> <!-- {doi && (
       <div class="meta-container-cell">
         <h3>DOI</h3>
         <p><a href={`https://doi.org/${doi}`} target="_blank" rel="noopener noreferrer">{doi}</a></p>
@@ -453,16 +453,17 @@ Download PDF
     document.addEventListener('DOMContentLoaded', buildTOC, { once: true });
   } else { buildTOC(); }
 </script>  <main> <h2 id="preface"><a href="#preface">Preface</a></h2>
-<p>One million lines of <code>python</code> code. Through them, the <code>transformers</code> library supports more than 400 model architectures, from state-of-the-art LLMs and VLMs to specialized models for audio, video, and tables.</p>
-<p>Built on <code>PyTorch</code>, transformers is a foundational tool for modern LLM usage, research, education, and tens of thousands of other open-source projects. Each AI model is added by the community, harmonized into a consistent interface, and tested daily on a CI to ensure reproducibility.</p>
+<p>One million lines of <code>Python</code> code. Through them, the <a href="https://github.com/huggingface/transformers"><code>transformers</code></a> library supports more than 400 model architectures, from state-of-the-art LLMs and VLMs to specialized models for audio, video, and tables.</p>
+<p>Built on <code>PyTorch</code>, it’s a foundational tool for modern LLM usage, research, education, and tens of thousands of other open-source projects. Each AI model is added by the community, harmonized into a consistent interface, and tested daily on a CI to ensure reproducibility.</p>
 <p>This scale presents a monumental engineering challenge.</p>
-<p>How do you keep such a ship afloat, made of so many moving, unrelated parts, contributed to by a buzzing hivemind? Especially as the pace of ML research accelerates? We receive constant feedback on everything from function signatures with hundreds of arguments to duplicated code and optimization concerns, and we listen to all of it, or try to. The library’s usage keeps on growing, and we are a small team of maintainers and contributors, backed by hundreds of open-source community members.
+<p>How do you keep such a ship afloat, made of so many moving, unrelated parts, contributed to by a buzzing hivemind? Especially as the pace of ML research accelerates?</p>
+<p>We receive constant feedback on everything from function signatures with hundreds of arguments to duplicated code and optimization concerns, and we listen to all of it, or try to. The library’s usage keeps on growing, and we are a small team of maintainers and contributors, backed by hundreds of open-source community members.
 We continue to support all new models and expect to do so for the foreseeable future.</p>
-<p>This post dissects the design philosophy that makes this possible. It’s the result of an evolution from our older principles, detailed on our previous <a href="https://huggingface.co/docs/transformers/en/philosophy">philosophy</a> page, as well as its accompanying <a href="https://huggingface.co/blog/transformers-design-philosophy">blog post from 2022</a>. More recently (and we strongly recommend the read) we published a blog post about <a href="https://huggingface.co/blog/faster-transformers">recent upgrades to transformers</a>, focusing on what makes the library faster today. All of these developments are only made possible thanks to these principles.</p>
+<p>This post dissects the design philosophy that makes this possible. It’s the result of an evolution from our older principles, detailed on our previous <a href="https://huggingface.co/docs/transformers/en/philosophy">philosophy</a> page, as well as its accompanying <a href="https://huggingface.co/blog/transformers-design-philosophy">blog post from 2022</a>. More recently (and we strongly recommend the read) we publish a blog post about <a href="https://huggingface.co/blog/faster-transformers">recent upgrades to transformers</a>, focusing on what makes the library faster today. All of these developments are only made possible thanks to these principles.</p>
 <p>We formalize and articulate the “tenets” that have been guiding our development, demonstrate how they are implemented in code, and show the measurable impact they have on the library’s sustainability and growth.</p>
 <p>For any OSS maintainer, power user, or contributor, this is the map to understanding, using, and building upon <code>transformers</code>, but not only: any project of comparable size will require you to make deep choices, not only on design and choice of abstraction, but on the very mindset of the software you are building. These tenets may or may not be applicable to your project, but they provide a glimpse on how we work that could be helpful or inspirational.</p>
 <p>Conventions used throughout this post:</p>
-<p><span class="glossary-term " style="" data-tooltip-id="tenet-gcuf06n8m8m" onmouseenter="window.showTenetTooltip(event, 'tenet-gcuf06n8m8m')" onmousemove="window.updateTenetTooltip(event, 'tenet-gcuf06n8m8m')" onmouseleave="window.hideTenetTooltip('tenet-gcuf06n8m8m')">Tenets exemplified</span><span id="tenet-gcuf06n8m8m" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">source-of-truth</span> <span class="glossary-tooltip__definition">Model implementations should be reliable, reproducible, and faithful to original performances.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p><span class="glossary-term " style="" data-tooltip-id="tenet-ntkidkv4r4" onmouseenter="window.showTenetTooltip(event, 'tenet-ntkidkv4r4')" onmousemove="window.updateTenetTooltip(event, 'tenet-ntkidkv4r4')" onmouseleave="window.hideTenetTooltip('tenet-ntkidkv4r4')">Tenets exemplified</span><span id="tenet-ntkidkv4r4" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">source-of-truth</span> <span class="glossary-tooltip__definition">Model implementations should be reliable, reproducible, and faithful to original performances.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -493,13 +494,13 @@ if (!window.tenetTooltipInitialized) {
 <p><a href="https://huggingface.co/blog/welcome-openai-gpt-oss">External links</a> to articles will help you solidify your knowledge.</p>
 <p><a href="#generated-modeling">Several interactive visualisations</a> are available as you go - scroll, zoom, drag away to explore them.</p>
 <div class="note note--neutral" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>Breadcrumb boxes summarize what you just learned, connect it to the tenets, and point to what’s coming <strong>Next</strong>. Think of them as narrative signposts to help you keep track.</p> </div> </div> </div> </div> 
-<p>We will get started by enumerating the tenets. Then we’ll look at concrete examples that show how they shape our decision-making. These examples are necessarily detailed, and sometimes complex, because they illustrate the challenges to maintain and grow a large codebase that caters to multiple collectives, has millions of users, hundreds of contributors, and always strives for simplicity and consistency.</p>
+<p>We get started by enumerating the tenets. Then we look at concrete examples that show how they shape our decision-making. These examples are necessarily detailed, and sometimes complex, because they illustrate the challenges to maintain and grow a large codebase that caters to multiple collectives, has millions of users, hundreds of contributors, and always strives for simplicity and consistency.</p>
 <h2 id="the-core-tenets-of-transformers"><a href="#the-core-tenets-of-transformers">The core tenets of transformers</a></h2>
 <p>We summarize the foundations on which we’ve built everything, and write the “tenets” of the library.  They behave like <em>software interfaces</em>, hence it is crucial that they are explicitly written down. However opinionated they are, they have evolved over time.</p>
 <p>These principles were not decided in a vacuum. The library <em>evolved</em> towards them, and once they <em>emerged</em>, they were recognized as critical.</p>
-<div class="tenet-list"><ol><li class="tenet"><a id="source-of-truth"></a><strong>Source of Truth</strong><p>We aim to be a <a href="https://huggingface.co/blog/transformers-model-definition">source of truth for all model definitions</a>. This is more of a goal than a tenet, but it strongly guides our decisions. Model implementations should be reliable, reproducible, and faithful to the original implementations. If we are successful, they should become reference baselines for the ecosystem, so they’ll be easily adopted by downstream libraries and projects. It’s much easier for a project to always refer to the transformers implementation, than to learn a different research codebase every time a new architecture is released.</p><em>This overarching guideline ensures quality and reproducibility across all models in the library, and aspires to make the community work easier.</em></li><li class="tenet"><a id="one-model-one-file"></a><strong>One Model, One File</strong><p>All inference and training core logic has to be visible, top‑to‑bottom, to maximize each model’s hackability.</p><em>Every model should be completely understandable and hackable by reading a single file from top to bottom.</em></li><li class="tenet"><a id="code-is-product"></a><strong>Code is Product</strong><p>Optimize for reading, diffing, and tweaking, our users are power users. Variables should be explicit, full words, even several words, readability is primordial.</p><em>Code quality matters as much as functionality - optimize for human readers, not just computers.</em></li><li class="tenet"><a id="standardize-dont-abstract"></a><strong>Standardize, Don’t Abstract</strong><p>If it’s model behavior, keep it in the file; use abstractions only for generic infra.</p><em>Model-specific logic belongs in the model file, not hidden behind abstractions.</em></li><li class="tenet"><a id="do-repeat-yourself"></a><strong>DRY* (DO Repeat Yourself)</strong><p>Copy when it helps users; keep successors in sync without centralizing behavior.</p><p><b>Evolution:</b></p><p> With the introduction and global adoption of <a href="#modular">modular</a> transformers, we do not repeat any logic in the modular files, but end user files remain faithful to the original tenet.</p><em>Strategic duplication can improve readability and maintainability when done thoughtfully.</em></li><li class="tenet"><a id="minimal-user-api"></a><strong>Minimal User API</strong><p>Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. We want the least amount of codepaths. Reading should be obvious, configurations should be obvious.</p><em>Keep the public interface simple and predictable, users should know what to expect.</em></li><li class="tenet"><a id="backwards-compatibility"></a><strong>Backwards Compatibility</strong><p>Evolve by additive standardization, never break public APIs.</p><p>Any artifact that was once on the hub and loadable with transformers should be usable indefinitely with the same interface. Further, public methods should not change to avoid breaking dependencies. If we do deprecate something, it’s with very long cycles beforehand.</p><em>Once something is public, it stays public, evolution through addition, not breaking changes.</em></li><li class="tenet"><a id="consistent-public-surface"></a><strong>Consistent Public Surface</strong><p>Same argument names, same outputs, hidden states and attentions exposed, enforced by tests. This is a goal as well as a tenet.</p><em>All models should feel familiar - consistent interfaces reduce cognitive load.</em></li></ol></div>
+<div class="tenet-list"><ol><li class="tenet"><a id="source-of-truth"></a><strong>Source of Truth</strong><p>We aim be the <a href="https://huggingface.co/blog/transformers-model-definition">source of truth for all model definitions</a>. This is not a tenet, but something that guides our decisions. Model implementations should be reliable, reproducible, and faithful to the original performances.</p><em>This overarching guideline ensures quality and reproducibility across all models in the library.</em></li><li class="tenet"><a id="one-model-one-file"></a><strong>One Model, One File</strong><p>All inference and training core logic has to be visible, top‑to‑bottom, to maximize each model’s hackability.</p><em>Every model should be understandable and hackable by reading a single file from top to bottom.</em></li><li class="tenet"><a id="code-is-product"></a><strong>Code is the Product</strong><p>Optimize for reading, diff-ing, and tweaking, our users are power users. Variables can be explicit, full words, even several words, readability is primordial.</p><em>Code quality matters as much as functionality - optimize for human readers, not just computers.</em></li><li class="tenet"><a id="standardize-dont-abstract"></a><strong>Standardize, Don’t Abstract</strong><p>If it’s model behavior, keep it in the file; abstractions are only for generic infra.</p><em>Model-specific logic belongs in the model file, not hidden behind abstractions.</em></li><li class="tenet"><a id="do-repeat-yourself"></a><strong>DRY* (DO Repeat Yourself)</strong><p>Copy when it helps users; keep successors in sync without centralizing behavior.</p><p><b>Evolution:</b></p><p> With the introduction and global adoption of <a href="#modular">modular</a> transformers, we do not repeat any logic in the modular files, but end user files remain faithful to the original tenet.</p><em>Strategic duplication can improve readability and maintainability when done thoughtfully.</em></li><li class="tenet"><a id="minimal-user-api"></a><strong>Minimal User API</strong><p>Config, model, pre-processing; from_pretrained, save_pretrained, push_to_hub. We want the least amount of codepaths. Reading should be obvious, configurations should be obvious.</p><em>Keep the public interface simple and predictable, users should know what to expect.</em></li><li class="tenet"><a id="backwards-compatibility"></a><strong>Backwards Compatibility</strong><p>Evolve by additive standardization, never break public APIs.</p><p>Any artifact that was once on the hub and worked with transformers should be usable indefinitely with the same interface. Further, public methods should not change to avoid breaking dependencies.</p><em>Once something is public, it stays public, evolution through addition, not breaking changes.</em></li><li class="tenet"><a id="consistent-public-surface"></a><strong>Consistent Public Surface</strong><p>Same argument names, same outputs, hidden states and attentions exposed, enforced by tests. This is a goal as well as a tenet.</p><em>All models should feel familiar - consistent interfaces reduce cognitive load.</em></li></ol></div>
 <p>When a PR is merged, it is because the contribution is worthwhile, and because the <code>transformers</code> team finds the design of the contribution to be aligned with the tenets.</p>
-<p>Does all the code in the library strictly follow these tenets? No. The library is a gigantic house with connected nooks, corridors, crannies everywhere, built by thousands of different workers. We <em>try</em> to make it so all the code added is compliant, because if we fail and merge it, we cannot change it lest we break <span class="glossary-term " style="" data-tooltip-id="tenet-2qdxbl889wv" onmouseenter="window.showTenetTooltip(event, 'tenet-2qdxbl889wv')" onmousemove="window.updateTenetTooltip(event, 'tenet-2qdxbl889wv')" onmouseleave="window.hideTenetTooltip('tenet-2qdxbl889wv')">backwards compatibility</span><span id="tenet-2qdxbl889wv" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">backwards-compatibility</span> <span class="glossary-tooltip__definition">Any artifact once on the hub must remain loadable. Breaking changes are unacceptable.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>Does all the code in the library strictly follow these tenets? No. The library is a gigantic house with connected nooks, corridors, crannies everywhere, built by thousands of different workers. We <em>try</em> to make it so all the code added is compliant, because if we fail and merge it, we cannot change it lest we break <span class="glossary-term " style="" data-tooltip-id="tenet-ud541vgupt" onmouseenter="window.showTenetTooltip(event, 'tenet-ud541vgupt')" onmousemove="window.updateTenetTooltip(event, 'tenet-ud541vgupt')" onmouseleave="window.hideTenetTooltip('tenet-ud541vgupt')">backwards compatibility</span><span id="tenet-ud541vgupt" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">backwards-compatibility</span> <span class="glossary-tooltip__definition">Any artifact once on the hub must remain loadable. Breaking changes are unacceptable.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -528,7 +529,7 @@ if (!window.tenetTooltipInitialized) {
 }
 </script>.</p>
 <p>To see what constitutes adherence to the tenets, let’s take the example of code repetition.</p>
-<p>The following function, essential to the implementation of <a href="https://huggingface.co/papers/2104.09864">Rotary Positional Embeddings</a> can be found in more than 70 <code>modeling_&lt;file&gt;.py</code> across <code>src/transformers/models/.</code>  Why keep it? Because we want all the model logic to be <span class="glossary-term " style="" data-tooltip-id="tenet-hdbzhm7gu5b" onmouseenter="window.showTenetTooltip(event, 'tenet-hdbzhm7gu5b')" onmousemove="window.updateTenetTooltip(event, 'tenet-hdbzhm7gu5b')" onmouseleave="window.hideTenetTooltip('tenet-hdbzhm7gu5b')">contained in the modeling file</span><span id="tenet-hdbzhm7gu5b" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>The following function, essential to the implementation of <a href="https://huggingface.co/papers/2104.09864">Rotary Positional Embeddings</a> can be found in more than 70 <code>modeling_&lt;file&gt;.py</code> across <code>src/transformers/models/.</code>  Why keep it? Because we want all the model logic to be <span class="glossary-term " style="" data-tooltip-id="tenet-fx3yccstvte" onmouseenter="window.showTenetTooltip(event, 'tenet-fx3yccstvte')" onmousemove="window.updateTenetTooltip(event, 'tenet-fx3yccstvte')" onmouseleave="window.hideTenetTooltip('tenet-fx3yccstvte')">contained in the modeling file</span><span id="tenet-fx3yccstvte" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -555,7 +556,7 @@ if (!window.tenetTooltipInitialized) {
     tooltip.style.opacity = '0';
   };
 }
-</script>. In order to do that, we <span class="glossary-term " style="" data-tooltip-id="tenet-2cbxd2z5hyp" onmouseenter="window.showTenetTooltip(event, 'tenet-2cbxd2z5hyp')" onmousemove="window.updateTenetTooltip(event, 'tenet-2cbxd2z5hyp')" onmouseleave="window.hideTenetTooltip('tenet-2cbxd2z5hyp')">do repeat ourselves</span><span id="tenet-2cbxd2z5hyp" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">do-repeat-yourself</span> <span class="glossary-tooltip__definition">Strategic duplication can improve readability and maintainability when done thoughtfully.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+</script>. In order to do that, we <span class="glossary-term " style="" data-tooltip-id="tenet-l598dyzqif" onmouseenter="window.showTenetTooltip(event, 'tenet-l598dyzqif')" onmousemove="window.updateTenetTooltip(event, 'tenet-l598dyzqif')" onmouseleave="window.hideTenetTooltip('tenet-l598dyzqif')">do repeat ourselves</span><span id="tenet-l598dyzqif" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">do-repeat-yourself</span> <span class="glossary-tooltip__definition">Strategic duplication can improve readability and maintainability when done thoughtfully.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -589,10 +590,10 @@ if (!window.tenetTooltipInitialized) {
 <span class="line"><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">    x2 </span><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">=</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8"> x[</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF">...</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">, x.shape[</span><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">-</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF">1</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">] </span><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">//</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF"> 2</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8"> :]</span></span>
 <span class="line"><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">    return</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8"> torch.cat((</span><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">-</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">x2, x1), </span><span style="--shiki-light:#E36209;--shiki-dark:#FFAB70">dim</span><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">=-</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF">1</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">)</span></span>
 <span class="line"></span></code></pre></div>
-<p>We want all models to have self-contained modeling code. Every core functionality <em>must</em> be in the modeling code, every non-core functionality <em>can</em> be outside of it.</p>
-<p>This comes at a great cost. For years, we have used what we call the <code>#Copied from...</code> mechanism: we added comments of a specific format documenting that some code was copied from another model, saving time both for the reviewers and for the CI: we had tooling to ensure that the copied blocks remained in sync.</p>
-<p>But the LOC count kept creeping up. Each new model copied over hundreds of lines that we considered largely boilerplate, yet, we could not remove them.</p>
-<p>We needed to separate two principles that were so far intertwined, <span class="glossary-term " style="" data-tooltip-id="tenet-7fkel24q67i" onmouseenter="window.showTenetTooltip(event, 'tenet-7fkel24q67i')" onmousemove="window.updateTenetTooltip(event, 'tenet-7fkel24q67i')" onmouseleave="window.hideTenetTooltip('tenet-7fkel24q67i')">repetition</span><span id="tenet-7fkel24q67i" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">do-repeat-yourself</span> <span class="glossary-tooltip__definition">Strategic duplication can improve readability and maintainability when done thoughtfully.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>We want all models to have self-contained modeling code.</p>
+<p>Each core functionality <em>must</em> be in the modeling code, every non-core functionality <em>can</em> be outside of it.</p>
+<p>This comes as a great cost. Enter the <code>#Copied from...</code> mechanism: for a long time, these comments were indicating that some code was copied from another model, saving time both for the reviewers and for the CI. But the LOC count kept creeping up. Each new model copied over hundreds of lines that we considered largely boilerplate, yet, we could not remove them.</p>
+<p>We need to separate both principles that were so far intertwined, <span class="glossary-term " style="" data-tooltip-id="tenet-lai4b2400hc" onmouseenter="window.showTenetTooltip(event, 'tenet-lai4b2400hc')" onmousemove="window.updateTenetTooltip(event, 'tenet-lai4b2400hc')" onmouseleave="window.hideTenetTooltip('tenet-lai4b2400hc')">repetition</span><span id="tenet-lai4b2400hc" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">do-repeat-yourself</span> <span class="glossary-tooltip__definition">Strategic duplication can improve readability and maintainability when done thoughtfully.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -619,7 +620,7 @@ if (!window.tenetTooltipInitialized) {
     tooltip.style.opacity = '0';
   };
 }
-</script> and <span class="glossary-term " style="" data-tooltip-id="tenet-xxbnlyxdbrr" onmouseenter="window.showTenetTooltip(event, 'tenet-xxbnlyxdbrr')" onmousemove="window.updateTenetTooltip(event, 'tenet-xxbnlyxdbrr')" onmouseleave="window.hideTenetTooltip('tenet-xxbnlyxdbrr')">hackability</span><span id="tenet-xxbnlyxdbrr" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+</script> and <span class="glossary-term " style="" data-tooltip-id="tenet-hyo7rb79mx8" onmouseenter="window.showTenetTooltip(event, 'tenet-hyo7rb79mx8')" onmousemove="window.updateTenetTooltip(event, 'tenet-hyo7rb79mx8')" onmouseleave="window.hideTenetTooltip('tenet-hyo7rb79mx8')">hackabilty</span><span id="tenet-hyo7rb79mx8" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -647,8 +648,8 @@ if (!window.tenetTooltipInitialized) {
   };
 }
 </script>.</p>
-<p>What was the solution to this? Let’s talk about modular transformers.</p>
-<div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p><strong>TL;DR:</strong> Read the code in one place, <span class="glossary-term " style="" data-tooltip-id="tenet-zakvn0b5oj7" onmouseenter="window.showTenetTooltip(event, 'tenet-zakvn0b5oj7')" onmousemove="window.updateTenetTooltip(event, 'tenet-zakvn0b5oj7')" onmouseleave="window.hideTenetTooltip('tenet-zakvn0b5oj7')">one model, one file.</span><span id="tenet-zakvn0b5oj7" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>What’s the solution to this?</p>
+<div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p><strong>TL;DR:</strong> Read the code in one place, <span class="glossary-term " style="" data-tooltip-id="tenet-k44ey0xqwkl" onmouseenter="window.showTenetTooltip(event, 'tenet-k44ey0xqwkl')" onmousemove="window.updateTenetTooltip(event, 'tenet-k44ey0xqwkl')" onmouseleave="window.hideTenetTooltip('tenet-k44ey0xqwkl')">one model, one file.</span><span id="tenet-k44ey0xqwkl" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -677,7 +678,7 @@ if (!window.tenetTooltipInitialized) {
 }
 </script>. Keep semantics local (<a href="#standardize-dont-abstract">Standardize, Don’t Abstract</a>). Allow strategic duplication for end users (<a href="#do-repeat-yourself">DRY*</a>). Keep the public surface minimal and stable (<a href="#minimal-user-api">Minimal API</a>, <a href="#backwards-compatibility">Backwards Compatibility</a>, <a href="#consistent-public-surface">Consistent Surface</a>).</p><p><strong>Next:</strong> how modular transformers honor these while removing boilerplate.</p> </div> </div> </div> </div> 
 <h2 id="-modular-transformers"><a href="#-modular-transformers"><a id="modular"></a> Modular transformers</a></h2>
-<p>Transformers is an opinionated library. The previous <a href="https://huggingface.co/docs/transformers/en/philosophy">philosophy</a> page, and the <a href="https://huggingface.co/blog/transformers-design-philosophy">blog post</a> were already pointing at the drawbacks mentioned just above, which have been iteratively addressed. <a href="https://huggingface.co/docs/transformers/en/modular_transformers"><code>modular</code> transformers was introduced</a> to allow a form of inheritance without breaking <span class="glossary-term " style="" data-tooltip-id="tenet-6zlvru3pscl" onmouseenter="window.showTenetTooltip(event, 'tenet-6zlvru3pscl')" onmousemove="window.updateTenetTooltip(event, 'tenet-6zlvru3pscl')" onmouseleave="window.hideTenetTooltip('tenet-6zlvru3pscl')">the one model, one file rule.</span><span id="tenet-6zlvru3pscl" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>Transformers is an opinionated library. The previous <a href="https://huggingface.co/docs/transformers/en/philosophy">philosophy</a> page, and the <a href="https://huggingface.co/blog/transformers-design-philosophy">blog post</a> were already pointing at the drawbacks mentioned just above, which have been iteratively addressed. <a href="https://huggingface.co/docs/transformers/en/modular_transformers"><code>modular</code> transformers was introduced</a> to allow a form of inheritance without breaking <span class="glossary-term " style="" data-tooltip-id="tenet-55va8zm6nla" onmouseenter="window.showTenetTooltip(event, 'tenet-55va8zm6nla')" onmousemove="window.updateTenetTooltip(event, 'tenet-55va8zm6nla')" onmouseleave="window.hideTenetTooltip('tenet-55va8zm6nla')">the one model, one file rule.</span><span id="tenet-55va8zm6nla" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -705,7 +706,7 @@ if (!window.tenetTooltipInitialized) {
   };
 }
 </script></p>
-<p>We amended the principle of <span class="glossary-term " style="" data-tooltip-id="tenet-7duqljcazz" onmouseenter="window.showTenetTooltip(event, 'tenet-7duqljcazz')" onmousemove="window.updateTenetTooltip(event, 'tenet-7duqljcazz')" onmouseleave="window.hideTenetTooltip('tenet-7duqljcazz')">DRY*</span><span id="tenet-7duqljcazz" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">do-repeat-yourself</span> <span class="glossary-tooltip__definition">Strategic duplication can improve readability and maintainability when done thoughtfully.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>We amended the principle of <span class="glossary-term " style="" data-tooltip-id="tenet-0gf1k2eur6q5" onmouseenter="window.showTenetTooltip(event, 'tenet-0gf1k2eur6q5')" onmousemove="window.updateTenetTooltip(event, 'tenet-0gf1k2eur6q5')" onmouseleave="window.hideTenetTooltip('tenet-0gf1k2eur6q5')">DRY*</span><span id="tenet-0gf1k2eur6q5" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">do-repeat-yourself</span> <span class="glossary-tooltip__definition">Strategic duplication can improve readability and maintainability when done thoughtfully.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -734,7 +735,7 @@ if (!window.tenetTooltipInitialized) {
 }
 </script> by progressively removing all pieces of code that were “copied from” another file.</p>
 <p>It works as follows. In order to contribute a model, <code>GLM</code> for instance, we define a <code>modular_</code> file that can inherit from <em>any function across all other modeling, configuration and processor files</em> already existing in the library.
-The modular file can use inheritance across models: and then, it will be unravelled into a fully functional modeling file.</p>
+The modular file can use inheritance across models: and then, it is unravelled into a fully functional modeling file.</p>
 <div class="reference-wrapper" data-astro-cid-e5g6tzce> <figure class="reference" data-astro-cid-e5g6tzce> <div class="reference__content" data-astro-cid-e5g6tzce> <div class="wide"> <div class="stack " data-layout="2-column" data-gap="medium" style="gap: 1rem" data-astro-cid-rlzglfcb> <div><h4 id="modular_glmpy"><a href="#modular_glmpy">modular_glm.py</a></h4><div class="code-card"><button class="code-copy button--ghost" type="button" aria-label="Copy code"><svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M16 1H4c-1.1 0-2 .9-2 2v12h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></svg></button><pre class="astro-code astro-code-themes github-light github-dark" style="--shiki-light:#24292e;--shiki-dark:#e1e4e8;--shiki-light-bg:#fff;--shiki-dark-bg:#24292e;overflow-x:auto" tabindex="0" data-language="python"><code><span class="line"><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">class</span><span style="--shiki-light:#6F42C1;--shiki-dark:#B392F0"> GlmMLP</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">(</span><span style="--shiki-light:#6F42C1;--shiki-dark:#B392F0">Phi3MLP</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">):</span></span>
 <span class="line"><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">    pass</span></span>
 <span class="line"></span>
@@ -868,7 +869,7 @@ The modular file can use inheritance across models: and then, it will be unravel
 <span class="line"><span style="--shiki-light:#6A737D;--shiki-dark:#6A737D"># ... (many more classes and functions would follow)</span></span>
 <span class="line"></span></code></pre></div></div> </div>  </div> </div> <figcaption class="reference__caption" data-astro-cid-e5g6tzce><strong>Left:</strong> Clean modular definition with inheritance. <strong>Right:</strong> Auto-expanded version with all inherited functionality visible.</figcaption> </figure> </div> 
 <p>As you can see, we can define a new model as a <em>modular</em> combination of fragments taken from others.</p>
-<p>You might think “well that’s just how inheritance works”. The crucial difference is that we do <em>visibly</em> what is essentially the <em>compiler</em>’s job: by unrolling the inheritances, we make visible all of the modeling code, keeping it <span class="glossary-term " style="" data-tooltip-id="tenet-s12tvjmgki" onmouseenter="window.showTenetTooltip(event, 'tenet-s12tvjmgki')" onmousemove="window.updateTenetTooltip(event, 'tenet-s12tvjmgki')" onmouseleave="window.hideTenetTooltip('tenet-s12tvjmgki')">all in one piece.</span><span id="tenet-s12tvjmgki" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>You might think “well that’s just how inheritance works”. The crucial difference is that we do <em>visibly</em> what is essentially the <em>compiler</em>’s job: by unrolling the inheritances, we make visible all of the modeling code, keeping it <span class="glossary-term " style="" data-tooltip-id="tenet-h2ja2v8qzzf" onmouseenter="window.showTenetTooltip(event, 'tenet-h2ja2v8qzzf')" onmousemove="window.updateTenetTooltip(event, 'tenet-h2ja2v8qzzf')" onmouseleave="window.hideTenetTooltip('tenet-h2ja2v8qzzf')">all in one piece.</span><span id="tenet-h2ja2v8qzzf" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -897,7 +898,7 @@ if (!window.tenetTooltipInitialized) {
 }
 </script></p>
 <p>You can see below the difference between <code>GlmAttention</code> and <code>LlamaAttention</code>, with the latter having been copied with minimal changes.</p>
-<div class="wide"> <div class="ri-root" data-ri-root="ri_17hg3z5xwnn" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/llama_glm_attn.D7pkKjAT_1axKuC.webp" alt="Llama vs GLM" data-zoomable="1" data-astro-cid-6kov3kig width="2169" height="482" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 1:</strong> Comparison of attention implementations between Llama and GLM, showing code reuse with minimal modifications.</span> </figcaption> </figure> </div> <script>
+<div class="wide"> <div class="ri-root" data-ri-root="ri_ijacchiixkm" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/llama_glm_attn.D7pkKjAT_1axKuC.webp" alt="Llama vs GLM" data-zoomable="1" data-astro-cid-6kov3kig width="2169" height="482" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 1:</strong> Comparison of attention implementations between Llama and GLM, showing code reuse with minimal modifications.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -1065,10 +1066,10 @@ if (!window.tenetTooltipInitialized) {
   })();
 </script>  </div>
 <p>What is the consequence? When adding a model, we do not need to go over the entire modeling file. The modular (left side above) is enough.</p>
-<p>When <code>AutoModel.from_pretrained(...)</code> is called, it is indeed the modeling (right side) that is ran, and all the tests run on the modeling code.</p>
+<p>When <code>AutoModel.from_pretrained(...)</code> is called, it is indeed the modeling (right side) that is run, and all the tests run on the modeling code.</p>
 <p>More importantly, the auto-generated modeling file is what users <em>read</em> to understand the code, what they step through in their debuggers and what they hack for their needs.</p>
 <p>What does that give us?</p>
-<div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p><strong>TL;DR:</strong> A small <code>modular_*.py</code> declares reuse; the expanded modeling file stays visible and <span class="glossary-term " style="" data-tooltip-id="tenet-f7cfzsvees4" onmouseenter="window.showTenetTooltip(event, 'tenet-f7cfzsvees4')" onmousemove="window.updateTenetTooltip(event, 'tenet-f7cfzsvees4')" onmouseleave="window.hideTenetTooltip('tenet-f7cfzsvees4')">unique</span><span id="tenet-f7cfzsvees4" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p><strong>TL;DR:</strong> A small <code>modular_*.py</code> declares reuse; the expanded modeling file stays visible and <span class="glossary-term " style="" data-tooltip-id="tenet-z5krirdchgg" onmouseenter="window.showTenetTooltip(event, 'tenet-z5krirdchgg')" onmousemove="window.updateTenetTooltip(event, 'tenet-z5krirdchgg')" onmouseleave="window.hideTenetTooltip('tenet-z5krirdchgg')">unique</span><span id="tenet-z5krirdchgg" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -1102,7 +1103,7 @@ However, if a model has a modular_<em>.py and a corresponding automatically gene
 <p>That gives an “effective LOC” curve: the 𝗺𝗮𝗶𝗻𝘁𝗲𝗻𝗮𝗻𝗰𝗲 𝘀𝘂𝗿𝗳𝗮𝗰𝗲.</p>
 <p>Measured on git history, raw <code>modeling_*.py</code> grew at ~362 LOC/day before modular; counting only modular shards yields ~25 LOC/day after — about <strong>15× lower</strong>. The effective curve (blue line below) represents the <strong>maintenance surface</strong> today: what maintainers actually read and review.</p>
 <p>Less code to hand-maintain means fewer places to break. Naturally LOC is not a direct measure of complexity, but they correlate in review effort and change risk.</p>
-<figure class="html-embed"><div class="html-embed__card"><div id="frag-z405fsz7sym"><div class="d3-loc-growth"></div>
+<figure class="html-embed"><div class="html-embed__card"><div id="frag-niv1nlk2d6d"><div class="d3-loc-growth"></div>
 <style>
   .d3-loc-growth { position: relative; }
   
@@ -1523,7 +1524,7 @@ If you zoom in, you’ll notice there’s a sharp drop near the end, it’s esse
 <p>But this was not the only effort that allowed us to reduce maintenance load.</p>
 <p>We recently underwent a deep refactor of the attention implementation. You’ve likely heard about <a href="https://huggingface.co/docs/text-generation-inference/en/conceptual/flash_attention">flash attention</a> and its several variants.</p>
 <p>The <em>attention computation</em> itself happens at a <em>lower</em> level of abstraction than the model itself.</p>
-<p>However, we were adding specific torch operations for each backend (sdpa, the several flash-attention iterations, flex attention) but it wasn’t a <span class="glossary-term " style="" data-tooltip-id="tenet-79uvrwy8cv7" onmouseenter="window.showTenetTooltip(event, 'tenet-79uvrwy8cv7')" onmousemove="window.updateTenetTooltip(event, 'tenet-79uvrwy8cv7')" onmouseleave="window.hideTenetTooltip('tenet-79uvrwy8cv7')">minimal user api</span><span id="tenet-79uvrwy8cv7" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>However, we were adding specific torch operations for each backend (sdpa, the several flash-attention iterations, flex attention) but it isn’t a <span class="glossary-term " style="" data-tooltip-id="tenet-grknlcin8hl" onmouseenter="window.showTenetTooltip(event, 'tenet-grknlcin8hl')" onmousemove="window.updateTenetTooltip(event, 'tenet-grknlcin8hl')" onmouseleave="window.hideTenetTooltip('tenet-grknlcin8hl')">minimal user api</span><span id="tenet-grknlcin8hl" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -1550,13 +1551,13 @@ if (!window.tenetTooltipInitialized) {
     tooltip.style.opacity = '0';
   };
 }
-</script>. Next section explains what we did.</p>
+</script>. Next section explains what we do.</p>
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>Evidence: effective (i.e., maintainable) LOC growth drops ~15× when counting shards instead of expanded modeling files. Less code to read, fewer places to break.</p><p><strong>Next:</strong> how the attention interface stays standard without hiding semantics.</p> </div> </div> </div> </div> 
 <h3 id="-external-attention-classes"><a href="#-external-attention-classes"><a id="attention-classes"></a> External Attention classes</a></h3>
 <p>The solution for the “attention abstraction problem” was to move to a standard <a href="https://huggingface.co/docs/transformers/en/attention_interface">attention interface</a> that allows the following:</p>
 <p>The naive implementation of attention, called “eager”, is available by default. We use a <code>Callable</code> called <code>eager_attention_forward</code>, which can run as long as the user has PyTorch installed – which is a requirement any way.</p>
 <p>Instead of using a class interface and a class hierarchy, we just moved to a function interface. When a more complex attention implementation is needed, we use other Callables, including much faster kernel bindings when available. The decision to use a different attention implementation is based on the model configuration file we download from the Hub, and it can also be overridden by the user.</p>
-<p>This is a clear example that that we prefer an interface that is <span class="glossary-term " style="" data-tooltip-id="tenet-gqk2q1gi9fq" onmouseenter="window.showTenetTooltip(event, 'tenet-gqk2q1gi9fq')" onmousemove="window.updateTenetTooltip(event, 'tenet-gqk2q1gi9fq')" onmouseleave="window.hideTenetTooltip('tenet-gqk2q1gi9fq')">standard, but not abstract</span><span id="tenet-gqk2q1gi9fq" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">standardize-dont-abstract</span> <span class="glossary-tooltip__definition">Model-specific logic belongs in the model file, not hidden behind abstractions.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>This is a clear example that that we prefer an interface that is <span class="glossary-term " style="" data-tooltip-id="tenet-6kwtarv0dum" onmouseenter="window.showTenetTooltip(event, 'tenet-6kwtarv0dum')" onmousemove="window.updateTenetTooltip(event, 'tenet-6kwtarv0dum')" onmouseleave="window.hideTenetTooltip('tenet-6kwtarv0dum')">standard, but not abstract</span><span id="tenet-6kwtarv0dum" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">standardize-dont-abstract</span> <span class="glossary-tooltip__definition">Model-specific logic belongs in the model file, not hidden behind abstractions.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -1588,7 +1589,7 @@ if (!window.tenetTooltipInitialized) {
 <span class="line"><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">if</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF"> self</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">.config._attn_implementation </span><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">!=</span><span style="--shiki-light:#032F62;--shiki-dark:#9ECBFF"> &quot;eager&quot;</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">:</span></span>
 <span class="line"><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">    attention_interface </span><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">=</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF"> ALL_ATTENTION_FUNCTIONS</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">[</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF">self</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">.config._attn_implementation]</span></span>
 <span class="line"></span></code></pre></div>
-<p>Having the attention interfaces functionalized allows to do dynamic switching of attentions as well, increasing their <span class="glossary-term " style="" data-tooltip-id="tenet-a6f77wx0s7" onmouseenter="window.showTenetTooltip(event, 'tenet-a6f77wx0s7')" onmousemove="window.updateTenetTooltip(event, 'tenet-a6f77wx0s7')" onmouseleave="window.hideTenetTooltip('tenet-a6f77wx0s7')">hackability</span><span id="tenet-a6f77wx0s7" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">code-is-product</span> <span class="glossary-tooltip__definition">Optimize for reading, diffing, and tweaking. Code quality matters as much as functionality.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>Having the attention interfaces functionalized allows to do dynamic switching of attentions as well, increasing their <span class="glossary-term " style="" data-tooltip-id="tenet-wpdzczeb9q" onmouseenter="window.showTenetTooltip(event, 'tenet-wpdzczeb9q')" onmousemove="window.updateTenetTooltip(event, 'tenet-wpdzczeb9q')" onmouseleave="window.hideTenetTooltip('tenet-wpdzczeb9q')">hackability</span><span id="tenet-wpdzczeb9q" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">code-is-product</span> <span class="glossary-tooltip__definition">Optimize for reading, diffing, and tweaking. Code quality matters as much as functionality.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -1618,7 +1619,7 @@ if (!window.tenetTooltipInitialized) {
 </script>.
 Another strength of the new attention interface is the possibility to enforce specific kwargs, which are needed by kernel providers and other dependencies.</p>
 <p>Backend integrations sometimes require specific kwargs.</p>
-<p>We know that kwargs are often a necessary evil that plagues tools with widespread compatibility; and it is something we have aimed to reduce, and will continue reduce in order to improve readability - with them, the current system is a <span class="glossary-term " style="" data-tooltip-id="tenet-yy9dlaagawg" onmouseenter="window.showTenetTooltip(event, 'tenet-yy9dlaagawg')" onmousemove="window.updateTenetTooltip(event, 'tenet-yy9dlaagawg')" onmouseleave="window.hideTenetTooltip('tenet-yy9dlaagawg')">minimal user api</span><span id="tenet-yy9dlaagawg" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>We know that kwargs are often a necessary evil that plagues tools with widespread compatibility; and it is something we have aimed to reduce, and continue to reduce in order to improve readability - with them, the current system is a <span class="glossary-term " style="" data-tooltip-id="tenet-neej1gd8zd" onmouseenter="window.showTenetTooltip(event, 'tenet-neej1gd8zd')" onmousemove="window.updateTenetTooltip(event, 'tenet-neej1gd8zd')" onmouseleave="window.hideTenetTooltip('tenet-neej1gd8zd')">minimal user api</span><span id="tenet-neej1gd8zd" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -1658,7 +1659,7 @@ if (!window.tenetTooltipInitialized) {
 <p>Why does it matter?</p>
 <p>Because we want to avoid code modifications that are unrelated to the model.</p>
 <p>We choose to place the level of abstraction higher than the device placement: a matrix multiplication - a <code>nn.Linear</code> layer - should be always expressed in the same way, regardless of how it is placed.</p>
-<p>Hence, we want to touch the modeling code <span class="glossary-term " style="" data-tooltip-id="tenet-q8a4395mh3" onmouseenter="window.showTenetTooltip(event, 'tenet-q8a4395mh3')" onmousemove="window.updateTenetTooltip(event, 'tenet-q8a4395mh3')" onmouseleave="window.hideTenetTooltip('tenet-q8a4395mh3')">as little as possible</span><span id="tenet-q8a4395mh3" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>Hence, we want to touch the modeling code <span class="glossary-term " style="" data-tooltip-id="tenet-fj5prhpgx7" onmouseenter="window.showTenetTooltip(event, 'tenet-fj5prhpgx7')" onmousemove="window.updateTenetTooltip(event, 'tenet-fj5prhpgx7')" onmouseleave="window.hideTenetTooltip('tenet-fj5prhpgx7')">as little as possible</span><span id="tenet-fj5prhpgx7" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -1717,7 +1718,7 @@ if (!window.tenetTooltipInitialized) {
 <p>Semantics stay in the model (a Linear stays a Linear), parallelization is orthogonal and declared via strings: “colwise” splits columns of weights/bias across ranks; “rowwise” splits rows; packed variants shard fused weights; The mapping keys accept glob patterns like <code>layers.*.mlp.down_proj</code> to target repeated submodules.</p>
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>Parallelization is specified in the configuration (<code>tp_plan</code>), not through edits to <code>Linear</code>s. Glob patterns target repeated blocks; modeling semantics stay intact.</p><p><strong>Next:</strong> per-layer attention/caching schedules declared in config, not hardcoded.</p> </div> </div> </div> </div> 
 <h3 id="-layers-attentions-and-caches"><a href="#-layers-attentions-and-caches"><a id="layers-attentions-caches"></a> Layers, attentions and caches</a></h3>
-<p>Following the same logic, the <em>nature</em> of attention and per-layer caching should not be hardcoded. We should be able to specify in the configuration how each layer is implemented. Thus, we define a mapping like:</p>
+<p>Following the same logic, the <em>nature</em> of attention and caching per layer of a model should not be hardcoded. We should be able to specify in a configuration-based fashion how each layer is implemented. Thus we define a mapping that can be then</p>
 <div class="code-card"><button class="code-copy button--ghost" type="button" aria-label="Copy code"><svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M16 1H4c-1.1 0-2 .9-2 2v12h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></svg></button><pre class="astro-code astro-code-themes github-light github-dark" style="--shiki-light:#24292e;--shiki-dark:#e1e4e8;--shiki-light-bg:#fff;--shiki-dark-bg:#24292e;overflow-x:auto" tabindex="0" data-language="python"><code><span class="line"><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF">ALLOWED_LAYER_TYPES</span><span style="--shiki-light:#D73A49;--shiki-dark:#F97583"> =</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8"> (</span></span>
 <span class="line"><span style="--shiki-light:#032F62;--shiki-dark:#9ECBFF">    &quot;full_attention&quot;</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">,</span></span>
 <span class="line"><span style="--shiki-light:#032F62;--shiki-dark:#9ECBFF">    &quot;sliding_attention&quot;</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">,</span></span>
@@ -1735,7 +1736,7 @@ if (!window.tenetTooltipInitialized) {
 <span class="line"><span style="--shiki-light:#032F62;--shiki-dark:#9ECBFF">    &quot;full_attention&quot;</span></span>
 <span class="line"><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">  ],</span></span>
 <span class="line"></span></code></pre></div>
-<p>This is <span class="glossary-term " style="" data-tooltip-id="tenet-tpheeocpf6r" onmouseenter="window.showTenetTooltip(event, 'tenet-tpheeocpf6r')" onmousemove="window.updateTenetTooltip(event, 'tenet-tpheeocpf6r')" onmouseleave="window.hideTenetTooltip('tenet-tpheeocpf6r')">minimal</span><span id="tenet-tpheeocpf6r" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>This is <span class="glossary-term " style="" data-tooltip-id="tenet-qp5m1h08x8c" onmouseenter="window.showTenetTooltip(event, 'tenet-qp5m1h08x8c')" onmousemove="window.updateTenetTooltip(event, 'tenet-qp5m1h08x8c')" onmouseleave="window.hideTenetTooltip('tenet-qp5m1h08x8c')">minimal</span><span id="tenet-qp5m1h08x8c" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -1765,7 +1766,7 @@ if (!window.tenetTooltipInitialized) {
 </script> to implement on the user side, and allows to keep the modeling code untouched. It is also easy to tweak.</p>
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>Allowed layer types are explicit; schedules (e.g., sliding/full alternation) live in config. This keeps the file readable and easy to tweak.</p><p><strong>Next:</strong> speedups come from kernels that don’t change semantics.</p> </div> </div> </div> </div> 
 <h3 id="community-kernels"><a href="#community-kernels"><a id="community-kernels"></a>Community Kernels</a></h3>
-<p>The same principle extends to normalization, activation, and other code paths. The model defines <strong>semantics</strong>; a kernel defines <strong>how</strong> to execute them faster. We annotate the module to borrow a community‑provided forward, keeping a <span class="glossary-term " style="" data-tooltip-id="tenet-x008g1ew6ua" onmouseenter="window.showTenetTooltip(event, 'tenet-x008g1ew6ua')" onmousemove="window.updateTenetTooltip(event, 'tenet-x008g1ew6ua')" onmouseleave="window.hideTenetTooltip('tenet-x008g1ew6ua')">consistent public surface</span><span id="tenet-x008g1ew6ua" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">consistent-public-surface</span> <span class="glossary-tooltip__definition">Uniform naming, signatures, and conventions across all models for predictability.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>The same principle extends to normalization, activation, and other code paths. The model defines <strong>semantics</strong>; a kernel defines <strong>how</strong> to execute them faster. We annotate the module to borrow a community‑provided forward, keeping a <span class="glossary-term " style="" data-tooltip-id="tenet-14e2emelx4v" onmouseenter="window.showTenetTooltip(event, 'tenet-14e2emelx4v')" onmousemove="window.updateTenetTooltip(event, 'tenet-14e2emelx4v')" onmouseleave="window.hideTenetTooltip('tenet-14e2emelx4v')">consistent public surface</span><span id="tenet-14e2emelx4v" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">consistent-public-surface</span> <span class="glossary-tooltip__definition">Uniform naming, signatures, and conventions across all models for predictability.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -1803,8 +1804,8 @@ if (!window.tenetTooltipInitialized) {
 <h2 id="a-modular-state"><a href="#a-modular-state">A Modular State</a></h2>
 <p>With <code>modular</code> transformers, we have a form of inheritance in our codebase. Some models become standards, and model contributors are given the opportunity to <em>define standards</em>. Pushing the boundaries of scientific knowledge can translate into the boundaries of engineering if this effort is made, and we’re striving for it.
 It’s hard to conceptualize very large libraries and how their components interact with each other, regardless of your cognitive abilities for abstractions.
-So I wanted to take a look at the current <strong>state of modularity</strong> across the repository. How many models are defined using components of others?</p>
-<p>To get this graph, I used the heuristic of modular inheritance.</p>
+So I want to take a look at the current <strong>state of modularity</strong> across the repository. How many models are defined using components of others?</p>
+<p>To get this graph, I use the heuristic of modular inheritance.</p>
 <ol>
 <li>Does this model have a <code>modular</code> file?</li>
 <li>In this <code>modular</code> file, what models, configurations and processings are imported?</li>
@@ -1813,7 +1814,7 @@ So I wanted to take a look at the current <strong>state of modularity</strong> a
 <p>So what do we see?</p>
 <p>(Graph reading guide: nodes are models; edges are modular imports).</p>
 <p>Check out the <a href="https://huggingface.co/spaces/Molbap/transformers-modular-refactor">full viewer here</a> (tab “dependency graph”, hit “build graph”) for better manipulation and exploration.</p>
-<div class="wide"> <figure class="html-embed"><div class="html-embed__card is-frameless"><div id="frag-un61h9n00dl"><iframe
+<div class="wide"> <figure class="html-embed"><div class="html-embed__card is-frameless"><div id="frag-h0xg4zaeejn"><iframe
 src="https://molbap-dependencies-1.hf.space"
 style="width:100%; height:680px; border:0"
 allow="clipboard-read; clipboard-write; fullscreen"
@@ -1821,7 +1822,7 @@ referrerpolicy="no-referrer-when-downgrade"
 ></iframe></div></div></figure> </div>
 <p>Let’s walk through some sections of this graph together.
 First, Llama is a basis and an influence for many models, and it is very visible.</p>
-<div class="ri-root" data-ri-root="ri_f8g7r3axz5g" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/llama_center.CbQ5MyAc_ZraNCd.webp" alt="Llama in the center" data-zoomable="1" data-astro-cid-6kov3kig width="1030" height="1015" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 2:</strong> Llama as a central model influencing many other models in the dependency graph.</span> </figcaption> </figure> </div> <script>
+<div class="ri-root" data-ri-root="ri_16upku868kf" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/llama_center.CbQ5MyAc_ZraNCd.webp" alt="Llama in the center" data-zoomable="1" data-astro-cid-6kov3kig width="1030" height="1015" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 2:</strong> Llama as a central model influencing many other models in the dependency graph.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -1990,7 +1991,7 @@ First, Llama is a basis and an influence for many models, and it is very visible
 </script> 
 <p>The models linked sometimes pull components from other models than <code>llama</code> of course. Radically different architectures such as mamba have spawned their own dependency subgraph.</p>
 <p>Audio models form sparser archipelagos, see for instance wav2vec2 which is a significant basis for a dozen of them.</p>
-<div class="ri-root" data-ri-root="ri_ck3b7kqtqkf" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/cluster_wave2vec2.BvHBUP61_Z2vdkmW.webp" alt="Wav2vec2 influence" data-zoomable="1" data-astro-cid-6kov3kig width="608" height="563" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 3:</strong> Cluster of audio architectures based on wav2vec2, forming a specialized archipelago.</span> </figcaption> </figure> </div> <script>
+<div class="ri-root" data-ri-root="ri_ovevlm7y5rp" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/cluster_wave2vec2.BvHBUP61_Z2vdkmW.webp" alt="Wav2vec2 influence" data-zoomable="1" data-astro-cid-6kov3kig width="608" height="563" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 3:</strong> Cluster of audio architectures based on wav2vec2, forming a specialized archipelago.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -2159,7 +2160,7 @@ First, Llama is a basis and an influence for many models, and it is very visible
 </script> 
 <p>In the case of VLMs which have massively grown in popularity since 2024, there’s far too many vision-based architectures that are not yet defined as modulars of other existing archs. In other words, there is no strong reference point in terms of software for vision models.</p>
 <p>As you can see, there is a small <code>DETR</code> island:</p>
-<div class="ri-root" data-ri-root="ri_tc4zrmd32i" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/detr_island.CSrqELWy_1IAFDR.webp" alt="DETR archipelago" data-zoomable="1" data-astro-cid-6kov3kig width="591" height="606" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 4:</strong> Small DETR archipelago for vision models, less centralized than Llama for text.</span> </figcaption> </figure> </div> <script>
+<div class="ri-root" data-ri-root="ri_r7g4zddmjy" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/detr_island.CSrqELWy_1IAFDR.webp" alt="DETR archipelago" data-zoomable="1" data-astro-cid-6kov3kig width="591" height="606" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 4:</strong> Small DETR archipelago for vision models, less centralized than Llama for text.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -2328,7 +2329,7 @@ First, Llama is a basis and an influence for many models, and it is very visible
 </script> 
 <p>There is also a little llava pocket, and so on, but it’s not comparable to the centrality observed for llama.</p>
 <p>Another problem is, this visualization only shows <code>modular</code> models. Several models still do NOT have a modular file. If we zoom out significantly, we can see them,  the red nodes are models that do not have a modular file yet.</p>
-<div class="ri-root" data-ri-root="ri_1mwgllujxiz" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/big_picture_zoomout.BKwXtSkj_1bNS6U.webp" alt="Red nodes" data-zoomable="1" data-astro-cid-6kov3kig width="1043" height="972" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 5:</strong> Overview showing red nodes (models without modular files) to be modularized.</span> </figcaption> </figure> </div> <script>
+<div class="ri-root" data-ri-root="ri_5x5w9by59t" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/big_picture_zoomout.BKwXtSkj_1bNS6U.webp" alt="Red nodes" data-zoomable="1" data-astro-cid-6kov3kig width="1043" height="972" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 5:</strong> Overview showing red nodes (models without modular files) to be modularized.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -2499,18 +2500,17 @@ First, Llama is a basis and an influence for many models, and it is very visible
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>Llama-lineage is a hub; several VLMs remain islands — engineering opportunity for shared parents.
 <strong>Next:</strong> timeline + similarity signals to spot modularisable candidates.</p> </div> </div> </div> </div> 
 <h3 id="many-models-but-not-enough-yet-are-alike"><a href="#many-models-but-not-enough-yet-are-alike">Many models, but not enough yet, are alike</a></h3>
-<p>I looked into Jaccard similarity, which we use to measure set differences, to find similarities across models. I know that code is more than a set of characters stringed together. We also tried code-embedding models that ranked candidates better in practice, but for this post we stick to the deterministic Jaccard index.</p>
-<p>It is interesting, for our comparison, to look at <em>when</em> we deployed the modular logic and what was its rippling effect on the library. Looking at the timeline makes it obvious: adding modular allowed to connect more and more models to solid reference points.</p>
-<p>Yet, we still have a lot of gaps to fill.</p>
+<p>Next, I looked into Jaccard similarity, which we use to measure set differences. I know that code is more than a set of characters stringed together. I also used code embedding models to check out code similarities, and it yielded better results, for the needs of this blog post I will stick to Jaccard index.</p>
+<p>It is interesting, for that, to look at <em>when</em> we deployed this modular logic and what was its rippling effect on the library. You can check the <a href="https://huggingface.co/spaces/Molbap/transformers-modular-refactor">larger space</a> to play around, but the gist is: adding modular allowed to connect more and more models to solid reference points. We have a lot of gaps to fill in still.</p>
 <p>Zoom out below - it’s full of models. You can click on a node to see its connections better, or use the text box to search for a model. You can use the <a href="https://huggingface.co/spaces/Molbap/transformers-modular-refactor">full viewer</a> (tab “timeline”, hit “build timeline”) for better exploration.</p>
-<div class="wide"> <figure class="html-embed"><div class="html-embed__card is-frameless"><div id="frag-gknihtiz6mm">    <iframe
+<div class="wide"> <figure class="html-embed"><div class="html-embed__card is-frameless"><div id="frag-pn9wtj7slmg">    <iframe
   src="https://molbap-timeline-1.hf.space"
   style="width:100%; height:680px; border:0"
   allow="clipboard-read; clipboard-write; fullscreen"
   referrerpolicy="no-referrer-when-downgrade"
 ></iframe></div></div></figure> </div>
 <p>Let’s look at a few highly connected models. Let’s start by the foundational work of <a href="https://arxiv.org/abs/2304.08485">Llava</a>.</p>
-<div class="ri-root" data-ri-root="ri_g7flco9698" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/timeline_llava.Bne5RSo9_Z26WEKX.webp" alt="Llava in its timeline" data-zoomable="1" data-astro-cid-6kov3kig width="1250" height="770" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 6:</strong> LLaVA and its variants in the timeline, with llava_video as a candidate for modularization.</span> </figcaption> </figure> </div> <script>
+<div class="ri-root" data-ri-root="ri_ola4htsxzid" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/timeline_llava.Bne5RSo9_Z26WEKX.webp" alt="Llava in its timeline" data-zoomable="1" data-astro-cid-6kov3kig width="1250" height="770" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 6:</strong> LLaVA and its variants in the timeline, with llava_video as a candidate for modularization.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -2677,7 +2677,7 @@ First, Llama is a basis and an influence for many models, and it is very visible
     else window.addEventListener("load", initZoomIfNeeded, { once: true });
   })();
 </script> 
-<p>You see that <code>llava_video</code> is a red node, connected by a red edge to <code>llava</code>: it’s a candidate, something that we can <em>likely</em> remodularize, <span class="glossary-term " style="" data-tooltip-id="tenet-pwacwh0ugx" onmouseenter="window.showTenetTooltip(event, 'tenet-pwacwh0ugx')" onmousemove="window.updateTenetTooltip(event, 'tenet-pwacwh0ugx')" onmouseleave="window.hideTenetTooltip('tenet-pwacwh0ugx')">not touching the actual model</span><span id="tenet-pwacwh0ugx" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">backwards-compatibility</span> <span class="glossary-tooltip__definition">Any artifact once on the hub must remain loadable. Breaking changes are unacceptable.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>You see that <code>llava_video</code> is a red node, connected by a red edge to <code>llava</code>: it’s a candidate, something that we can <em>likely</em> remodularize, <span class="glossary-term " style="" data-tooltip-id="tenet-aozg3lfekvd" onmouseenter="window.showTenetTooltip(event, 'tenet-aozg3lfekvd')" onmousemove="window.updateTenetTooltip(event, 'tenet-aozg3lfekvd')" onmouseleave="window.hideTenetTooltip('tenet-aozg3lfekvd')">not touching the actual model</span><span id="tenet-aozg3lfekvd" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">backwards-compatibility</span> <span class="glossary-tooltip__definition">Any artifact once on the hub must remain loadable. Breaking changes are unacceptable.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -2704,7 +2704,7 @@ if (!window.tenetTooltipInitialized) {
     tooltip.style.opacity = '0';
   };
 }
-</script> but being much more readable with <span class="glossary-term " style="" data-tooltip-id="tenet-kqcf0tdw28" onmouseenter="window.showTenetTooltip(event, 'tenet-kqcf0tdw28')" onmousemove="window.updateTenetTooltip(event, 'tenet-kqcf0tdw28')" onmouseleave="window.hideTenetTooltip('tenet-kqcf0tdw28')">DRY*</span><span id="tenet-kqcf0tdw28" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">do-repeat-yourself</span> <span class="glossary-tooltip__definition">Strategic duplication can improve readability and maintainability when done thoughtfully.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+</script> but being much more readable with <span class="glossary-term " style="" data-tooltip-id="tenet-5ss9cgqp7an" onmouseenter="window.showTenetTooltip(event, 'tenet-5ss9cgqp7an')" onmousemove="window.updateTenetTooltip(event, 'tenet-5ss9cgqp7an')" onmouseleave="window.hideTenetTooltip('tenet-5ss9cgqp7an')">DRY*</span><span id="tenet-5ss9cgqp7an" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">do-repeat-yourself</span> <span class="glossary-tooltip__definition">Strategic duplication can improve readability and maintainability when done thoughtfully.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -2734,7 +2734,7 @@ if (!window.tenetTooltipInitialized) {
 </script>.</p>
 <p>The same can be identified with the classical encoders family, centered on <code>BERT</code>:</p>
 <p>Here <code>roberta</code>, <code>xlm_roberta</code>, <code>ernie</code> are <code>modular</code>s of BERT, while models like <code>mobilebert</code> are likely candidates.</p>
-<div class="ri-root" data-ri-root="ri_veyzkbkcmq" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/classic_encoders.BSgQl9lp_3OtlT.webp" alt="Classical encoders" data-zoomable="1" data-astro-cid-6kov3kig width="1274" height="749" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 7:</strong> Family of classical encoders centered on BERT, with several models already modularized.</span> </figcaption> </figure> </div> <script>
+<div class="ri-root" data-ri-root="ri_uzbrne95enn" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/classic_encoders.BSgQl9lp_3OtlT.webp" alt="Classical encoders" data-zoomable="1" data-astro-cid-6kov3kig width="1274" height="749" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 7:</strong> Family of classical encoders centered on BERT, with several models already modularized.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -2908,7 +2908,7 @@ if (!window.tenetTooltipInitialized) {
 <div class="code-card"><button class="code-copy button--ghost" type="button" aria-label="Copy code"><svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M16 1H4c-1.1 0-2 .9-2 2v12h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></svg></button><pre class="astro-code astro-code-themes github-light github-dark" style="--shiki-light:#24292e;--shiki-dark:#e1e4e8;--shiki-light-bg:#fff;--shiki-dark-bg:#24292e;overflow-x:auto" tabindex="0" data-language="python"><code><span class="line"><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">class</span><span style="--shiki-light:#6F42C1;--shiki-dark:#B392F0"> InputsEmbeddingMixerMixin</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">(</span><span style="--shiki-light:#6F42C1;--shiki-dark:#B392F0">nn</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">.</span><span style="--shiki-light:#6F42C1;--shiki-dark:#B392F0">Module</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8">):</span></span>
 <span class="line"><span style="--shiki-light:#6A737D;--shiki-dark:#6A737D">    #</span></span>
 <span class="line"></span></code></pre></div>
-<p>But this is <span class="glossary-term " style="" data-tooltip-id="tenet-3k8q4eeea5v" onmouseenter="window.showTenetTooltip(event, 'tenet-3k8q4eeea5v')" onmousemove="window.updateTenetTooltip(event, 'tenet-3k8q4eeea5v')" onmouseleave="window.hideTenetTooltip('tenet-3k8q4eeea5v')">not an abstraction</span><span id="tenet-3k8q4eeea5v" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">standardize-dont-abstract</span> <span class="glossary-tooltip__definition">Model-specific logic belongs in the model file, not hidden behind abstractions.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>But this is <span class="glossary-term " style="" data-tooltip-id="tenet-gw6fwi24bkb" onmouseenter="window.showTenetTooltip(event, 'tenet-gw6fwi24bkb')" onmousemove="window.updateTenetTooltip(event, 'tenet-gw6fwi24bkb')" onmouseleave="window.hideTenetTooltip('tenet-gw6fwi24bkb')">not an abstraction</span><span id="tenet-gw6fwi24bkb" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">standardize-dont-abstract</span> <span class="glossary-tooltip__definition">Model-specific logic belongs in the model file, not hidden behind abstractions.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -2938,7 +2938,7 @@ if (!window.tenetTooltipInitialized) {
 </script>. Embedding mixin is part of the model, removing it would break it. A user opening <a href="https://github.com/huggingface/transformers/blob/b3bd815786c36f4e6c3791fae0a96cac86658b32/src/transformers/models/qwen2_5_vl/modeling_qwen2_5_vl.py#L1358"><code>modeling_qwen2.5_vl</code></a> (check out the <a href="https://huggingface.co/collections/Qwen/qwen25-vl-6795ffac22b334a837c0f9a5">Qwen2.5VL collection</a>) should not have to go to another file to understand how it works.</p>
 <p>What is the current state of these “abstractions” across the codebase?
 You will see all the imports around a modeling file, here <a href="https://huggingface.co/google/gemma-3n-E4B-it">Gemma3n</a>.</p>
-<div class="ri-root" data-ri-root="ri_8ksrrycysy6" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/still_graph_bloat.BII6Am4a_Z2d5KVT.webp" alt="Gemma3n graph" data-zoomable="1" data-astro-cid-6kov3kig width="2580" height="1207" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 8:</strong> Gemma3n import graph showing dependency complexity, with GenerationMixin very central.</span> </figcaption> </figure> </div> <script>
+<div class="ri-root" data-ri-root="ri_k6bg42tktkg" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/still_graph_bloat.BII6Am4a_Z2d5KVT.webp" alt="Gemma3n graph" data-zoomable="1" data-astro-cid-6kov3kig width="2580" height="1207" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 8:</strong> Gemma3n import graph showing dependency complexity, with GenerationMixin very central.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -3148,7 +3148,7 @@ That means every decision we make to abstract something else has to be extremely
 <span class="line"></span>
 <span class="line"><span style="--shiki-light:#D73A49;--shiki-dark:#F97583">        return</span><span style="--shiki-light:#24292E;--shiki-dark:#E1E4E8"> special_image_mask, special_video_mask</span></span>
 <span class="line"></span></code></pre></div>
-<p>But this is <em>within</em> the modeling file, not in the <code>PreTrainedModel</code> base class. It will not move away from it, because it’d break the <span class="glossary-term " style="" data-tooltip-id="tenet-buncbzosj2g" onmouseenter="window.showTenetTooltip(event, 'tenet-buncbzosj2g')" onmousemove="window.updateTenetTooltip(event, 'tenet-buncbzosj2g')" onmouseleave="window.hideTenetTooltip('tenet-buncbzosj2g')">One model, one file tenet.</span><span id="tenet-buncbzosj2g" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>But this is <em>within</em> the modeling file, not in the <code>PreTrainedModel</code> base class. It does not move away from it, because it’d break the <span class="glossary-term " style="" data-tooltip-id="tenet-fl20fixgztr" onmouseenter="window.showTenetTooltip(event, 'tenet-fl20fixgztr')" onmousemove="window.updateTenetTooltip(event, 'tenet-fl20fixgztr')" onmouseleave="window.hideTenetTooltip('tenet-fl20fixgztr')">One model, one file tenet.</span><span id="tenet-fl20fixgztr" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">one-model-one-file</span> <span class="glossary-tooltip__definition">All inference and training core logic visible, top‑to‑bottom, in a single file.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -3181,8 +3181,8 @@ if (!window.tenetTooltipInitialized) {
 <strong>Next:</strong> pipeline-level wins that came from PyTorch-first choices (fast processors).</p> </div> </div> </div> </div> 
 <h3 id="on-image-processing-and-processors"><a href="#on-image-processing-and-processors">On image processing and processors</a></h3>
 <p>Deciding to become a <code>torch</code>-first library meant relieving a tremendous amount of support for <code>jax </code> and <code>TensorFlow</code>, and it also meant that we could be more lenient about the amount of torch-dependent utilities that we were able to accept. One of these is the <em>fast processing</em> of images. Where inputs were once minimally assumed to be ndarrays, enforcing native <code>torch</code> and <code>torchvision</code> inputs allowed us to massively improve processing speed for each model.</p>
-<p>The gains in performance are immense, up to 20x speedup for most models when using compiled torchvision ops. Furthermore, lets us run the whole pipeline solely on GPU.</p>
-<div class="ri-root" data-ri-root="ri_82vx9eq8e22" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/fast_image_processors.D3x5vY3o_2cacGa.webp" alt="Fast Image Processors Performance" data-zoomable="1" data-astro-cid-6kov3kig width="2251" height="2409" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 9:</strong> Performance gains of fast image processors, up to 20x acceleration with compiled torchvision.</span> </figcaption> </figure> </div> <script>
+<p>The gains in performance are immense, up to 20x speedup for most models when using compiled torchvision ops. Furthermore, let us run the whole pipeline solely on GPU.</p>
+<div class="ri-root" data-ri-root="ri_2o30u71x96t" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/fast_image_processors.D3x5vY3o_2cacGa.webp" alt="Fast Image Processors Performance" data-zoomable="1" data-astro-cid-6kov3kig width="2251" height="2409" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 9:</strong> Performance gains of fast image processors, up to 20x acceleration with compiled torchvision.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -3353,13 +3353,12 @@ if (!window.tenetTooltipInitialized) {
 <h2 id="reduce-barrier-to-entrycontribution"><a href="#reduce-barrier-to-entrycontribution">Reduce barrier to entry/contribution</a></h2>
 <p>This is an overall objective: there’s no <code>transformers</code> without its community.</p>
 <p>Having a framework means forcing users into it. It restrains flexibility and creativity, which are the fertile soil for new ideas to grow.</p>
-<p>Among the most valuable contributions to <code>transformers</code> is of course the addition of new models. Very recently, <a href="https://huggingface.co/blog/welcome-openai-gpt-oss">OpenAI added GPT-OSS</a>, which prompted the addition of many new features to the library in order to support <a href="https://huggingface.co/openai/gpt-oss-120b">their model</a>.</p>
-<p>These additions are immediately available for other models to use.</p>
-<p>Another important advantage is the ability to fine-tune and pipeline these models into many other libraries and tools. Check here on the hub how many finetunes are registered for <a href="https://huggingface.co/models?other=base_model:finetune:openai/gpt-oss-120b">gpt-oss 120b</a>, despite its size!</p>
+<p>Among the most valuable contributions to <code>transformers</code> is of course the addition of new models. Recently, <a href="https://huggingface.co/blog/welcome-openai-gpt-oss">OpenAI added GPT-OSS</a>, which prompted the addition of many new features to the library in order to support <a href="https://huggingface.co/openai/gpt-oss-120b">their model</a>.</p>
+<p>A second one is the ability to fine-tune and pipeline these models into many other softwares. Check here on the hub how many finetunes are registered for <a href="https://huggingface.co/models?other=base_model:finetune:openai/gpt-oss-120b">gpt-oss 120b</a>, despite its size!</p>
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>The shape of a contribution: add a model (or variant) with a small modular shard; the community and serving stacks pick it up immediately. Popularity trends (encoders/embeddings) guide where we invest.</p><p><strong>Next:</strong> power tools enabled by a consistent API.</p> </div> </div> </div> </div> 
 <h3 id="-models-popularity"><a href="#-models-popularity"><a id="encoders-ftw"></a> Models popularity</a></h3>
 <p>Talking about dependencies, we can take a look at the number of downloads as a measure of popularity. One thing we see is the prominence of encoders, despite the apparent prevalence of decoder LLMs. The reason is that encoders are used to generate embeddings, which have multiple downstream uses. Just check out <a href="https://huggingface.co/blog/embeddinggemma">EmbeddingGemma</a> for a modern recap. Hence, it is vital to keep the encoders portion of the library viable, usable, fine-tunable.</p>
-<div><figure class="html-embed"><div class="html-embed__card"><div id="frag-74k2ai7j5ws"><div class="d3-model-popularity"></div>
+<div><figure class="html-embed"><div class="html-embed__card"><div id="frag-9vqpudwr01g"><div class="d3-model-popularity"></div>
 <style>
   .d3-model-popularity .controls {
     margin-top: 0;
@@ -3935,7 +3934,7 @@ if (!window.tenetTooltipInitialized) {
 </script>
 </div></div></figure></div>
 <p>As the codebase grows, we need to maintain it in coordination with our friend <a href="https://huggingface.co/sentence-transformers">Sentence Transformers codebase</a>. Retrieval use-cases, smart databases, FAISS-based indexing rely on it, and thus indirectly on transformers.</p>
-<p>In that regard, we DO want to be a modular toolbox, being <span class="glossary-term " style="" data-tooltip-id="tenet-pddeg9pklgf" onmouseenter="window.showTenetTooltip(event, 'tenet-pddeg9pklgf')" onmousemove="window.updateTenetTooltip(event, 'tenet-pddeg9pklgf')" onmouseleave="window.hideTenetTooltip('tenet-pddeg9pklgf')">minimal</span><span id="tenet-pddeg9pklgf" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>In that regard, we DO want to be a modular toolbox, being <span class="glossary-term " style="" data-tooltip-id="tenet-du4zsb4wyeg" onmouseenter="window.showTenetTooltip(event, 'tenet-du4zsb4wyeg')" onmousemove="window.updateTenetTooltip(event, 'tenet-du4zsb4wyeg')" onmouseleave="window.hideTenetTooltip('tenet-du4zsb4wyeg')">minimal</span><span id="tenet-du4zsb4wyeg" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">minimal-user-api</span> <span class="glossary-tooltip__definition">Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. Least amount of codepaths.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -3971,7 +3970,7 @@ if (!window.tenetTooltipInitialized) {
 <p>All models have the same API for attention computation, thanks to <a href="#external-attention-classes">the externalisation of attention classes</a>.</p>
 <p>This uniformity allows us to build cool tools to visualize the inner workings of the attention mechanism.</p>
 <p>One particular piece of machinery is the <code>attention mask</code>. Here you see the famous bidirectional attention pattern for the whole prefix (text + image) in PaliGemma and all Gemma2+ models, contrasting with the usual “causal-only” models.</p>
-<figure class="html-embed"><div class="html-embed__card is-frameless"><div id="frag-e1g97mju1k"><!-- Minimal HTML fragment: terminal-style ASCII attention masks -->
+<figure class="html-embed"><div class="html-embed__card is-frameless"><div id="frag-ur2ouaht9ps"><!-- Minimal HTML fragment: terminal-style ASCII attention masks -->
 <div style="max-width: 940px; margin: 16px 0; border:1px solid #2a2f3a; border-radius:8px; background:#0b0f19; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace; color:#e5e7eb;">
     <div style="display:flex; align-items:center; gap:8px; padding:8px 10px; border-bottom:1px solid #1f2430; background:#111827; border-top-left-radius:8px; border-top-right-radius:8px;">
       <span style="width:10px; height:10px; background:#ef4444; border-radius:50%; display:inline-block;"></span>
@@ -4019,7 +4018,7 @@ if (!window.tenetTooltipInitialized) {
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>Uniform attention APIs enable cross-model diagnostics (e.g., PaliGemma prefix bidirectionality vs causal).</p><p><strong>Next:</strong> whole-model tracing for ports and regressions.</p> </div> </div> </div> </div> 
 <h3 id="logging-entire-model-activations"><a href="#logging-entire-model-activations">Logging entire model activations</a></h3>
 <p>Because everything is PyTorch, we can easily <a href="https://huggingface.co/docs/transformers/internal/model_debugging_utils">debug any model</a> when we want to add it to transformers. We now have a power-user tool for porting or adding models, that wraps a forward pass, intercepts every submodule call, and logs shapes, dtypes, and sample statistics of inputs/outputs to nested JSON.</p>
-<p>It just works with PyTorch models and is especially useful when aligning outputs with a reference implementation, to match our <span class="glossary-term " style="" data-tooltip-id="tenet-1uta17ljnaa" onmouseenter="window.showTenetTooltip(event, 'tenet-1uta17ljnaa')" onmousemove="window.updateTenetTooltip(event, 'tenet-1uta17ljnaa')" onmouseleave="window.hideTenetTooltip('tenet-1uta17ljnaa')">Source of Truth guideline</span><span id="tenet-1uta17ljnaa" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">source-of-truth</span> <span class="glossary-tooltip__definition">Model implementations should be reliable, reproducible, and faithful to original performances.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>It just works with PyTorch models and is especially useful when aligning outputs with a reference implementation, to match our <span class="glossary-term " style="" data-tooltip-id="tenet-3c3ba1lh9vj" onmouseenter="window.showTenetTooltip(event, 'tenet-3c3ba1lh9vj')" onmousemove="window.updateTenetTooltip(event, 'tenet-3c3ba1lh9vj')" onmouseleave="window.hideTenetTooltip('tenet-3c3ba1lh9vj')">Source of Truth guideline</span><span id="tenet-3c3ba1lh9vj" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">source-of-truth</span> <span class="glossary-tooltip__definition">Model implementations should be reliable, reproducible, and faithful to original performances.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -4047,7 +4046,7 @@ if (!window.tenetTooltipInitialized) {
   };
 }
 </script>.</p>
-<div class="wide"> <div class="ri-root" data-ri-root="ri_v7whj1yjkxi" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/model_debugger.DouWEpKv_Z2338YE.webp" alt="Model debugger interface" data-zoomable="1" data-astro-cid-6kov3kig width="2053" height="1016" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 10:</strong> Model debugger interface intercepting calls and logging statistics in nested JSON.</span> </figcaption> </figure> </div> <script>
+<div class="wide"> <div class="ri-root" data-ri-root="ri_2zgw27fkaka" data-has-caption data-astro-cid-6kov3kig> <figure class="" data-astro-cid-6kov3kig> <img src="/_astro/model_debugger.DouWEpKv_Z2338YE.webp" alt="Model debugger interface" data-zoomable="1" data-astro-cid-6kov3kig width="2053" height="1016" loading="lazy" decoding="async"> <figcaption data-astro-cid-6kov3kig> <span data-astro-cid-6kov3kig><strong>Figure 10:</strong> Model debugger interface intercepting calls and logging statistics in nested JSON.</span> </figcaption> </figure> </div> <script>
   (() => {
     const scriptEl = document.currentScript;
     const root = scriptEl ? scriptEl.previousElementSibling : null;
@@ -4216,7 +4215,7 @@ if (!window.tenetTooltipInitialized) {
 </script>  </div>
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>Forward interception and nested JSON logging align ports to reference implementations, reinforcing “Source of Truth.”</p><p><strong>Next:</strong> CUDA warmup reduces load-time without touching modeling semantics.</p> </div> </div> </div> </div> 
 <h3 id="cooking-faster-cuda-warmups"><a href="#cooking-faster-cuda-warmups">Cooking faster CUDA warmups</a></h3>
-<p>Having a clean <em>external</em> API allows us to work on the <span class="glossary-term " style="" data-tooltip-id="tenet-b2qi2hjidh" onmouseenter="window.showTenetTooltip(event, 'tenet-b2qi2hjidh')" onmousemove="window.updateTenetTooltip(event, 'tenet-b2qi2hjidh')" onmouseleave="window.hideTenetTooltip('tenet-b2qi2hjidh')">true inner workings of transformers</span><span id="tenet-b2qi2hjidh" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">code-is-product</span> <span class="glossary-tooltip__definition">Optimize for reading, diffing, and tweaking. Code quality matters as much as functionality.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>Having a clean <em>external</em> API allows us to work on the <span class="glossary-term " style="" data-tooltip-id="tenet-3lafjw8hdey" onmouseenter="window.showTenetTooltip(event, 'tenet-3lafjw8hdey')" onmousemove="window.updateTenetTooltip(event, 'tenet-3lafjw8hdey')" onmouseleave="window.hideTenetTooltip('tenet-3lafjw8hdey')">true inner workings of transformers</span><span id="tenet-3lafjw8hdey" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">code-is-product</span> <span class="glossary-tooltip__definition">Optimize for reading, diffing, and tweaking. Code quality matters as much as functionality.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -4243,8 +4242,8 @@ if (!window.tenetTooltipInitialized) {
     tooltip.style.opacity = '0';
   };
 }
-</script>. One of a few recent additions was the <em>CUDA warmup</em> via <code>caching_allocator_warmup</code>, which dramatically improved loading times by pre-allocating GPU memory to avoid malloc bottlenecks during model loading. It can achieve a 7x speedup factor for an 8B model, or 6x for a 32B one, as you can check in <a href="https://github.com/huggingface/transformers/pull/36380">the PR</a>!</p>
-<div class="wide"> <figure class="html-embed"><figcaption class="html-embed__title" style="text-align:center">Mem allocation patterns during model loading</figcaption><div class="html-embed__card"><div id="frag-i5dswhnu8j"><div class="d3-warmup-demo"></div>
+</script>. One of a few recent additions is the <em>CUDA warmup</em> via <code>caching_allocator_warmup</code>, which dramatically improves loading times by pre-allocating GPU memory to avoid malloc bottlenecks during model loading. It can achieve a 7x speedup factor for an 8B model, or 6x for a 32B one, as you can check in <a href="https://github.com/huggingface/transformers/pull/36380">the PR</a>!</p>
+<div class="wide"> <figure class="html-embed"><figcaption class="html-embed__title" style="text-align:center">Mem allocation patterns during model loading</figcaption><div class="html-embed__card"><div id="frag-nyt4llacbz"><div class="d3-warmup-demo"></div>
 <style>
   .d3-warmup-demo {
     font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
@@ -4873,7 +4872,7 @@ if (!window.tenetTooltipInitialized) {
 <p>It’s hard to overstate how much of a lifesaver that is when you’re trying to load a model as fast as possible, as it’s the narrowest bottleneck for your iteration speed.</p>
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>Pre-allocating GPU memory removes malloc spikes (e.g., 7× for 8B, 6× for 32B in the referenced PR).</p><p><strong>Next:</strong> consistent interfaces allow transformers-serve.</p> </div> </div> </div> </div> 
 <h3 id="transformers-serve-and-continuous-batching"><a href="#transformers-serve-and-continuous-batching">Transformers-serve and continuous batching</a></h3>
-<p>Having all these models readily available and sharing the same interface allowed us to implement transformers-serve, a CLI tool to expose models through a standard OpenAI http API.</p>
+<p>Having all these models readily available and sharing the same interface allows us to implement transformers-serve, a CLI tool to expose models through a standard OpenAI http API.</p>
 <div class="code-card"><button class="code-copy button--ghost" type="button" aria-label="Copy code"><svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M16 1H4c-1.1 0-2 .9-2 2v12h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></svg></button><pre class="astro-code astro-code-themes github-light github-dark" style="--shiki-light:#24292e;--shiki-dark:#e1e4e8;--shiki-light-bg:#fff;--shiki-dark-bg:#24292e;overflow-x:auto" tabindex="0" data-language="bash"><code><span class="line"><span style="--shiki-light:#6F42C1;--shiki-dark:#B392F0">transformers</span><span style="--shiki-light:#032F62;--shiki-dark:#9ECBFF"> serve</span></span>
 <span class="line"></span>
 <span class="line"><span style="--shiki-light:#6F42C1;--shiki-dark:#B392F0">curl</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF"> -X</span><span style="--shiki-light:#032F62;--shiki-dark:#9ECBFF"> POST</span><span style="--shiki-light:#032F62;--shiki-dark:#9ECBFF"> http://localhost:8000/v1/chat/completions</span><span style="--shiki-light:#005CC5;--shiki-dark:#79B8FF"> \</span></span>
@@ -4890,14 +4889,14 @@ if (!window.tenetTooltipInitialized) {
 <p>For model deployment, check <a href="https://huggingface.co/docs/inference-providers/en/index">Inference Providers</a> or roll your solution using any of the excellent serving libraries.</p>
 <div class="note note--info" data-astro-cid-qg6lmfty> <div class="note__layout" data-astro-cid-qg6lmfty>  <div class="note__body" data-astro-cid-qg6lmfty>  <div class="note__content" data-astro-cid-qg6lmfty> <p>OpenAI-compatible surface + continuous batching; kernels/backends slot in because the modeling API stayed stable.</p><p><strong>Next:</strong> reuse across vLLM/SGLang relies on the same consistency.</p> </div> </div> </div> </div> 
 <h2 id="community-reusability"><a href="#community-reusability">Community reusability</a></h2>
-<p>The transformers-serve CLI built on transformers, for sure, but the library is made first and foremost to be <em>reused</em> at large by the open-source ecosystem.</p>
+<p>The transformers-serve CLI is built on transformers, for sure, but the library is made first and foremost to be <em>reused</em> at large by the open-source ecosystem.</p>
 <p>Adding a model to transformers means:</p>
 <ul>
 <li>having it immediately available to the community</li>
 <li>having it immediately usable in vLLM, <a href="https://huggingface.co/blog/transformers-backend-sglang">SGLang</a>, and so on without additional code. In the case of vLLM, transformers was added as a backend to run models on vLLM, which optimizes throughput/latency on top of <em>existing</em> transformers architectures <a href="https://blog.vllm.ai/2025/04/11/transformers-backend.html">as seen in this great vLLM x HF blog post.</a></li>
 <li>being the reference code for implementations in MLX, llama.cpp and other libraries.</li>
 </ul>
-<p>This further cements the need for a <span class="glossary-term " style="" data-tooltip-id="tenet-b6g8a7kuhja" onmouseenter="window.showTenetTooltip(event, 'tenet-b6g8a7kuhja')" onmousemove="window.updateTenetTooltip(event, 'tenet-b6g8a7kuhja')" onmouseleave="window.hideTenetTooltip('tenet-b6g8a7kuhja')">consistent public surface</span><span id="tenet-b6g8a7kuhja" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">consistent-public-surface</span> <span class="glossary-tooltip__definition">Uniform naming, signatures, and conventions across all models for predictability.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
+<p>This further cements the need for a <span class="glossary-term " style="" data-tooltip-id="tenet-se5igsg6udd" onmouseenter="window.showTenetTooltip(event, 'tenet-se5igsg6udd')" onmousemove="window.updateTenetTooltip(event, 'tenet-se5igsg6udd')" onmouseleave="window.hideTenetTooltip('tenet-se5igsg6udd')">consistent public surface</span><span id="tenet-se5igsg6udd" class="glossary-tooltip" data-position="top"> <span class="glossary-tooltip__content"> <span class="glossary-tooltip__term">consistent-public-surface</span> <span class="glossary-tooltip__definition">Uniform naming, signatures, and conventions across all models for predictability.</span> </span> <span class="glossary-tooltip__arrow"></span> </span> <script>
 if (!window.tenetTooltipInitialized) {
   window.tenetTooltipInitialized = true;
 
@@ -4929,7 +4928,7 @@ if (!window.tenetTooltipInitialized) {
 <h2 id="a-pact-with-the-community-and-what-is-coming-next"><a href="#a-pact-with-the-community-and-what-is-coming-next">A Pact with the Community and what is coming next</a></h2>
 <p>The next major version of <code>transformers</code> is just around the corner (and will have another blog post to its name when it comes out). When v5 is released, we aim to keep <a href="#backwards-compatibility">backwards compatibility</a> as solid as possible. The changes we make now are in service of that goal.</p>
 <p>We will lean further into a modular toolbox, not a framework. You should not be forced to rewrite modeling code. It’s better when a model can inherit from <code>PreTrainedModel</code> and opt into Tensor Parallel, <code>from_pretrained</code>, sharding, <code>push_to_hub</code>, loss plumbing, and external stacks like PEFT/TRL/SGLang/vLLM.</p>
-<p>We wrote this to make our design philosophy legible. Transformers is built by thousands of contributors, but it only stays usable if its core principles are explicit and upheld. These tenets are our pact with you: they ensure that whether you are shipping a new model, contributing an optimized kernel, or simply debugging a forward pass, the code remains transparent and hackable.</p>
+<p>We write this to make our design philosophy legible. Transformers is built by thousands of contributors, but it only stays usable if its core principles are explicit and upheld. These tenets are our pact with you: they ensure that whether you are shipping a new model, contributing an optimized kernel, or simply debugging a forward pass, the code remains transparent and hackable.</p>
 <p>This is a living document, not a stone tablet. Tell us where these tenets fall short or should evolve next. We’ll keep working, and we’ll be here to share the journey with you all.</p> </main> </section> <footer class="footer"> <div class="footer-inner"> <section class="citation-block"> <h3>Citation</h3> <p>For attribution, cite this work as</p> <pre class="citation short">Pablo Montalvo, Lysandre Debut, Pedro Cuenca, Yoni Gozlan (2025). &quot;Maintain the unmaintainable: 1M python loc, 400+ models&quot;.</pre> <p>BibTeX citation</p> <pre class="citation long">@misc{montalvo2025_maintain_the_unmaintaina,
   title={Maintain the unmaintainable: 1M python loc, 400+ models},
   author={Pablo Montalvo and Lysandre Debut and Pedro Cuenca and Yoni Gozlan},
diff --git a/app/dist/index.html.gz b/app/dist/index.html.gz
index 76b8327a7723da109a0103d6aa0a46940a8afcd6..25ae079dd672766ee6cb6026b3d54a9d9e663b9a 100644
--- a/app/dist/index.html.gz
+++ b/app/dist/index.html.gz
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f073b768a6cf51ffeccf975a1448aa1ecf36a3fd42daf0626356f5bdb01597f4
-size 64292
+oid sha256:e6ba9616dba9dfa5cc9ef3815f320ccb912d7e70851a5a4e7888917e1eebce23
+size 64010
diff --git a/app/src/content/article.mdx b/app/src/content/article.mdx
index 903d3f6ac510308957c8a752138fc498d9235f4f..1dc0266e0b8caa8ed790bded00c765088b28ebb4 100644
--- a/app/src/content/article.mdx
+++ b/app/src/content/article.mdx
@@ -47,13 +47,15 @@ import modelDebugger from "./assets/image/model_debugger.png";
 
 ## Preface
 
-One million lines of `python` code. Through them, the `transformers` library supports more than 400 model architectures, from state-of-the-art LLMs and VLMs to specialized models for audio, video, and tables.
+One million lines of `Python` code. Through them, the [`transformers`](https://github.com/huggingface/transformers) library supports more than 400 model architectures, from state-of-the-art LLMs and VLMs to specialized models for audio, video, and tables.
 
-Built on `PyTorch`, transformers is a foundational tool for modern LLM usage, research, education, and tens of thousands of other open-source projects. Each AI model is added by the community, harmonized into a consistent interface, and tested daily on a CI to ensure reproducibility.
+Built on `PyTorch`, it's a foundational tool for modern LLM usage, research, education, and tens of thousands of other open-source projects. Each AI model is added by the community, harmonized into a consistent interface, and tested daily on a CI to ensure reproducibility.
 
 This scale presents a monumental engineering challenge.
 
-How do you keep such a ship afloat, made of so many moving, unrelated parts, contributed to by a buzzing hivemind? Especially as the pace of ML research accelerates? We receive constant feedback on everything from function signatures with hundreds of arguments to duplicated code and optimization concerns, and we listen to all of it, or try to. The library's usage keeps on growing, and we are a small team of maintainers and contributors, backed by hundreds of open-source community members. 
+How do you keep such a ship afloat, made of so many moving, unrelated parts, contributed to by a buzzing hivemind? Especially as the pace of ML research accelerates?
+
+We receive constant feedback on everything from function signatures with hundreds of arguments to duplicated code and optimization concerns, and we listen to all of it, or try to. The library's usage keeps on growing, and we are a small team of maintainers and contributors, backed by hundreds of open-source community members. 
 We continue to support all new models and expect to do so for the foreseeable future.
 
 This post dissects the design philosophy that makes this possible. It's the result of an evolution from our older principles, detailed on our previous [philosophy](https://huggingface.co/docs/transformers/en/philosophy) page, as well as its accompanying [blog post from 2022](https://huggingface.co/blog/transformers-design-philosophy). More recently (and we strongly recommend the read) we publish a blog post about [recent upgrades to transformers](https://huggingface.co/blog/faster-transformers), focusing on what makes the library faster today. All of these developments are only made possible thanks to these principles.
@@ -88,26 +90,27 @@ These principles were not decided in a vacuum. The library _evolved_ towards the
 <li class="tenet">
 <a id="source-of-truth"></a>
 <strong>Source of Truth</strong>
-<p>We aim to be a [source of truth for all model definitions](https://huggingface.co/blog/transformers-model-definition). This is more of a goal than a tenet, but it strongly guides our decisions. Model implementations should be reliable, reproducible, and faithful to the original implementations. If we are successful, they should become reference baselines for the ecosystem, so they'll be easily adopted by downstream libraries and projects. It's much easier for a project to always refer to the transformers implementation, than to learn a different research codebase every time a new architecture is released.</p>
-<em>This overarching guideline ensures quality and reproducibility across all models in the library, and aspires to make the community work easier.</em>
+<p>We aim be the [source of truth for all model definitions](https://huggingface.co/blog/transformers-model-definition). This is not a tenet, but something that guides our decisions. Model implementations should be reliable, reproducible, and faithful to the original performances.</p>
+<em>This overarching guideline ensures quality and reproducibility across all models in the library.</em>
 </li>
 
 <li class="tenet">
 <a id="one-model-one-file"></a>
 <strong>One Model, One File</strong>
 <p>All inference and training core logic has to be visible, top‑to‑bottom, to maximize each model's hackability.</p>
-<em>Every model should be completely understandable and hackable by reading a single file from top to bottom.</em>
+<em>Every model should be understandable and hackable by reading a single file from top to bottom.</em>
 </li>
+
 <li class="tenet">
 <a id="code-is-product"></a>
-<strong>Code is Product</strong>
-<p>Optimize for reading, diffing, and tweaking, our users are power users. Variables should be explicit, full words, even several words, readability is primordial.</p>
+<strong>Code is the Product</strong>
+<p>Optimize for reading, diff-ing, and tweaking, our users are power users. Variables can be explicit, full words, even several words, readability is primordial.</p>
 <em>Code quality matters as much as functionality - optimize for human readers, not just computers.</em>
 </li>
 <li class="tenet">
 <a id="standardize-dont-abstract"></a>
 <strong>Standardize, Don't Abstract</strong>
-<p>If it's model behavior, keep it in the file; use abstractions only for generic infra.</p>
+<p>If it's model behavior, keep it in the file; abstractions are only for generic infra.</p>
 <em>Model-specific logic belongs in the model file, not hidden behind abstractions.</em>
 </li>
 <li class="tenet">
@@ -121,14 +124,14 @@ These principles were not decided in a vacuum. The library _evolved_ towards the
 <li class="tenet">
 <a id="minimal-user-api"></a>
 <strong>Minimal User API</strong>
-<p>Config, model, preprocessing; from_pretrained, save_pretrained, push_to_hub. We want the least amount of codepaths. Reading should be obvious, configurations should be obvious.</p>
+<p>Config, model, pre-processing; from_pretrained, save_pretrained, push_to_hub. We want the least amount of codepaths. Reading should be obvious, configurations should be obvious.</p>
 <em>Keep the public interface simple and predictable, users should know what to expect.</em>
 </li>
 <li class="tenet">
 <a id="backwards-compatibility"></a>
 <strong>Backwards Compatibility</strong>
 <p>Evolve by additive standardization, never break public APIs.</p>
-<p>Any artifact that was once on the hub and loadable with transformers should be usable indefinitely with the same interface. Further, public methods should not change to avoid breaking dependencies. If we do deprecate something, it's with very long cycles beforehand.</p>
+<p>Any artifact that was once on the hub and worked with transformers should be usable indefinitely with the same interface. Further, public methods should not change to avoid breaking dependencies.</p>
 <em>Once something is public, it stays public, evolution through addition, not breaking changes.</em>
 </li>
 <li class="tenet">
@@ -158,15 +161,15 @@ def rotate_half(x):
 ```
 
 
-We want all models to have self-contained modeling code. Every core functionality _must_ be in the modeling code, every non-core functionality _can_ be outside of it.
+We want all models to have self-contained modeling code.
 
-This comes at a great cost. For years, we have used what we call the `#Copied from...` mechanism: we added comments of a specific format documenting that some code was copied from another model, saving time both for the reviewers and for the CI: we had tooling to ensure that the copied blocks remained in sync.
+Each core functionality _must_ be in the modeling code, every non-core functionality _can_ be outside of it.
 
-But the LOC count kept creeping up. Each new model copied over hundreds of lines that we considered largely boilerplate, yet, we could not remove them.
+This comes as a great cost. Enter the `#Copied from...` mechanism: for a long time, these comments were indicating that some code was copied from another model, saving time both for the reviewers and for the CI. But the LOC count kept creeping up. Each new model copied over hundreds of lines that we considered largely boilerplate, yet, we could not remove them.
 
-We needed to separate two principles that were so far intertwined, <Tenet term="do-repeat-yourself" display="repetition" position="top" /> and <Tenet term="one-model-one-file" display="hackability" position="top" />.
+We need to separate both principles that were so far intertwined, <Tenet term="do-repeat-yourself" display="repetition" position="top" /> and <Tenet term="one-model-one-file" display="hackabilty" position="top" />.
 
-What is the solution to this? Let's talk about modular transformers.
+What's the solution to this?
 
 <Note variant="info">
 <strong>TL;DR:</strong> Read the code in one place, <Tenet term="one-model-one-file" display="one model, one file." position="top" />. Keep semantics local (<a href="#standardize-dont-abstract">Standardize, Don't Abstract</a>). Allow strategic duplication for end users (<a href="#do-repeat-yourself">DRY*</a>). Keep the public surface minimal and stable (<a href="#minimal-user-api">Minimal API</a>, <a href="#backwards-compatibility">Backwards Compatibility</a>, <a href="#consistent-public-surface">Consistent Surface</a>).
@@ -486,7 +489,7 @@ Parallelization is specified in the configuration (<code>tp_plan</code>), not th
 
 ### <a id="layers-attentions-caches"></a> Layers, attentions and caches
 
-Following the same logic, the _nature_ of attention and per-layer caching should not be hardcoded. We should be able to specify in the configuration how each layer is implemented. Thus, we define a mapping like:
+Following the same logic, the _nature_ of attention and caching per layer of a model should not be hardcoded. We should be able to specify in a configuration-based fashion how each layer is implemented. Thus we define a mapping that can be then
 
 
 ```python
@@ -594,11 +597,9 @@ Llama-lineage is a hub; several VLMs remain islands — engineering opportunity
 
 ### Many models, but not enough yet, are alike
 
-I look into Jaccard similarity, which we use to measure set differences, to find similarities across models. I know that code is more than a set of characters stringed together. We also try code-embedding models that rank candidates better in practice, but for this post we stick to the deterministic Jaccard index. 
+Next, I looked into Jaccard similarity, which we use to measure set differences. I know that code is more than a set of characters stringed together. I also used code embedding models to check out code similarities, and it yielded better results, for the needs of this blog post I will stick to Jaccard index.
 
-It is interesting, for our comparison, to look at _when_ we deployed the modular logic and what was its rippling effect on the library. Looking at the timeline makes it obvious: adding modular allowed to connect more and more models to solid reference points.
-
-Yet, we still have a lot of gaps to fill.
+It is interesting, for that, to look at _when_ we deployed this modular logic and what was its rippling effect on the library. You can check the [larger space](https://huggingface.co/spaces/Molbap/transformers-modular-refactor) to play around, but the gist is: adding modular allowed to connect more and more models to solid reference points. We have a lot of gaps to fill in still.
 
 Zoom out below - it's full of models. You can click on a node to see its connections better, or use the text box to search for a model. You can use the [full viewer](https://huggingface.co/spaces/Molbap/transformers-modular-refactor) (tab "timeline", hit "build timeline") for better exploration.
 
@@ -722,11 +723,9 @@ This is an overall objective: there's no `transformers` without its community.
 
 Having a framework means forcing users into it. It restrains flexibility and creativity, which are the fertile soil for new ideas to grow.
 
-Among the most valuable contributions to `transformers` is of course the addition of new models. Very recently, [OpenAI added GPT-OSS](https://huggingface.co/blog/welcome-openai-gpt-oss), which prompted the addition of many new features to the library in order to support [their model](https://huggingface.co/openai/gpt-oss-120b).
-
-These additions are immediately available for other models to use.
+Among the most valuable contributions to `transformers` is of course the addition of new models. Recently, [OpenAI added GPT-OSS](https://huggingface.co/blog/welcome-openai-gpt-oss), which prompted the addition of many new features to the library in order to support [their model](https://huggingface.co/openai/gpt-oss-120b).
 
-Another important advantage is the ability to fine-tune and pipeline these models into many other libraries and tools. Check here on the hub how many finetunes are registered for [gpt-oss 120b](https://huggingface.co/models?other=base_model:finetune:openai/gpt-oss-120b), despite its size!
+A second one is the ability to fine-tune and pipeline these models into many other softwares. Check here on the hub how many finetunes are registered for [gpt-oss 120b](https://huggingface.co/models?other=base_model:finetune:openai/gpt-oss-120b), despite its size!
 
 
 <Note variant="info">
