On June 3, 2026, a Palo Alto research lab called Reve released Reve 2.0, an image generation model that does something almost every other major image generator refuses to do. Instead of turning your prompt straight into pixels, it first builds a structured, editable plan of the image, called a layout, and only then renders it. Reve sums up the result in three words. Images you can touch.
It is not a marketing slogan stretched over an ordinary diffusion model. It is the entire architecture, which Reve lays out in its announcement. And the bet looks like it is paying off. Reve 2.0 debuted at number two on the Arena Text-to-Image leaderboard, ahead of Google’s Nano Banana 2 and an earlier OpenAI image model, behind only GPT-Image-2. The lab claims it did this while training on roughly ten times fewer GPUs than the trillion-dollar competition.
This article is a full breakdown of Reve 2.0. What it actually is, how layout-based generation differs from the prompt-then-diffuse pipeline everyone else uses, how it benchmarks, who built it, what it costs, where the approach still has limits, and why two of the most respected image labs pivoted to the same idea in the same week.
TL;DR
Reve 2.0 is a frontier text-to-image and image-editing model built around an architecture the company calls a Large Layout Model. Three things make it different from the models most people use today.
First, it plans before it paints. A structured layout sits between your request and the final pixels, describing where every element goes, how big it is, and what it contains. Second, it renders at native 4K by 4K, a true 16 megapixels, with no separate upscaling step. Third, because that layout is readable and code-like, you (or an AI agent) can edit the plan directly instead of rewriting a prompt and hoping for the best.
The payoff is control. You can move one object, recolor one region, or fix one piece of text without the rest of the image transforming on you. That single capability has been the white whale of image generation since it began.
Why Text Prompts Hit a Ceiling
To understand why Reve made this bet, it helps to see how a typical modern image model works. You type a prompt. A language model expands it into a long, dense paragraph describing the scene. A diffusion model then reads that paragraph and renders pixels.
Text is wonderfully expressive, but it is also ambiguous, subjective, and lossy. That ambiguity is the enemy of control. Anyone who has spent real time with these tools knows the specific frustration. You finally get an image you love, you change three words to fix one small detail, and the whole composition rearranges itself. Ask for an exact shade of green, or for an object to sit in the top-left corner, and plain English routinely fails you.
Reve’s framing is that the problem is not the model’s intelligence. It is the representation. Going straight from prompt to pixels, they argue, is like generating an entire application without ever writing the code. It is fast to kick off but opaque, almost impossible to steer, and it shuts the creator out of the process once it starts running. The lab calls the first four years of image generation the fireworks phase. Pack as much material into the tube as possible, light it, and enjoy whatever materializes. Impressive, but not controllable.
The history of technology, Reve points out, tends to move in two phases. First humanity unleashes a powerful force. Then it learns to control it. Printing existed for centuries before the press made it configurable. People built gliders for a hundred years before the Wright brothers cracked three-axis control. Generative imaging, in this view, is finally leaving its fireworks phase and entering its control phase. The instrument of control is the layout.
What a Layout Actually Is
A layout is a structured, hierarchical description of an image. Every element in it has a location, a size, and a local description, plus optional attributes like a color value or a reference image. Put simply, it is the blueprint of the picture before any paint goes on.
The cleanest analogy is the one Reve uses itself. A layout is to an image what HTML is to a webpage, or what SVG is to a vector graphic. It separates semantic intent, meaning what the image is supposed to contain and how it is arranged, from pixel rendering, meaning how it is finally drawn. That separation is the most important idea in the whole system.
Because the layout is structured and human-readable, it becomes a shared interface. A person can edit it by hand, dragging a region or rewriting one element’s description. An AI agent can read the same structure and reason about it. And the model can refine it from natural-language instructions. You get three ways to control the same image: write an instruction, edit the structure directly, or hand it to an agent. None of them require you to re-roll the entire scene.
How the Large Layout Model Works
Working with layouts requires a new genre of model, so Reve trained its own. The system runs in three conceptual stages.
- Input. The model accepts any combination of layouts, natural-language instructions, and reference images. You can give it all three, or just one.
- Thinking. It derives a layout from an internal reasoning trace, planning the full composition before a single pixel exists. This is the visual thinking step.
- Rendering. A separate, high-performance renderer turns the finished layout into a native 4K image.
The training recipe is notable. Reve built a data pipeline on billions of images, bootstrapped from dense human annotations, to teach the system what good layouts look like. It then ran continued pretraining and post-training on open-source large language models from the Qwen family, the models released by Alibaba’s Qwen team, to instill spatial reasoning around its layout representation. In plain terms, the planning brain of Reve 2.0 is a language model retrained to think about space, and the renderer is a separate engine optimized purely for image quality and speed.
This split is the architectural heart of Reve 2.0. Diffusion models produce beautiful images but are hard to steer. Autoregressive language models are highly intelligent but slow and not especially aesthetic, and their native modality is text, not pixels. By separating planning from rendering, Reve uses each kind of model for what it is genuinely good at, rather than forcing one to do both jobs badly.
The Evidence That Layouts Win
A clever idea is only worth as much as its results, so Reve ran a large-scale ablation comparing layout models against equal-size prompt-based generators. The lab reports that the layout models won across the board, producing significantly better images. Two specific findings carry most of the weight.
Reconstruction keeps improving as you add regions. A plain text prompt can never fully reconstruct a real photograph, no matter how long and detailed the description gets. The result always drifts from the original. A layout behaves differently. As the number of labeled regions rises, Reve 2.0 reconstructs finer and finer detail, and it does this with no input pixels at all, working purely from structure. When you do supply pixels, layouts become even more powerful, because you can define exactly what changes and where.
Scaling laws apply to layouts. Image quality climbs as the model grows, which is expected. But it also climbs when the model is allowed to output more regions, which effectively widens its visual thinking context. More planning detail produces a better final image. That is a useful property, because it means quality can be bought with structure, not only with raw model size.
Native 4K and the End of Upscaling Roulette
Reve 2.0 renders at 4K by 4K natively, which the lab says makes it the fastest 4K image model in the world. At 16 megapixels, the output is print-ready straight out of the model, with no separate upscaling pass required.
That detail matters more than it first appears. Upscaling has always been one final dice roll at the end of a long sequence of dice rolls. You spend an hour getting an image exactly right, run it through an upscaler, and watch subtle details quietly shift. Reve’s answer is not a better upscaler. It is to iterate at full resolution from the start, so what you see during the creative process is what you actually get at the end. For physical media and high-quality print work, where 16 megapixels is genuinely useful, this removes a recurring source of frustration.
Editing Without Degradation
Iteration is where the layout approach reveals a second major advantage, and it solves a problem that quietly plagues every diffusion workflow.
Normal image models punish iteration. Each generated image carries small diffusion and compression artifacts. When you feed that image back in as a reference for the next generation, those artifacts get carried forward, and a fresh layer is added on top. Over a long editing session they do not just accumulate, they compound, and the picture slowly degrades into mush. Reve 2.0 fights this two ways.
| Workflow | What happens in Reve 2.0 |
|---|---|
| Editing with image references | A new rendering architecture resists this collapse, so edits stay stable across long iterative sessions |
| Editing without image references | Generating from the layout locks elements in place, so there is zero artifact accumulation |
The second case is the more striking one. Because the image is effectively defined by code, regenerating it from the layout is like rerunning the same program. The same structured input produces the same locked output, with no drift. Reve argues this turns generative editing from a series of gambles into a proper iterative creative process, which is closer to how design actually works.
One concrete beneficiary is text and typography. Because composition, positioning, and spacing are defined in the layout before rendering, Reve 2.0 can place text precisely and handle environmental typography, signs, packaging, labels, menus, license plates, in a way that looks far less synthetic than the warped lettering image models became infamous for. Graphic design and layout-heavy work are the clearest early winners.
How Reve 2.0 Benchmarks
On the Arena leaderboard for text-to-image, dated June 3, 2026, Reve 2.0 scored 1280, give or take 11 points, from 3,455 votes. That placed it second overall and represented a jump of about 125 points over the previous Reve 1.5.
| Position | Model | Lab | Notes |
|---|---|---|---|
| 1 | GPT-Image-2 | OpenAI | Current leader by a wide margin |
| 2 | Reve 2.0 | Reve | 1280, sub-trillion-dollar lab, far less compute |
| Below | Nano Banana 2 | Also known as Gemini 3.1 Flash Image Preview | |
| Below | MAI-Image-2.5 | Microsoft | |
| Below | GPT-Image-1.5 | OpenAI | High Fidelity variant |
The context matters as much as the rank. Reve describes its result as the best image model from any company valued under a trillion dollars, achieved with roughly ten times fewer GPUs than its larger rivals. Beating Google’s latest image model and an earlier OpenAI image model on a blind human-preference leaderboard, at that compute budget, is the part that turned heads. Arena scores are based on people choosing between two images without knowing which model made them, so a high placement reflects what real users actually prefer rather than a synthetic metric.
It is worth keeping the result in proportion. Reve 2.0 is number two, not number one, and GPT-Image-2 still leads by a clear margin. But the gap between a small lab and the frontier has rarely been this narrow.
The Lab Behind the Model
Reve is a Palo Alto research lab founded in 2023 by a team of ex-Adobe and ex-Stability researchers. Among the founders are Michaël Gharbi, a former research scientist at Adobe Research with a PhD from MIT CSAIL, and Taesung Park, also formerly of Adobe Research with a PhD from UC Berkeley, who is well known in the field for foundational work on image-to-image translation. Christian Cantrell, a former VP of Product at Stability AI, is also part of the founding group, with backing from Sutter Hill’s Mike Speiser.
That pedigree is not a side note. Park’s research lineage is precisely about transforming structured representations into images, which is the exact problem layouts pose. A team that came up through Adobe’s imaging research and Stability’s product world is unusually well suited to bet that the future of image generation looks more like design tooling than like a prompt box.
The lab is well funded for its size. Reve raised roughly 350 million dollars at a valuation near 1.9 billion dollars in November 2025, in a round led by Top Harvest Capital, with earlier backing from investors including Basis Set Ventures. Its first model, Reve Image 1.0, codenamed Halfmoon, shipped in March 2025 and quickly reached number one on the Image Arena, earning a reputation for strong prompt adherence and unusually clean typography. Crucially, Reve 1.0 was already trained on detailed data structures rather than plain captions, which is what first proved the layout thesis. Reve 2.0 scales that idea up with roughly three times the parameters, far more data, and the dedicated 4K renderer.
Pricing and How to Try It
Reve 2.0 is live at reve.com, which doubles as the editor. That is by design. Because the model and the product were built together around the same layout representation, every part of an image is addressable, so Reve could build direct-manipulation editing tools on top of the exact structure the model generates. The model is the code, and reve.com is the editor for that code.
Web subscriptions are tiered by monthly credits.
| Plan | Price | Credits per month |
|---|---|---|
| Starter | $6.90 | 100 |
| Standard | $19.90 | 700 |
| Premium | $39.90 | Larger allotment |
A developer API is available in beta through Reve’s console for teams that want the model inside their own pipelines. Because the underlying representation is code-like, Reve positions the model as agent-native, meaning automated systems can both see the images and reason about their structure, not just receive a flat picture.
Where Layouts Still Fall Short
A fair assessment has to name the trade-offs, and there are a few.
The headline performance claims, fewest GPUs, fastest 4K renderer, best sub-trillion-dollar model, all come from Reve’s own announcement and have not yet been independently audited. They are plausible and the Arena ranking is third-party, but the compute and speed figures should be read as the lab’s claims for now.
Layouts also add a layer of conceptual overhead. For a casual user who just wants a quick picture, typing a prompt is still simpler than thinking in regions and structure. The layout’s power shows up most when you need precision and iteration, which is professional and design work, not necessarily a one-off image for a social post.
And the model sits at number two, not number one. GPT-Image-2 still leads the leaderboard comfortably, which is a reminder that a better representation narrows the gap with scale but has not yet erased it.
The Industry Is Moving the Same Direction
Reve 2.0 did not land in isolation. In the same week, Ideogram shipped Ideogram 4 built around a closely related idea, using bounding boxes and structural control rather than relying on ever-denser prompts. Two of the most respected image labs independently concluded that the road to controllable generation runs through structured, editable representations.
That convergence is the real signal. Reve frames layouts as only the first step toward treating image generation as program synthesis, a world where humans and agents read, write, and reason over a shared, code-like semantic layer. The next step on its roadmap is to scale the language models that do the planning. If the bet holds, the prompt box may eventually look like a transitional interface, the way punch cards once were, and structured visual editing may become the default way serious image work gets done.
What This Means If You Use AI Every Day
For most people, the practical takeaway is that genuine visual control is finally arriving. Place text exactly where it belongs. Fix a single object without regenerating the scene. Iterate at high resolution without watching your details quietly rot. If you do any design, marketing, product mockup, or print work, this is the capability that has been missing.
The launch also underlines how fast the model landscape moves. In a single day, a small lab introduced a new architecture and reshuffled a leaderboard dominated by OpenAI, Google, and Microsoft. The best model for any given task keeps changing, sometimes week to week, and no single provider stays on top for long.
That churn is exactly the problem Fello AI solves on the language side. Rather than juggling separate subscriptions to every frontier model, Fello AI bundles Claude, GPT, Gemini, and the rest into one lightweight native app for Mac, iPhone, and iPad, so you can switch to whichever model is winning this week without managing five logins or five bills. As image and language models keep leapfrogging each other, having one place to reach all of them is the simplest way to stay current without betting your workflow on a single lab.
The Takeaway
Reve 2.0 is a reminder that the frontier is not only about scale. A small team of ex-Adobe and ex-Stability researchers, training on a fraction of the compute, reached number two in the world by changing the representation rather than just adding parameters. Their bet is that images are better understood as code than as prose, and that humans and AI agents should collaborate over a shared, editable structure rather than trading guesses through a prompt box.
Whether layout-based generation becomes the industry standard or simply one strong approach among several, Reve 2.0 has already proved the more important point. In a field that often feels like it belongs to a handful of giants, a better idea can still move the leaderboard in a single day.
