TMDL View - Bringing code-level control to Power BI Desktop

Power BI's visual interface has always been one of its greatest strengths. It enables rapid development and makes data modelling accessible to a broad range of users. But as models grow in complexity, that same interface can become a limitation - navigating nested menus, updating properties one at a time, and losing sight of the overall model structure.

TMDL View addresses this by exposing your entire semantic model as structured, editable code directly within Power BI Desktop. It's not just a convenience feature, it's a fundamental improvement to how we build and maintain Power BI models.

Understanding TMDL View

TMDL View brings the Tabular Model Definition Language directly into Power BI Desktop, allowing you to view and edit your semantic model as structured text. This means complete visibility into your model's structure - tables, columns, measures, relationships, and metadata - all in one place, without switching to external tools.

It works in both PBIX and PBIP files. With PBIX, the model and report are stored in a single binary file. With PBIP, the model and reports are stored in a folder structure with readable files. The experience in Power BI Desktop is the same, but PBIP is required for Git.

The image shows the Date table fully exposed in TMDL View, with all columns, hierarchy levels, and metadata visible as editable text. It also demonstrates the diff viewer, making it easy to review and confirm changes before committing them.

Deeper visibility, faster editing

TMDL View gives developers the speed and clarity the traditional UI can’t match. Instead of drilling through panes and dialogs, you see the entire semantic model -tables, columns, measures, relationships, and metadata - in one text-based view inside Power BI Desktop.

This makes it easier to spot inconsistencies, understand calculation logic, find references with full-model search, and identify unused objects. It dramatically shortens onboarding and troubleshooting, especially for inherited models.

Beyond visibility, TMDL View streamlines editing. Bulk updates, multi-cursor edits, and search-and-replace make large changes fast and accurate. You can safely experiment using the built-in diff viewer, configure advanced metadata like perspectives and translations, reorganize display folders, and review relationships without navigating multiple menus.

In short, tasks that once took hours of UI clicking now take minutes, right inside Power BI Desktop.

Enhanced collaboration for version-controlled environments

For organizations using PBIP and Git, TMDL View addresses a key workflow challenge. PBIP stores semantic models as TMDL files that Git can track, enabling proper version control and parallel development. However, working with these files has traditionally required switching between Power BI Desktop and external code editors, a workflow that suited some developers but created friction for others.

TMDL View resolves this by bringing the contents of your TMDL files into Power BI Desktop. While changes made in Desktop and external editors do not synchronize in real time, both ultimately edit the same TMDL files inside the PBIP folder. This ensures the project maintains a single source of truth and supports flexible workflows while preserving consistency:

• Developers comfortable with code editors can continue editing TMDL files in VS Code or other tools

• Developers who prefer the Power BI interface can make equivalent changes directly in TMDL View

• Both approaches modify the same TMDL files, ensuring model consistency

• Git captures identical diffs regardless of where changes originated

  
  

This flexibility allows teams to work according to their preferences while maintaining a single source of truth. UI-focused developers can now contribute to version-controlled projects without leaving Desktop, while technical developers can continue using their preferred tools.

Practical example: Updating business logic across models

Consider a scenario where your organization updates the definition of "Active Customer" and this logic needs to be applied across multiple measures in several reports.

Before the availability of TMDL view, this was a tedious process: opening each report, navigating through tables and folders, locating every measure that uses the old logic, and updating them one by one. With limited visibility into dependencies, it’s easy to overlook a reference or introduce inconsistencies, especially in larger models.

TMDL View changes this entirely. By exposing the full semantic model as searchable, editable text, developers can quickly locate every occurrence of the “Active Customer” expression, update all related definitions in a single pass, and immediately see the impact of those changes.

Teams using PBIP and Git gain even more value: these updates become clear, readable diffs that simplify code reviews and ensure a consistent version-controlled history. Whether changes are made in Power BI Desktop or an external editor, the TMDL files stay aligned, making updates to shared business logic faster, safer, and far more transparent.

Scope and limitations

TMDL View focuses exclusively on the semantic model layer. It doesn't affect how you design report pages, configure visuals, apply themes, or create dashboard layouts. Those capabilities remain in Power BI Desktop's standard interface.

The value of TMDL View lies specifically in improving how you understand, build, and maintain the data model that powers your reports.

The evolution: Reusable components

When working with PBIP you naturally gain a structured, folder-based view of your model. This makes it easy to take the next step and build reusable components your organization can standardize on - whether stored in Git or other centralized systems.

These components can be used individually as needed, such as copying a standard date table definition or approved calculation group into your model, or bundled together into template PBIP projects for new initiatives.

A template is simply a complete PBIP folder preloaded with the most commonly needed foundational elements: standard date tables, organizational hierarchies, calculation groups, documentation and naming conventions.

New projects can start by copying a template for a comprehensive foundation, or selectively incorporate individual components based on specific requirements, ensuring consistency where it matters while maintaining flexibility where it doesn't.

With TMDL View, these components become visible and editable directly inside Power BI Desktop, allowing any developer to review and tailor the shared logic to their specific project without leaving Desktop.

The result: shared components become easier to build centrally, easier to adopt in new projects, and easier to adapt when needed - whether teams work in Git or not.

Example of a predefined calculation group for time intelligence with annotations that give extra context for developers.

A new foundation for scalable Power BI development

TMDL View isn't just a convenience feature. It transforms how organizations approach Power BI development. By bringing the entire semantic layer into one clear, editable place, it removes long-standing barriers between UI-first and code-first workflows. Teams can adopt version control when they're ready, without forcing developers into tools they don’t prefer.

By exposing the model as text, Power BI finally gains true transparency. Shared components become easier to standardize and maintain across projects, changes are easier to understand and review, and collaboration flows more smoothly between business-focused creators and technical developers.

TMDL View gives teams the precision they need without adding complexity, and the consistency they want without disrupting existing ways of working.

For organizations, the impact is simple: cleaner models, clearer ownership, and a development process that scales as the team grows.