QCNEWS
The open dataset matches 1.3 million code files with records of how they actually run, so AI can be trained on what code does at runtime, not just how it reads.
Today's best coding models can produce code that compiles and passes a code review, but they cannot reliably predict what that code will do at runtime. They might write a function that looks correct and still loop forever, leak memory, or break on edge cases. IBM's newly open-sourced CodeAlchemy dataset is built around that gap. It pairs synthetic code with execution traces so the next training run can be supervised on what code does, not just what it looks like.
The doorway is a familiar developer habit. When a program misbehaves, a human engineer traces it: runs the code, watches each line fire, and records what each input produces. CodeAlchemy is the AI-training version of the same exercise. Instead of teaching a model that a function reads as valid Python, it teaches the model that the function, given specific inputs, returns a specific result, raises a specific exception, or hits a specific branch.
The release's novelty is the supervision signal. The dataset spans 15 programming languages and includes 1.3 million code files, each paired with an execution trace. Total size: about 1 trillion tokens, which the IBM Research blog puts at roughly 200 times the size of Wikipedia, near 5 billion tokens. The companion paper, "CodeAlchemy: Synthetic Code Rewriting at Scale", documents the pipeline that rewrites and instruments the code so each file has a recorded runtime history attached.
IBM's framing, in its own research post, is that this is the first dataset to pair code files with execution traces at this scale. The size claim is the part most exposed to peer-dataset comparison; the trace mechanism is the part most defensible as a methodological move. Earlier public synthetic-code corpora, including OctoPack, HumanEval-X, and derivatives of The Stack v2, optimized on volume rather than runtime behavior. CodeAlchemy adds a dynamic-behavior axis.
That axis is a response to a real pressure in the field. High-quality human-written code is being absorbed into commercial models or locked behind proprietary licenses. What remains publicly scrapeable is, on average, middling. The IBM AI researcher Ankit Gupta, in the same blog post, puts the limit plainly: GitHub-scraped code teaches a model what code looks like, not what happens when it executes on different inputs. The synthetic-data turn is a reaction to that constraint, not a triumph over it.
CodeAlchemy extends a lineage IBM has been building for years. In 2021, roughly two years before ChatGPT, IBM released CodeNet, a corpus of real-world code with execution traces designed to teach models to write code. CodeAlchemy inherits the trace idea but swaps the source material. Where CodeNet leaned on static, real-world samples, CodeAlchemy uses synthetic rewriting at scale, with traces as the supervision signal. CodeNet taught models to write code. CodeAlchemy aims to teach them what that code means once it runs.
The IBM blog does not publish a Granite benchmark delta against prior open models trained on static corpora, which would be the most direct test of the trace-axis claim. Until that comparison lands, the release's news is the execution-trace pairing itself, not the trillion-token number that frames it.