TL;DR
Get business pricing on tech for your team
- Business-only prices and quantity discounts
- Tax-exempt purchasing
- Multiple users, one account, clear invoices
Hugging Face says it fine-tuned a 20B open-weight model, Palette, to create slide decks following IBM Design Language. The company reports that Palette ranked first in two of three PresentBench domains it measured; the post does not provide scores or enough detail to assess how it compares with frontier models overall.
Hugging Face says it fine-tuned a 20B open-weight model called Palette to create slide decks in IBM Design Language, using a workflow that separates planning the deck from writing the code for each slide. The company reports that the model ranked first in two of three PresentBench domains it measured, but the supplied post gives no scores or comparison details to judge that result independently.
Palette divides deck creation between two roles served by a single LoRA adapter. A designer role turns the input into a structured JSON brief covering the deck’s palette, type system, slide layouts, content and design rationale. A coder role then uses each slide’s specification to write pptxgenjs JavaScript for the layout. Hugging Face says the split allows slide coding to run in parallel, making that stage about six to seven times faster than running it sequentially.
The training set was synthesized with a larger open model because, according to the post, there is no public corpus containing the plans, design decisions and code behind finished decks. Hugging Face says it generated about 1,000 decks, covering roughly 10,000 slides, with examples spanning different genres, lengths, layouts and input styles. The examples include counterfactual reasoning: explanations of why a design choice was made over an alternative.
The company says it rendered each generated deck and checked for overlaps and text overflow. It repaired broken slides and revised the associated reasoning into additional training examples. The post also describes a faithfulness problem: when a specification lacked enough information, the model could fill gaps with invented content. Hugging Face says examples from reference decks helped steer the teacher model’s output more reliably than adding more prompt rules.
Palette builds branded decks with a two-role workflow
Hugging Face says its 20B open-weight model creates slide decks in IBM Design Language. The approach separates planning from slide coding, while benchmark and deployment evidence remains limited.
From brief to slide code
One LoRA adapter serves two roles, keeping editorial choices separate from layout implementation.
Creates a structured brief for content, palette, typography, layouts and rationale.
Turns each slide specification into pptxgenjs JavaScript; slides can be coded in parallel.
Training includes design reasoning
Synthetic examples teach both how a deck looks and why its design choices were made.
Deck examples
About 1,000 decks covered roughly 10,000 slides across varied genres, lengths and layouts.
Render and repair
Generated decks were checked for overlaps and text overflow; broken slides were repaired and added to training.
Unsupported content
When briefs lacked detail, the model could invent content. Reference-deck examples helped guide the teacher model.
What the evidence supports
- First place in two of three measured PresentBench domains.
- Slide coding about six to seven times faster with parallel work.
- A workflow designed for an organization’s design language.
- Scores, domain names, baselines and evaluation conditions.
- Performance beyond IBM Design Language or on demanding decks.
- Public availability, deployment safeguards and independent results.
A Smaller Model for Branded Slides
Palette targets two practical limits of using general-purpose models for presentations: their outputs may not match an organization’s design system, and sending confidential material to an external service may be unsuitable. An open-weight model that can run on an organization’s own infrastructure could give teams more control over both the visual style and where their inputs are processed. The post presents these as motivations for the project; it does not report deployment results or establish how well Palette protects sensitive information in practice.
The reported benchmark result is a signal that a smaller model can perform competitively on at least some measured deck-building tasks, but it is not enough to establish broad superiority. The post says Palette ranked first in two of three domains, without identifying the domains, scores, competing systems, or evaluation conditions in the supplied material. The evidence therefore supports a narrower claim: Hugging Face reports a strong result on part of its PresentBench evaluation.
Products Worth Considering
Bose SoundLink Flex Bluetooth Speaker (2nd Gen), Waterproof, Dustproof, USB‑C, Up to 12 hr Battery, Black
Amazon Kindle Scribe Colorsoft, 64GB, 11-Inch Color Display with Premium Pen
Samsung 27-inch Odyssey G5 QHD Gaming Monitor (G51F)
As an affiliate, we earn on qualifying purchases.
Why Deck Generation Needs Two Roles
Generating a presentation requires more than writing concise text. The model must decide what belongs on each slide and also translate those choices into positions, font sizes and shapes. Hugging Face says small models often make layout errors because they write code without seeing the rendered slide until afterward. Text can overflow, elements can overlap, and titles can become difficult to read.
The project addresses this by separating editorial planning from slide geometry. A deck-wide brief sets the content and visual decisions before slide code is produced, and that brief can be edited by a person or another agent. Hugging Face also says coder examples were about five times longer than designer examples, so the team oversampled designer examples fivefold to avoid undertraining that role. Training used LoRA, which the post says made experiments less expensive while adding the deck-building format and skill to the base model.
“The designer handles the editorial judgment, and the coder handles the geometry.”
— Hugging Face, describing Palette’s approach
Benchmark Scope and Deployment Details
The supplied material does not give PresentBench scores, domain names, baselines or evaluation settings, so the reported rankings cannot be compared quantitatively with other models here. It also does not identify the 20B base model, provide a public model release or license, or show independent testing of the generated decks.
It remains unclear how Palette performs on presentations with complex data, strict factual requirements or design systems beyond IBM Design Language. The post says its workflow can be trained in a user’s design language, but the supplied account focuses on IBM’s system and does not give results from other templates. It also does not specify the safeguards or operational conditions for running the model on private infrastructure.
Release and Broader Testing
The post describes how Hugging Face generated training data, fine-tuned Palette and built a checking harness, but the supplied material does not announce a release date or say when model weights, code or evaluation results will be available. Those details would let developers reproduce the approach and test the claims on their own presentations.
Further evidence would also need to show performance across different design languages and longer or more demanding decks, including how often the checker catches layout failures and how frequently the model adds unsupported facts. Until those results are available, the reported benchmark ranking and speed improvement remain claims from the project’s authors.
Where I land
I see Palette’s clearest contribution in its structured workflow: separating what a deck should say from the geometry needed to draw it gives teams a place to inspect and edit decisions. The render-and-check loop also addresses a real weakness of code-generated slides. Hugging Face’s reported PresentBench result is encouraging, but the missing scores and evaluation details keep me from judging how much it establishes.
The strongest counterargument is that a model trained on synthetic decks and one design language may perform well on the tasks it was built around while struggling with unfamiliar templates, dense data or strict factual constraints. The post itself describes invented content as a failure mode. I would update my assessment if Hugging Face published reproducible benchmark results, released the model and harness, and showed independent tests across multiple design systems with measured rates for layout errors and unsupported claims.
Key Questions
What is Palette?
Palette is a fine-tuned 20B open-weight model that Hugging Face says it trained to build slide decks in IBM Design Language.
How does Palette create a deck?
It first produces a structured brief with the content and design choices for each slide. A second role uses that brief to write pptxgenjs code for the slides.
What benchmark result did Hugging Face report?
Hugging Face says Palette ranked first in two of the three PresentBench domains it measured. The supplied post does not include the scores, domain names or comparison setup.
Can Palette run on private infrastructure?
The project is framed around an open-weight model that organizations could self-host. The supplied material does not provide deployment instructions or independent evidence about its use with confidential data.
Is Palette publicly available?
The supplied source does not say whether or when the model weights or code will be released.
Source: Hugging Face
