Meta SixthView: A 604-Puzzle Benchmark That Asks Vision Models to Guess the Hidden Face of a Block

Meta's research group has quietly published a new test for a weakness that vision-language models still struggle to hide: reasoning about objects in three dimensions. SixthView, a repository created on October 28, 2026 under the facebookresearch organization, gives a model five faces of a block built from interlocking cube pieces and asks it to predict the sixth, hidden one. The repo has 604 examples and 11,634 images, with exact-match scoring, and it arrived with essentially no fanfare: zero stars when we looked, no paper link and no results table.

That last point matters. This is a data release, not a result. What we can do honestly is explain what the benchmark asks, why the design is interesting, how to run it, and what you should not conclude from it yet.

TL;DR #

What is SixthView? #

The README states it plainly: SixthView "evaluates spatial reasoning by asking models to predict a withheld face of a block assembled from interlocking cube pieces." Each example includes text and image inputs together with the underlying 3D structure and answer.

Think of a Soma-style cube puzzle. A solid n by n by n block is built from several irregular pieces, each made of unit cubes and each labeled with a letter. You are shown what the block looks like from five of its six sides. The sixth view is hidden. To get it right you must work out where each piece sits inside the block, including pieces that are recessed behind others or show up as through-holes, then imagine looking at the block from the missing side.

The expected output is a grid. Every cell holds the letter of the first piece a line of sight meets from the withheld side, or a dot for a cell you can see straight through. A reply is a JSON object with a free-text reason and an answer array of strings, top row first and leftmost character first.

How hard do the puzzles get? #

The data has a difficulty ladder. The inputs.jsonl file tags every example with a level (we counted L1 through L8), a block size n, and a piece count k. Level 1 examples are 3 by 3 by 3 blocks with three pieces. A level 5 example we sampled is 7 by 7 by 7 with five to eight pieces, and level 8 reaches 10 by 10 by 10 with eight to ten pieces. The withheld face rotates across all six directions (plus and minus X, Y and Z), so a model cannot learn one fixed viewpoint.

That is our read of the file's fields; the repo does not publish a difficulty rubric, so treat the level labels as the authors' own and the size-to-level mapping as approximate.

The text prompt is detailed. For each face it lists, per cell, a letter plus a state: S for a ray that hits the piece right at the surface, R for recessed (the ray travels down a channel before hitting), and a dot for a hole straight through. It also lists each piece's voxel coordinates in its own local frame, and says that on some items the shapes are rotated from the pose they occupy in the block. Only proper rotations are used, never mirror images. So the model has to infer both position and orientation.

Four ways to ask the same question #

The most useful design choice is the four "arms," because it separates reasoning from perception.

• Arm 1, text: the faces and pieces are transcribed as character grids and coordinates. No images.
• Arm 2, multiple images: six face images plus two renders per piece. The held-out face is a "PREDICT THIS" placeholder.
• Arm 3, text plus multiple images: both of the above together.
• Arm 4, single image: one merged sheet.

Run all four on one model and the gaps tell you something. If text-only beats images, the weakness is visual parsing; if all four fail, the weakness is the 3D inference itself. The repo says the prompt text is byte-identical to what was sent in the authors' runs and includes a prompt_sha so you can verify you are using the same prompt.

A green thread linking a magnifying lens to one pebble among three, a picture of picking the right piece in the SixthView benchmark

How the scoring works, and the baselines #

Scoring is strict: an exact match on the answer array, so one wrong cell fails the example. The free-text reason is recorded but ignored. Each row in golden.jsonl also carries two reference numbers, a majority baseline (always guess the most common letter) and an opposite baseline (mirror the opposite face). In the first three rows we read, the majority baseline was 0.44, 0.5 and 0.44, while the opposite-face baseline ranged from 0.11 to 0.69. Those are cell-level accuracies, per the README, so they show that cheap heuristics get partial credit on individual cells even though exact match gives them nothing.

That detail is worth keeping in mind when numbers eventually appear. A model reporting "cell accuracy" on this set and one reporting "exact match" are describing very different things.

The answers are not hand-labeled. The README says ray-casting the stored 3D structure from the held-out face reproduces the answer grid exactly, and that this was checked on all 604 rows. A validation script, scripts/check_benchmark.py, checks example IDs, prompt hashes, image references, PNG headers, piece coordinates and answers computed from the 3D structures, and GitHub Actions runs it on every push.

How to run it today #

1. Clone the repository and read benchmark/inputs.jsonl .
2. For each id, pick an arm and send its prompt_text and images, resolved relative tobenchmark/ , to your model.
3. Parse the JSON reply and take the answer array.
4. Join with benchmark/golden.jsonl by id and score exact match.
5. Run python scripts/check_benchmark.py first (Python 3.10 or newer) to confirm your copy is intact.

A sensible first experiment is 20 level-1 and 20 level-5 examples across all four arms with the model you already use. If you are comparing models, report arm, level and exact-match rate separately; a single blended number would hide the interesting part.

What we do not know yet #

• No results. There is no leaderboard, no paper link and no model scores in the repo or docs.
• No stated purpose. The authors do not say whether this supports a specific Meta model or a research paper. We will not guess.
• Contamination. The inputs and answers are public in a GitHub repository, so any future model trained on web crawls could see them. The non-commercial license does not stop a crawler.
• Difficulty calibration. The level labels are the authors' own and are not explained in the README.
• License limits adoption. CC BY-NC 4.0 means companies cannot use the data in commercial evaluation pipelines as-is.

Why it matters for people building with AI #

Spatial reasoning is a practical bottleneck for robots, CAD assistants, 3D-printing helpers and AR tools, all of which need to infer unseen geometry from partial views. Benchmarks like this are a way to find out whether a model's apparent visual fluency survives a task with a single verifiable answer and no room for plausible-sounding vagueness.

It also fits a pattern we have been tracking: evaluations that use a programmatically generated ground truth so there is no annotator disagreement, such as the Property Finder study of biased eval labels showed is a real problem with human labels. In embodied settings, NVIDIA's long-context world action model and Naver's language-action world model both depend on the kind of 3D understanding SixthView isolates. And for 3D from images at the production end, see Apple's real-time Gaussian head reconstruction. For a sense of how compositional failures show up in other systems, read the IBM RAG compositionality study, and for how benchmark claims can go wrong in coding-agent land, DoubleAI's code-execution model claim.

explainx.ai's read #

SixthView is small by benchmark standards, but it is carefully built: public prompts with hashes, verified answers, graded difficulty, and a four-arm design that separates seeing from thinking. Its weakness is also its strength for now. With no published scores, nobody can say a given model "passes" it. If you test a model on it, publish the arm, level and scoring method, link the commit you used, and note the license, so that your numbers are comparable with the next person's.

We will update this post if Meta publishes a paper, results or a leaderboard, or if the license terms change.

Related reading #

Repository details are as of October 29, 2026 and may change as Meta updates the project.