REVIEW 49 cited by
OpenCoder: The Open Cookbook for Top-Tier Code Large Language Models
Not yet reviewed by Pith; the record is open.
This paper has not been read by Pith yet. Machine review is queued; the pith claim, tier, and objections will appear here once it completes.
SPECIMEN: schema-true, not a live event
T0 review · schema-true
One-sentence machine reading of the paper's core claim.
pith:XXXXXXXX · record.json · timestamp
Signed reviews
read the original abstract
Large language models (LLMs) for code have become indispensable in various domains, including code generation, reasoning tasks and agent systems. While open-access code LLMs are increasingly approaching the performance levels of proprietary models, high-quality code LLMs suitable for rigorous scientific investigation, particularly those with reproducible data processing pipelines and transparent training protocols, remain limited. The scarcity is due to various challenges, including resource constraints, ethical considerations, and the competitive advantages of keeping models advanced. To address the gap, we introduce OpenCoder, a top-tier code LLM that not only achieves performance comparable to leading models but also serves as an "open cookbook" for the research community. Unlike most prior efforts, we release not only model weights and inference code, but also the reproducible training data, complete data processing pipeline, rigorous experimental ablation results, and detailed training protocols for open scientific research. Through this comprehensive release, we identify the key ingredients for building a top-tier code LLM: (1) code optimized heuristic rules for data cleaning and methods for data deduplication, (2) recall of text corpus related to code and (3) high-quality synthetic data in both annealing and supervised fine-tuning stages. By offering this level of openness, we aim to broaden access to all aspects of a top-tier code LLM, with OpenCoder serving as both a powerful model and an open foundation to accelerate research, and enable reproducible advancements in code AI.
Forward citations
Cited by 49 Pith papers
-
ProSec: Fortifying Code LLMs with Proactive Security Alignment
ProSec synthesizes vulnerability-inducing coding scenarios from CWE definitions and uses preference learning on model-generated fixes to make code LLMs up to 35.4% more secure on the PurpleLlama benchmark.
-
SWE-Flow: Synthesizing Software Engineering Data in a Test-Driven Manner
SWE-Flow synthesizes incremental, test-driven development tasks from real GitHub projects and shows that fine-tuning Qwen2.5-Coder-32B-Instruct on them improves performance on the resulting SWE-Flow-Bench benchmark.
-
PoLoRA: A Preconditioned Orthogonalized LoRA Optimizer
A preconditioned, product-aware spectral optimizer for LoRA reaches Adam's final loss in 1.2–1.7x fewer steps on instruction-tuning, with ~3% per-step overhead.
-
Selective Left-Shift: Turning Test-Time Compute and Difficulty-based Curation into Training Data for Low-Resource Code Generation
Left-shifting iterative compiler/test refinement into verified SFT data, then GRPO on difficulty-curated IO rewards, lifts Qwen3-8B Julia pass@1 past prior SOTA at 1/3 data and 1/6 cost, and bootstraps Ballerina.
-
Fine-Tuning Masked Diffusion for Provable Self-Correction
PRISM fine-tunes any masked diffusion model with a binary-cross-entropy loss so its new head provably estimates per-token quality p(x_i=y_i|y⊕m_i) and can remask low-quality tokens at inference.
-
Understanding Benchmark Language Under Weakened Formal Semantics
ICRAG, a retrieval-augmented iterative code-generation framework, improves accuracy on 13 NLP benchmarks by compiling questions into Python programs and executing them, though gains are partly inflated by in-distribut...
-
Empirical Study of Code Large Language Models for Binary Security Patch Detection
Fine-tuned code LLMs detect binary security patches accurately on decompiler pseudo-code, and adding source-code patches to the training data improves accuracy and F1 further.
-
Delta Activations: A Representation for Finetuned Large Language Models
Delta Activations embed finetuned LLMs as the average difference in hidden states between the finetuned model and its base model on a small set of generic prompts, yielding domain clusters and approximate additive com...
-
Any-Order Flexible Length Masked Diffusion
FlexMDM is a discrete diffusion model that provably supports any-order generation over variable-length sequences by learning an insertion expectation alongside the unmasking posterior, validated by length-fidelity, ma...
-
VERIRL: Boosting the LLM-based Verilog Code Generation via Reinforcement Learning
VERIRL applies reinforcement learning with a trace-back rescore mechanism and sample-balanced weighting to achieve state-of-the-art Verilog code generation.
-
AutoCodeBench: Large Language Models are Automatic Code Benchmark Generators
AutoCodeBench is an LLM-generated, sandbox-verified code benchmark with 3,920 problems across 20 languages, where top models reach only 52.4% pass@1.
-
IFEvalCode: Controlled Code Generation
A 1,620-sample, 8-language, Chinese/English benchmark separates code correctness from instruction-following and shows instruction compliance is far lower than correctness across 40+ LLMs.
-
Falcon-H1: A Family of Hybrid-Head Language Models Redefining Efficiency and Performance
Falcon-H1 reports competitive benchmark scores for a 0.5B to 34B family of parallel hybrid attention/Mamba-2 models, claiming 2x to 4x parameter efficiency versus dense transformers.
-
CodeEvo: Interaction-Driven Synthesis of Code-centric Data through Hybrid and Iterative Feedback
CodeEvo uses two interacting LLM agents with keyword-guided instruction evolution and hybrid compiler-plus-LLM feedback to synthesize high-quality instruction-code pairs for fine-tuning code models.
-
Turning the Tide: Repository-based Code Reflection
A new 1,888-case, six-language benchmark and a trained model measure and improve how code LLMs edit and repair code inside multi-file repositories.
-
DiffuCoder: Understanding and Improving Masked Diffusion Models for Code Generation
A 7B masked-diffusion code model plus complementary-mask GRPO (coupled-GRPO) improves benchmark scores and shifts decoding away from strict left-to-right order.
-
Essential-Web v1.0: 24T tokens of organized web data
A 24T-token web corpus with automatic document-level taxonomy labels enables competitive domain-specific datasets via simple filters.
-
ProtocolLLM: RTL Benchmark for SystemVerilog Generation of Communication Protocols
A new benchmark, ProtocolLLM, evaluates LLM-generated SystemVerilog for SPI, I2C, UART, and AXI and finds most models fail timing-accurate functional checks.
-
Seed-Coder: Let the Code Model Curate Data for Itself
Seed-Coder shows that an LLM-trained quality scorer can filter 6T tokens of code data and yield 8B models that outperform similar-size open code models.
-
Afterburner: Reinforcement Learning Facilitates Self-Improving Code Efficiency Optimization
Reinforcement learning with execution feedback enables a code model to iteratively improve the efficiency of its own generated code, surpassing supervised and preference-based training methods.
-
rStar-Coder: Scaling Competitive Code Reasoning with a Large-Scale Verified Dataset
A large verified dataset of 418K competition code problems built by synthesis, test-input utility functions, and majority-vote output labeling improves small model code reasoning to frontier level.
-
Success is in the Details: Evaluate and Enhance Details Sensitivity of Code LLMs through Counterfactuals
Code LLMs drop by more than 10% in accuracy when problem details are subtly changed, and fine-tuning on such counterfactual variants boosts performance on standard benchmarks.
-
Tests as Prompt: A Test-Driven-Development Benchmark for LLM Code Generation
The paper builds a 1000-task test-driven development benchmark for LLMs and concludes that instruction following and in-context learning matter more than general coding proficiency.
-
CodeMixBench: Evaluating Large Language Models on Code Generation with Code-Mixed Prompts
CodeMixBench adds code-mixed prompt variants to BigCodeBench and shows that code-mixed inputs consistently reduce Pass@1 performance of code LLMs.
-
CodeI/O: Condensing Reasoning Patterns via Code Input-Output Prediction
Training on 3.5M code input-output prediction tasks with natural-language chain-of-thought improves LLM performance on math, logic, symbolic, scientific, and commonsense reasoning benchmarks.
-
ACECODER: Acing Coder RL via Automated Test-Case Synthesis
ACECODER shows that automatically synthesized test cases can serve as scalable reward signals for code RL, yielding consistent gains on HumanEval, MBPP, BigCodeBench, and LiveCodeBench.
-
BRiTE: Bootstrapping Reinforced Thinking Process to Enhance Language Model Reasoning
BRiTE is an EM-style algorithm that uses RL to sample high-likelihood reasoning chains and fine-tunes the LLM on them, with a theoretical 1/T convergence rate and mixed empirical gains.
-
CodeElo: Benchmarking Competition-level Code Generation of LLMs with Human-comparable Elo Ratings
CodeElo benchmarks LLMs by submitting their solutions to CodeForces's official judge and converting results into human-comparable Elo ratings, with o1-mini at 1578 and most open models below the 20th human percentile.
-
QUBE: Enhancing Automatic Heuristic Design via Quality-Uncertainty Balanced Evolution
QUBE adds a UCB-style uncertainty term to FunSearch's parent selection and finds better heuristics on bin packing and TSP, with cap set gains only over a same-hardware reproduction.
-
Dream-Coder 7B: An Open Diffusion Language Model for Code
An open 7B diffusion language model for code, adapted from Qwen2.5-Coder, reaches 21.4% pass@1 on LiveCodeBench and shows adaptive, non-left-to-right generation patterns.
-
Data Mixing Optimization for Supervised Fine-Tuning of Large Language Models
The authors introduce and test an optimization method for fine-tuning data mixtures that matches costly grid-search results within 0.66% validation loss.
-
SmallThinker: A Family of Efficient Large Language Models Natively Trained for Local Deployment
Two new MoE language models and a co-designed inference engine claim 20+ tokens/s CPU decoding under 1-8 GB memory with benchmark scores comparable to much larger models.
-
A Deep Dive into Retrieval-Augmented Generation for Code Completion: Experience on WeChat
On WeChat's closed-source codebase, similarity-based RAG with combined BM25 and GTE-Qwen retrieval improves open-source LLM code completion more than identifier-based retrieval, with gains growing for larger models.
-
Solving Formal Math Problems by Decomposition and Iterative Reflection
An agent that decomposes Lean 4 goals into subproblems and iteratively repairs proofs achieves a 95.9% pass rate on miniF2F-test using a stock Gemini model.
-
AceReason-Nemotron 1.1: Advancing Math and Code Reasoning through SFT and RL Synergy
A 7B reasoning model trained with carefully balanced SFT and RL beats prior small models on math and code benchmarks, with the paper documenting scaling and temperature heuristics.
-
HPCTransCompile: An AI Compiler Generated Dataset for High-Performance CUDA Transpilation and LLM Preliminary Exploration
A TVM-based pipeline generates 20,000 CUDA-CPU code pairs, and fine-tuning code LLMs on this data improves transpilation success and CPU performance, with an average speedup improvement of 43.8%.
-
CODE-DITING: A Reasoning-Based Metric for Functional Alignment in Code Evaluation
CODE-DITING distills reasoning from a large reasoning LLM into 1.5B and 7B judges that evaluate generated code without reference solutions or test cases, beating larger judges under majority voting.
-
LLM-KG-Bench 3.0: A Compass for SemanticTechnology Capabilities in the Ocean of LLMs
LLM-KG-Bench 3.0 is an open, extensible benchmark framework with automatic scoring that compares more than 30 LLMs on RDF and SPARQL knowledge graph tasks.
-
DeepDistill: Enhancing LLM Reasoning Capabilities via Large-Scale Difficulty-Graded Data Training
A two-stage SFT recipe using pass-rate and coefficient-of-variation based data selection from a 40M-response distilled dataset lifts Qwen2.5-72B to 79.2% on AIME2024, nearly matching RL-trained reasoning models.
-
BitsAI-CR: Automated Code Review via LLM in Practice
An industrial LLM-based code review system with a two-stage generate-and-filter pipeline and a data flywheel reached 75% precision and a 26.7% developer-action rate on Go code at ByteDance.
-
InfiFusion: A Unified Framework for Enhanced Cross-Model Reasoning via LLM Fusion
InfiFusion fuses multiple large language models into one pivot model using enhanced universal logit distillation, and reports that the fused model outperforms all source models on 11 benchmarks with a fraction of the ...
-
HumanEval Pro and MBPP Pro: Evaluating Large Language Models on Self-invoking Code Generation
HumanEval Pro and MBPP Pro test whether LLMs can first solve a base function and then call it inside a more complex solution, and frontier models lose about 10 to 15 points on this task.
-
Typhoon 2: A Family of Open Text and Multimodal Thai Large Language Models
Typhoon 2 improves Thai LLM performance through continual pre-training on curated Thai data and post-training, releasing text, vision, audio, and safety models.
-
ExecRepoBench: Multi-level Executable Code Completion Evaluation
ExecRepoBench is an executable, repository-level code completion benchmark with unit tests, and Qwen2.5-Coder-Instruct-C is a 7B model fine-tuned on the accompanying Repo-Instruct corpus.
-
Secure Code Generation at Scale with Reflexion
Three-round reflexion prompting raises LLM-generated code security from 70.74% to 79.43% as measured by the ICD static detector on the Instruct Prime benchmark.
-
A Survey on Latent Reasoning
A survey that organizes latent reasoning methods into vertical recurrence, horizontal recurrence, and infinite-depth diffusion, arguing that silent reasoning can beat explicit chain-of-thought.
-
YuLan-Mini: An Open Data-efficient Language Model
A 2.42B-parameter base model trained on 1.08T tokens matches or beats several industry baselines trained on 7T to 18T tokens across math, code, and general benchmarks.
-
CogniSQL-R1-Zero: Lightweight Reinforced Reasoning for Efficient SQL Generation
A 7B model trained with GRPO and a sparse execution-correctness reward reaches 59.97% execution accuracy on BIRD dev, though the evaluation protocol and baseline numbers contain inconsistencies.
-
Exploring the Potential of Offline RL for Reasoning in LLMs: A Preliminary Study
Applying LD-DPO to the DeepDistill-32B model improves average benchmark scores by 3.3 points, but the gains are uneven, the tables are inconsistent, and the evidence is preliminary.
Discussion (0). Continue with ORCID to comment.