Skip to content
Main Site News Console

Palette: Teaching Small Models to Create Slides in Your Design Language

· Hugging Face Translated
教程模型卡

Ask a leading frontier model for a slide deck, and you will usually get a decent result. But ask it for ten, and they all start looking the same: the same tasteful defaults, the same baked-in style, and an unmistakable whiff of “AI-generated presentation.” That might be fine for everyday tasks, but problems arise when you need the deck to adhere to your own template style. Frontier models have an indelible default aesthetic, and no amount of prompting can stop them from drifting back to their ingrained habits. On top of that, presentation content is often confidential and simply cannot leave your local systems.

Both issues point to the same solution: owning your model—open-weights, running on your own infrastructure, and trained on your own design language. The catch, however, is that the small open-source models you would actually want to self-host are terrible at this. The decks they produce are riddled with flaws: titles vanish into the background, text spills over slide boundaries, and shapes pile haphazardly on top of one another.

Palette explores a hypothesis: that a small open-source model, trained on synthetic data derived from your own design language and validated by a test harness, can go toe-to-toe with frontier model systems while ensuring you retain complete ownership of the output. We fine-tuned a 20B-parameter model to build decks the way humans do: with a designer planning the deck and a coder drawing each slide. Trained on data adhering to the IBM Design Language, it ranks first in two out of the three domains we evaluated on the PresentBench benchmark. This post details how we synthesized the data, trained the model, and built a verification and repair harness around it.

Why Small Models Struggle with Decks

Slide decks look simple, but producing one demands three things that small models are notoriously bad at:

Laying out slides blind. The model does not draw the slide directly; instead, it writes code that positions every element at specific x and y coordinates, widths, and font sizes. Figuring out whether a 75-character title fits on two lines at 56pt requires doing arithmetic in its “head,” and it only discovers if it miscalculated after the code renders. Small models miscalculate often, which is why shapes overlap and text bleeds off the slide.

Making two very different kinds of decisions at once. Deciding what goes on each slide and how to present it (chart vs. table? what gets cut?) is a matter of editorial judgment. Laying it out with precise positioning is a geometry problem. A single inference pass must handle both across 10 to 20 slides while maintaining consistency across the color palette, typography, and overall layout.

A lack of data showing how decks are made. Finished decks are abundant, but there is virtually no data explaining the design rationale behind them or the code used to generate them.

Build It Like a Human: A Designer and a Coder

Nobody builds a deck in a single pass. You always map out the narrative arc first—how many slides, what each one covers, which gets a chart, which gets a table—and only then do you build them slide by slide. Palette divides the work the same way, using a single LoRA adapter that plays two distinct roles:

  • The Designer: Reads the outline and writes a structured JSON brief covering the color palette, typography system, per-slide layouts, exact content, and a brief design rationale for each choice.
  • The Coder: Takes the specification for a single slide from the brief and, after providing its reasoning, writes the pptxgenjs JavaScript code to render that slide.

This way, each role only has to make