What is PBIR? The New Power BI Report Format Explained

February 22, 2026

TL;DR: PBIR is the new folder-based Power BI report format that replaces PBIX. It became the default in Power BI Service in January 2026 and in Desktop in March 2026 (anticipated). Instead of a single binary file, PBIR stores your report as a collection of human-readable JSON files — enabling version control, granular diffs, and CI/CD workflows that were impossible with PBIX.

Microsoft's official PBIR overview covers the format specification in full. This article explains what the change means for report development practice.

What PBIR Stands For

PBIR stands for Power BI Enhanced Report Format. Microsoft introduced it as part of the push to make Power BI reports first-class citizens in source control systems like Git.

The name "enhanced" undersells the change. This isn't a minor update to how reports are saved — it's a fundamental shift from a proprietary binary format (PBIX) to an open, structured folder format that any developer tool can read and modify.

When PBIR Became the Default

PBIR reached two key milestones:

January 2026: Power BI Service (Fabric workspaces) started using PBIR as the default format for reports saved in workspaces with Git integration enabled.
March 2026: The March Power BI Desktop update made PBIR the default for all new reports. The format also received seven schema version bumps and a new 16:9 HD page size option.

If you're on an older Desktop version, your existing PBIX files still open and work. But new reports created in March 2026+ Desktop will be PBIR by default. You can also explicitly convert an existing PBIX to PBIR from the File menu.

PBIR vs PBIX: What Actually Changed

The most important change is structural. A PBIX is a single ZIP archive — open it in a hex editor and you'll find compressed binary blobs for each page, visual, and theme. Diff that against another version of the same file and you get noise.

PBIR is a folder. Download a PBIR from a Fabric workspace and you get a directory structure you can open in VS Code:

MyReport.Report/
  definition.pbir
  report.json
  pages/
    ReportSection_abc123/
      page.json
      visuals/
        visualContainer_def456/
          visualContainer.json

Each visual is its own JSON file. Change a bar chart's title? Only visualContainer.json for that visual changes. The diff is readable. Code review is possible. Merge conflicts are resolvable.

The PBIR Folder Structure

Understanding the folder layout helps you work with PBIR programmatically:

definition.pbir

The root descriptor file. It identifies the format version and points to the semantic model connection. For reports connected to a Fabric-hosted model, the connection is a byPath reference to the .SemanticModel folder. The PBIR report structure reference documents every field in this file.

report.json

Top-level report configuration: canvas dimensions (default 1280x720), custom visuals list, active section, and resource packages (theme files). This is where the canvas size lives.

pages/

Each page is a subfolder named with a section ID. Inside each page folder:

page.json — Page name, display option (1=Normal, 2=FitToWidth, etc.), ordinal (display order), and the list of visual container IDs.
visuals/ — One subfolder per visual on that page.

visuals/visualContainer.json

The per-visual JSON. This contains everything about a single visual: type (pivotTable, barChart, cardVisual, etc.), position (x, y, z), dimensions (width, height), configuration, data bindings, and conditional formatting rules.

This is the most granular level of PBIR. When you move a visual 20px to the left, only this file changes.

Why Microsoft Made This Change

Three reasons drove the switch to PBIR:

1. Git integration. Microsoft Fabric's Git integration for workspaces was hamstrung by PBIX. You could check a PBIX in, but branch comparisons were meaningless because the binary diff showed nothing useful. PBIR makes branching, merging, and pull requests work the same way code does. Fabric Git integration docs cover workspace setup and supported item types.

2. Granular diffs. With PBIX, "I moved a chart" and "I rewired five measures" produced identical-looking binary diffs. PBIR makes the scope of change visible — a layout tweak touches one visualContainer.json, while a semantic model change touches different files entirely.

3. CI/CD pipelines. Teams can now build deployment pipelines that validate PBIR files, run automated tests against the JSON structure, and promote reports through environments (dev → UAT → prod) using the same tooling they use for code.

What This Means for Report Design

PBIR makes the design phase more consequential. Before PBIX, layout decisions made late in a project were cheap to change because the format was opaque anyway — who was going to diff a binary file? With PBIR, the structure of your report is explicit and versioned from the start.

This is why planning your layout before building in Desktop has become more valuable. When your report structure is visible in Git, a poorly planned layout creates noisy history. A well-planned layout, built systematically, creates clean, reviewable commits.

How Draft BI Fits Into the PBIR Workflow

Draft BI is a wireframing tool built specifically for Power BI layouts. You drag real Power BI visual types (bar charts, matrices, slicers, card visuals) onto a 1280x720 canvas, position them, then export the layout directly as PBIR.

The exported PBIR uses the same JSON structure described above — valid visualContainer.json files with correct positions, correct visual type identifiers, and a proper report.json with the canvas dimensions. Open the exported PBIR in Power BI Desktop and your layout is already in place. Connect your measures, format your visuals, done.

For teams adopting PBIR for Git integration, this means your first commit can be a meaningful layout baseline rather than a default empty report.

Learn about wireframing your reports before you build them — it's the workflow that PBIR was designed to support.

Getting Started with PBIR

If you're on Desktop March 2026+, new reports default to PBIR. For existing PBIX files: File > Export > Export to PBIR format. The conversion is non-destructive — your PBIX file stays intact, and you get a new PBIR folder alongside it. Microsoft's PBIX to PBIR conversion guide covers what changes during conversion and what edge cases to watch for.

For Fabric workspaces with Git integration enabled, connecting your workspace to a Git repo and saving a report automatically stores it in PBIR format in the connected branch.

The tooling is maturing quickly. VS Code extensions for PBIR editing, linting pipelines, and automated testing frameworks are all being built by the Power BI community now that the format is open and readable.