Lois d'échelle pour le code : chaque langage de programmation compte

Scaling Laws for Code: Every Programming Language Matters

December 15, 2025

papers.authors: Jian Yang, Shawn Guo, Lin Jing, Wei Zhang, Aishan Liu, Chuan Hao, Zhoujun Li, Wayne Xin Zhao, Xianglong Liu, Weifeng Lv, Bryan Dai

cs.AI

papers.abstract

Les modèles de grands langages de code (Code LLMs) sont puissants mais coûteux à entraîner, les lois d'échelle prédisant traditionnellement les performances à partir de la taille du modèle, des données et de la puissance de calcul. Cependant, différents langages de programmation (PLs) ont des impacts variables lors du pré-entraînement qui affectent significativement les performances du modèle de base, conduisant à des prédictions inexactes. De plus, les travaux existants se concentrent sur des cadres agnostiques au langage, négligeant la nature intrinsèquement multilingue du développement logiciel moderne. Il est donc nécessaire d'étudier d'abord les lois d'échelle des différents PLs, puis de considérer leurs influences mutuelles pour aboutir à la loi d'échelle multilingue finale. Dans cet article, nous présentons la première exploration systématique des lois d'échelle pour le pré-entraînement multilingue de code, menant plus de 1000 expériences (équivalant à plus de 336 000 heures H800) couvrant plusieurs PLs, tailles de modèles (0,2 à 14 milliards de paramètres) et volumes de données (1 000 milliards de tokens). Nous établissons des lois d'échelle complètes pour les Code LLMs sur plusieurs PLs, révélant que les langages interprétés (ex: Python) bénéficient davantage de l'augmentation de taille de modèle et de données que les langages compilés (ex: Rust). L'étude démontre que le pré-entraînement multilingue offre des bénéfices synergiques, particulièrement entre les PLs syntaxiquement similaires. De plus, la stratégie de pré-entraînement par appariement parallèle (concaténation d'extraits de code avec leurs traductions) améliore significativement les capacités translinguistiques avec des propriétés d'échelle favorables. Enfin, une loi d'échelle multilingue proportionnelle est proposée pour allouer optimalement les tokens d'entraînement en priorisant les PLs à haute utilité (ex: Python), en équilibrant les paires à forte synergie (ex: JavaScript-TypeScript), et en réduisant l'allocation aux langages à saturation rapide (Rust), permettant d'atteindre des performances moyennes supérieures sur tous les PLs comparé à une distribution uniforme sous le même budget de calcul.

English

Code large language models (Code LLMs) are powerful but costly to train, with scaling laws predicting performance from model size, data, and compute. However, different programming languages (PLs) have varying impacts during pre-training that significantly affect base model performance, leading to inaccurate performance prediction. Besides, existing works focus on language-agnostic settings, neglecting the inherently multilingual nature of modern software development. Therefore, it is first necessary to investigate the scaling laws of different PLs, and then consider their mutual influences to arrive at the final multilingual scaling law. In this paper, we present the first systematic exploration of scaling laws for multilingual code pre-training, conducting over 1000+ experiments (Equivalent to 336,000+ H800 hours) across multiple PLs, model sizes (0.2B to 14B parameters), and dataset sizes (1T tokens). We establish comprehensive scaling laws for code LLMs across multiple PLs, revealing that interpreted languages (e.g., Python) benefit more from increased model size and data than compiled languages (e.g., Rust). The study demonstrates that multilingual pre-training provides synergistic benefits, particularly between syntactically similar PLs. Further, the pre-training strategy of the parallel pairing (concatenating code snippets with their translations) significantly enhances cross-lingual abilities with favorable scaling properties. Finally, a proportion-dependent multilingual scaling law is proposed to optimally allocate training tokens by prioritizing high-utility PLs (e.g., Python), balancing high-synergy pairs (e.g., JavaScript-TypeScript), and reducing allocation to fast-saturating languages (Rust), achieving superior average performance across all PLs compared to uniform distribution under the same compute budget.