The big update this month: business logic is written once, gets a signature and types, and is called from anywhere. Also — DAX Query View, report updates, and the list of known bugs with workarounds.
The monthly updates module: what's new in Power BI, why Microsoft built it, and how to actually use it.
June 2026Executive Summary — What's New This Month
Five minutes of reading that give you the full picture, before diving deeper. Version 2.155.756.0.
User-defined functions in DAX, now generally available. Business logic is written once as a function with a signature, types and optional parameters, and is called from a measure, a calculated column and a visual calculation. Requires compatibility level 1702.
A new type system with two passing modes. The distinction between val toexpr determines which contexts the function inherits — and this is the most important technical point in the update.
Governance warning: Object-level security doesn't propagate to functions. A function that references a protected measure isn't automatically protected.
Sorting and filtering in the results grid of DAX Query View. The grid isn't editable, and filtering only works on results that have already been returned — which may be truncated.
Report updates that eliminate manual maintenance: A date picker for a slicer that rolls forward with each refresh, a tooltip in sentence mode without a DAX measure, and conditional column width.
A change that affects existing reports: The selection tools in Azure Maps are now enabled by default.
11 known bugs and limitations documented in Chapter V, with a workaround for each.
Estimated reading time · 75 minutes
01
Navigating between topics
the buttons Previous Fnext fixed at the top of the screen. Also available via keyboard shortcut, by swiping on a phone, or by jumping to a topic from the topics list.
02
Questions and practice
At the end of the lesson, a short quiz with immediate feedback for each question, and application exercises with full solutions.
03
Progress is saved
The topic where you stopped and the topics you have read are saved only in your browser. You can close and come back, and reset from the topics list.
How each topic is built
Every topic opens with an explanation why The feature exists — the pain point in the field and the vision behind it — and moves on to the technical detail with code and examples. At the end of the lesson: a whole section of known bugs with workarounds, a short quiz, and a summary.
What the lesson covers
June 2026 update, version 2.155.756.0.
DAX
User-defined functions
The big feature of the month: DAX gets functions with a signature, types, and optional parameters.
tools
DAX Query View
Sorting and filtering the results grid — and one trap you must know.
reports
Report experience updates
A date picker for the slicer, tooltip in sentence mode, conditional column width, and mobile adaptation.
production
Bugs and workarounds
What's currently broken, why, and what to do until it's fixed.
Threshold requirement for the lesson: An introduction to measures, filter context, and row context. If CALCULATE still isn't fully clear — it's worth going back to lesson 4 before continuing.
Chapter I · Why DAX got to this point
The pain that gave birth to the feature
Before the syntax — the problem. Without it, it's hard to understand why this is the big announcement of the month.
In a mature enterprise model there are hundreds of measures, and within them the same business logic repeats over and over: the definition of an active customer, the conversion rate, the revenue recognition rule, the commission formula. When the rule changes — and business rules do change — someone has to find every place it's coded into. In practice they find eighty percent of them. The remaining twenty percent turn into reports that contradict each other, and that's exactly the moment management stops trusting the BI.
01
What was missing
DAX had one unit of reuse: the measure. But a measure isn't a function — you can't pass it parameters.
02
The improvised solution
Calculation groups, which pass parameters through the filter context. It works, but it's indirect, hard to debug, and expensive when the same logic is called multiple times in a query.
03
the vision
The semantic model as a software product: a function is a first-class object, saved as text, goes into Git, and goes through a code review.
This is the same movement that also leads to PBIR, TMDL and Desktop Bridge: Everything turns into code. DAX functions are the part that directly concerns the analyst.
Chapter I · Why DAX got to this point
What changed in general availability
The feature moved out of preview — and with it came threshold requirements you need to know.
what
details
status
General availability in Power BI Desktop and the service starting with the June 2026 release
Compatibility level
1702 and above. A model that wasn't upgraded simply won't keep the function
Where do you write
DAX Query View, TMDL View, and the formula bar of Model Explorer
Where does it live
junction Functions In Model Explorer, and in a PBIP project in the file functions.tmdl
How many parameters
From zero to 256
✓The first check when something doesn't work: The function refuses to save? It is almost always a compatibility level below 1702. In TMDL View an automatic upgrade prompt is shown.
Chapter II · UDF Basics
The first function
Three rows, and you already understand the whole structure.
DAX
DEFINE /// Adds VAT to the received amount FUNCTIONAddVat = ( amount : NUMERIC ) => amount * 1.18
EVALUATE { AddVat ( 100 ) } // returns 118
The keyword FUNCTION · name · parameter list · arrow · function body
Written in DAX Query ViewUnder DEFINE, exactly like defining a measure in a query.
Run and checkAn EVALUATE block with a function call returns the result immediately.
Saving to the modelbutton Update model with changes Keeps all the functions in the query, or the row Update model: Add new function Above a single definition.
Note the three slashes: Only a comment that starts with/// Enters the IntelliSense of whoever calls the function. A comment with // or /* */ won't appear there.
Chapter II · UDF Basics
Documentation and naming conventions
A function no one understands how to call is a function no one will use.
DAX
DEFINE /// Safely computes a profitability percentage, guarding against division by zero /// @param {NUMERIC} revenue - the revenue amount /// @param {NUMERIC} [cost] - cost, default 0 /// @returns profitability percentage as a decimal number FUNCTIONFin.MarginPct = ( revenue : NUMERIC, cost : NUMERIC = 0 ) => DIVIDE ( revenue - cost, revenue )
EVALUATE { Fin.MarginPct ( 1000, 400 ) } // 0.6
rule
What's allowed and what's not
uniqueness
A unique name in the model, that doesn't clash with a built-in function or a reserved word like measure or function
points
are allowed for namespaces like Fin.MarginPct — but not at the start, not at the end, and not consecutively
characters
Besides periods: alphanumeric characters and underscore only. No spaces
Parameter names
Points are completely forbidden, and you may not use a reserved word
✓A convention that pays off: Namespace by prefix — Fin., Dim., Stat.. In IntelliSense, the whole function family appears together.
Chapter II · UDF Basics
Where the function is called
After saving to the model, the function behaves like any built-in DAX function.
DAX
-- measure Total Sales with VAT = AddVat ( [Total Sales] )
-- a computed column (note the type conversion) Sales Amount with VAT = CONVERT ( AddVat ( Sales[Sales Amount] ), CURRENCY )
Two usage warnings: In a calculated column, make sure the function returns a scalar of a consistent type, and convert with CONVERT when needed. In a visual calculation you can't pass in objects from the model that aren't in the visual.
✓ Recursion — a function that calls itself directly or indirectly — is not supported. Composing different functions does.
Chapter III · The Type System
Why DAX needs types
The conceptual shift of the update: moving the failure from the report to write time.
In classic DAX, a measure that receives unexpected input silently returns a wrong result. In a one-person model that's tolerable. In a function library a whole team consumes, unexpected input is a bug that shows up in a management report.
01
Reliable IntelliSense
Whoever calls the function sees what it expects to receive, before running it.
02
Preventing a type error
You can't pass a column instead of a measure when the signature requires a measure.
03
Controlled conversion
Sub-typing forces a predictable conversion, instead of an incidental conversion by the engine.
You can specify everything, some, or nothing. A parameter written with no hint at all behaves asAnyVal val — meaning the argument is evaluated immediately at call time.
Chapter III · The Type System
The types and the two families
The distinction that determines all the behavior: value vs. expression.
family
type
what receives
When it's evaluated
Value types
AnyVal
A scalar or a table. The default
Immediately, before entering the function
Value types
Scalar
A scalar value, with an optional subtype
immediately
Value types
Table
table
immediately
Expression types
AnyRef
Any reference or expression
Inside the function body
Expression types
ColumnRef
Reference to a column
Inside the function body
Expression types
MeasureRef
Reference to the measure
Inside the function body
Expression types
TableRef
Reference to the table
Inside the function body
Expression types
CalendarRef
Reference to a calendar
Inside the function body
✓Two rules derived from the table: Value types support automatic type conversion, expression types don't. And expression types must be expr — score val for which it isn't valid.
The table was already filtered before entering the function, so the ALL inside no longer changes anything
CountRowsLater
all the years
The function received an uncomputed expression and evaluated it itself under ALL, meaning it removed the external filtering
The rule worth memorizing: parameter val is evaluated at the caller and therefore inherits the row context and filter context. parameter expr It's evaluated inside the function and therefore only inherits the filter context.
✓Pro tip: when a parameter expr may take a measure or a formula, force context transition inside the function with CALCULATE Explicit. This way the function also works correctly in uses you didn't anticipate.
Chapter IV · Parameters and Tests
Optional parameters
A default in the signature makes the parameter optional — with four rules you need to know.
DAX
DEFINE FUNCTIONAddNum = ( x : NUMERIC = 1, y : NUMERIC = 2 ) => x + y
An empty comma skips an argument and uses the default
the rule
What does this mean
location
An optional parameter can appear anywhere. But the minimum number of arguments is determined by the parameter The rightmost required — in a function with three parameters where only the second is optional, you still must pass three
the context
Inheritance of row context and filter context is determined by the passing mode of that parameter
Field of vision
The default expression only sees names visible in the location the setting, not at the call site. It also can't refer to another optional parameter
Type check
The type hint is enforced on the default only when it's actually used. If the caller supplied an argument, the check runs against that instead
Chapter IV · Parameters and Tests
Runtime type checking
When the function needs to accept more than one input type — check inside the function body.
Timing of the check: in the parameter expr The check happens when the parameter is referenced in the function body — no at call time. This changes when you'll see the error.
Chapter IV · Parameters and Tests
TABLEOF and NAMEOF
Two new helper functions that let you write truly generic functions.
function
What it returns
TABLEOF
the table that a column, measure, or calendar belongs to
NAMEOF
the name of a table, column, measure or calendar — as text
DAX
DEFINE /// Returns the most common value of an expression over the table it belongs to FUNCTIONStat.ModeX = ( e : ANYREF ) => VAR newTable = ADDCOLUMNS ( TABLEOF ( e ), "expr", e ) VAR freqTable = GROUPBY ( newTable, [expr], "count", SUMX ( CURRENTGROUP (), 1 ) ) VAR maxCount = MAXX ( freqTable, [count] ) RETURN SELECTCOLUMNS ( FILTER ( freqTable, [count] = maxCount ), "expr", [expr] )
EVALUATEStat.ModeX ( [Total Sales] )
The function doesn't hard-code a table name — TABLEOF finds it from the expression received
✓ This is what turns a function fromModel-dependent Hmobile: you can copy it to another model without changing a thing.
Chapter V · Production and governance
Governance limitations and risks
What you must check before a function enters an enterprise model.
The most severe risk — object-level security: OLS does not pass and to functions and vice versa. If a function refers to a protected measure, the function itself isn't automatically protected; when it runs under an identity without permission, the system behaves as if the measure doesn't exist. The official recommendation: don't expose names of protected objects in function names and descriptions.
limitation
The practical implication
Unqualified names
A name without an explicit table prefix is treated as a measure reference, so it isn't included in dependency tracking. Always 'Sales'[Amount] and never [Amount]
No recursion
Neither directly nor mutually
No overload
Two functions can't share a name with different signatures
There is no explicit return type
Need to ensure consistency within the function body itself
No view folders
and you also can't hide or expose a function
No combination with translations
Translated model — the functions stay out
No enum return
A built-in function expecting an enum won't accept a UDF
DAX
-- to check which functions exist in the model EVALUATEINFO.USERDEFINEDFUNCTIONS () // Full metadata, requires write permission
Two capabilities that look similar and solve completely different problems.
when
the tool
why
Business logic with variable parameters
UDF
Passing parameters through an explicit signature saves the overhead of passing them through the filter context, especially when the same logic is called several times in one query
Display variations across all the measures
Calculation group
Prior year, year-to-date cumulative, percent of total — something that needs to apply to a hundred measures without rewriting them
combination
both
A calculation group that internally calls a shared function — this is the pattern recommended for large models
✓The decision test in one question: Does the logic need to take variable input? If so — UDF. If it only changes the context of an existing measure — a calculation group.
Chapter V · Production and governance
Known Bugs and Workarounds
What is currently broken, per the bug entries in the official docs and community reports — and what to do until it is fixed.
the phenomenon
the reason
The workaround
Red underlines and validation errors when passing a column as a parameter expr
A known inconsistency of the parser in advanced scenarios
run it and check the actual result; write full qualified references; split into a simpler helper function
Type hint ColumnRef or MeasureRef Deferred at the call site
Known bug: the specific reference types aren't accepted at every call site
to drop toAnyRef and perform validation in the function body
A custom error message with ERROR not displayed
DAX generates an internal error from incorrect parameter use before the validation code runs
Don't rely on custom messages at this stage; document the requirement in///
Renaming a column breaks a function
An unqualified name is treated explicitly as a reference to a measure and is therefore not included in dependency tracking
Always use the full table name inside a function
The function refuses to save
a compatibility level below 1702, or a model with no tables
to upgrade the compatibility level; in TMDL View an automatic prompt is shown
There's no IntelliSense in visual calculations, in TMDL, or in SSMS
Partial support at this stage
Write and test it in DAX Query View and then copy
A measure in a report with live connect can't see a function from the source model
A report-level measure can reference it but without IntelliSense; a model-level measure in a complex model cannot at all
Define the logic in the source model as a measure too, not only as a function
A calculated column returns an inconsistent type
A function that returns different types depending on the branch chosen
to wrap inCONVERT or split into two functions with a uniform type
Saved DAX queries didn't go into Git
Setting up an initial Git integration from the workspace doesn't include them
To save critical queries as text files in the repository at the same time
Maps started behaving differently in an old report
The selection tools in Azure Maps are now on by default, even in existing reports
To turn off the switch Selection In the Controls section
Date picker doesn't appear for a teammate
A preview feature that's enabled per device individually
to make sure everyone has enabled the preview, and not to rely on it in a production report
Contradiction in the docs: The Best Practices page in Learn still carries a preview label and lists a limitation of not being able to create functions in the service, while the official blog from June announces full in-browser editing. It's worth checking the behavior in your own environment.
Chapter VI · DAX Query View
Sorting and filtering in the results grid
A small interface improvement that saves run cycles — with one big trap.
Why Microsoft introduced this
Debugging DAX is a loop: run, look, change, run again. Until now, every small question about the result — what's the highest value, are there negative rows — required rewriting the query and running it again. Each round costs time as well as capacity resources.
What was actually added
Every column header shows a sort icon to toggle between ascending and descending order on click. The three-dot menu adds clearing the sort, searching values, and filtering by value selection.
Precision matters: the network Cannot be edited. Only sorting, search and filtering were added — there's no editing values and no writing back to the data. This is a common misinterpretation found in several online summaries.
the limitation
the value
What does this mean in practice
Volume per query
15MB
On an exception the current row ends and no further rows are written
Values for the query
1,000,000
With 20 columns you get at most 50,000 rows
Rows in the browser
99,999
and write permission on the semantic model is required
Display format
not shown
Currency and thousands separators won't appear in the grid
The main trap: Sorting and filtering work Only on the results already returned, and these may be truncated. If the result was truncated, what you see doesn't reflect the full result set.
DAX
-- correct validation: filter in the query, not in the grid EVALUATE FILTER ( SUMMARIZECOLUMNS ( 'Product'[Category], 'Date'[Month of Year], "Sales", [Total Sales] ), [Sales] > 100000 ) ORDER BY [Sales] DESC
✓A rule for students: The grid is a debugging tool, not a validation tool. A student who filters in the grid and reports "I checked, no anomalies" can still be wrong on a large model.
Chapter VII · The report and mobile
Report experience updates
The common thread: eliminating repetitive manual work.
Why Microsoft introduced this
Almost every change here erases maintenance: a date slicer that needs updating every month, a text measure written only so a tooltip is readable, manually tuning axis ranges so a bar isn't cut off. At the same time, turning on the map selection tool by default teaches a second principle: a feature that exists but is hidden behind a switch that's off is a feature that doesn't exist.
01
Date picker for the slicer
A relative selection that rolls forward with every refresh. Anchored to today, to the first date, or to the last date in the data — and that's what prevents a report from breaking when the ETL is delayed. In preview.
02
Auto-expansion in the matrix
Defined separately for rows and columns. The big value is in Personalize this visual: a field the reader adds opens up immediately.
03
Tooltip in sentence mode
A free-form sentence that refers to the tooltip fields — without a dedicated DAX measure. Saves unnecessary text measures in the model.
04
Conditional column width
Turn on Custom widths and click fx. The interesting pattern: tying the width to a What-If parameter with a slider.
05
Azure Maps
The selection tools are lit by default — circle, rectangle, polygon, travel time and distance. Close a polygon with the C key.
06
Shape map
in general availability, with uploading TopoJSON and GeoJSON, and re-downloading a map you uploaded.
A change that affects existing reports: Enabling the selection in Azure Maps doesn't apply only to new reports. Anyone who wants the previous behavior needs to turn off the switch manually.
Chapter VII · The report and mobile
Adapting the report for mobile
The mobile layout isn't a shrunken desktop — it's a different report.
How it works: A mobile-optimized view is displayed only in the iOS and Android apps, and only when the device is in portrait mode. In the browser the report is always shown in the regular layout. Built inView > Mobile layout in Desktop, or via editing the report in the service.
Building both layouts togetherDuplicating a page duplicates both layouts, so a page with a header and navigation serves as a template for the rest of the pages.
Select only what mattersRecommended minimum size: 323 points wide for a large visual, 158 for a small one. Font no smaller than nine points.
Clean up noiseRemove axis titles, gridlines and legend; arrange navigation and slicers horizontally; reduce white space.
Testing an interactionTooltips are disabled on the editing canvas but work in the app. Slicer selections on the canvas don't carry over to the grid layout.
The new update
What it gives on a small screen
Date picker
A relative selection saves typing, and is preferable to two separate slicers for a range
Conditional column width
The same table in two different widths for desktop and mobile, without duplicating the visual
Tooltip in sentence mode
One readable sentence instead of a field list that gets cut off on a narrow screen
✓ Automatic responsiveness may clash with manual formatting. You can turn it off inGeneral > Properties > Advanced options.
Chapter VIII · Self-check
Quiz — 12 questions
One question at a time. A correct answer is colored green, an incorrect one red, and the correct answer is always revealed along with a full technical explanation.
What's the passing mode of a parameter written without any type hint?
explanation: The default is AnyVal val. This means the argument is fully evaluated before at the entry to the function body, and the value already computed is what goes in. This is why a simple function works as expected without specifying anything — but it's also why trying to change the context inside the function has no effect, since there's no longer an expression whose context can be changed. The answer 'it depends on the argument' is wrong because the passing mode is determined by the function's signature, not by the call to it.
In expr mode, which context does a parameter inherit?
explanation: parameter expr passed as an uncomputed expression and evaluated inside the function body, so it sees the filter context that prevails there but not the row context of the caller. A parameter val, by contrast, is evaluated at the caller, so it inherits both of them. This is exactly why the same function body returns different results in the two functions CountRowsNow and CountRowsLater: in one the table has already been filtered, and in the other the ALL inside can still remove the filter.
What happens when a function refers to a measure protected by object-level security?
explanation: OLS does not pass to functions and vice versa — this is a documented limitation, not a bug. When a function runs under an identity that lacks permission on a measure, the engine behaves as if the measure doesn't exist at all, which can silently return a wrong result instead of blocking it. The official recommendation follows from this: don't expose the names of protected objects in function names or their descriptions, and every function must be tested under every role before publishing.
Why should you not rely on filtering in the DAX Query View results grid to validate data?
explanation: Sorting and filtering are an interface operation on what the engine has already returned, not a new query. If the result was truncated — by the 15MB limit, the million-value-per-query limit, or the 99,999-row browser limit — you are filtering part of the data and drawing conclusions about the whole. For real validation, move the logic into the query itself with FILTER and ORDER BY and rerun.
The MeasureRef type hint is rejected at the call site. What's the solution?
explanation: This is a known, documented bug: the specific reference types — CalendarRef, ColumnRef, MeasureRef and TableRef — are not accepted at every call site, and the official workaround is to fall back to AnyRef, the general type of the family. The option to pass it as a value is wrong because a reference must be an expr; bumping the compatibility level is not relevant here, because if it were too low the function would not save at all.
What's the minimum compatibility level required for user-defined functions?
explanation: 1702 and above. The compatibility level determines which objects and properties the model can even hold, so an older model that hasn’t been upgraded will simply refuse to save the function — and that’s the first thing to check when something isn’t working. The TMDL View shows an auto-upgrade prompt that specifies exactly which object requires the upgrade.
In a function with three parameters where only the second is optional — how many arguments must the caller supply?
explanation: The minimum number of arguments — the function's arity — is determined by the parameter's position The rightmost required, not by how many optional parameters there are. Since the third parameter is required, three arguments must be passed. You can skip the second one with an empty comma in the style MyFunc(1,,3), and its default value will kick in.
What's special about a comment that starts with three slashes?
explanation: the syntax /// Saved into the model as a description property of the object, exactly as TMDL supports for measures and functions too. A regular comment with // or /* */ stays only in the query code and doesn't reach whoever calls the function. Inside the block you can also use JSDoc-style tags like @param and @returns to describe each parameter separately.
What will happen if you use an unqualified reference in the style [Amount] inside a function when you mean a column?
explanation: An explicit unqualified name is always read as a reference to a measure. This is a known limitation in formula fixing and dependency tracking: if you meant a column, the name won’t be included in the dependency graph, so a future rename won’t fix the function and it will break silently. The practical rule: inside a UDF always write 'Sales'[Amount] with the table name.
Where is the mobile layout you built for the report displayed?
explanation: The mobile layout is a separate artifact saved alongside the web layout, and it's loaded only by the Power BI apps for iOS and Android when the device is held in portrait. In a browser — even on a phone — the regular layout is always shown, so you can't test the mobile layout through a browser. Tilting the device to landscape brings back the regular view in the app too.
When do you choose a UDF instead of a calculation group?
explanation: Explicit parameters in the signature are the clear advantage of a UDF: the input passes through directly, without going through the filter context. When the same logic is called several times in the same query, this difference also adds up in performance. A calculation group, on the other hand, is built for exactly answers A and C: applying a uniform display variation to existing measures without rewriting them.
A function defined with ( t : TABLE ) and called inside CALCULATE with a year filter — what will it return?
explanation: Without an explicit transition state, the default is val. The table is evaluated by the caller — meaning it’s already filtered to the year — and only then enters the function, so the ALL inside can no longer remove a filter from an already-evaluated table. The fix is an explicit declaration: ( t : TABLE EXPR ). This is the most common mistake when writing a first UDF.
You haven't answered questions yet — 0 out of 12
Chapter VIII · Self-check
Summary and next steps
Ten rows that sum up the entire lesson.
topic
what to remember
the rationale
Business logic becomes a code-managed library, not copy-paste between measures
definition
FUNCTION Name = ( p : TYPE SUBTYPE MODE = default ) => body with documentation in-///
val vs expr
val at the caller inherits row and filter; expr inside inherits filter only
Reference types
ColumnRef, MeasureRef, TableRef, CalendarRef — always expr, without type conversion
Optional
The minimum argument count is determined by the rightmost required parameter
Main risk
OLS doesn't carry over to functions
golden rule
Always fully qualified names inside a function
DAX Query View
Sorting and filtering only, and only on results already returned
mobile
Build the mobile layout together with the desktop one, not after it
source of truth
functions.tmdl In a PBIP project, in a workspace connected to Git
From here to July 2026
After the logic became code, the next step is the model itself: TMDL in the browser, Model Options in the service, and the risks of overwriting against Desktop.