Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
165116 stories
·
33 followers

Introducing spatial CSS: A developer preview

1 Share

Safari on visionOS 27.3 comes with an important update: a limited feature preview of the proposed spatial CSS API, with an initial focus on working with 3D objects through the <model> element. While it’s a big conceptual jump, spatial CSS itself is made of a lot of small tweaks to existing syntax. Read on for more details, but here’s a list of each of the features covered in the update:

  • Collecting multiple elements inside a spatial: portal
  • transform to move multiple models independently
  • position-anchor to snap models together
  • @environment-map syntax to reuse and manage different lighting,
  • Enabling orbit over the portal scene with portal-action:orbit,
  • Using requestVolumetricScene() to launch a connected volumetric scene.

To enable the features for yourself on Vision Pro, or to check it out in the visionOS Simulator, go to
Settings > Apps > Safari > Advanced > Feature flags > CSS Portals.
You can experience the spatial CSS demo page here. You can also learn more about installing additional simulators from Xcode here.

The big picture

The 3D <model> element, now available in Safari 27 on all platforms, allows you to present intrinsically 3d objects on their own, in their own space. However, the web is at its best when it allows the composition and configuration of content based on author intentions and user context. These context cues can include the device display capabilities, window size, and color theme. These requirements will remain even as we include spatial content — and ideally, authors should be able to use the same kinds of patterns to build for the spatial web.

And spatial content should not just be designed for spatial devices. The last few years have seen a dramatic rise in the number of websites showing 3D content – on phones, tablets and computers as well as headsets. Spatial web standards should support designing for browsers wherever they run.

New web features, classical CSS

By routing functionality for spatial content through declarative CSS, a page can use media queries targeting aspect ratio, color theme and reduced motion to adapt spatially as well. This adds much more flexibility to your website without having to do as much in your JavaScript, and removing the need to keep track of any complicated state.

Even better, the numerical parameters can be animated and transitioned in the same way that any other value can be changed on the page.

visionOS 27.3 offers the first components of spatial CSS in a developer preview, and this article demonstrates how to use them through the case study of a simple set of children’s blocks.

Feature breakdown

spatial: portal

The feature that kicks this all off is the declaration that an element is acting as a portal, through the new spatial:portal syntax. Elements that can contain other elements – think <figure>, <div> – can act as a portal, and will then act as a space that all of the child elements nested inside it share. This preview focuses on model elements, but the specification is written so that this approach should work for all content.

spatial transform:

Once the models are collected inside a shared space, you can then move, rotate, and scale them using their standard transform attribute. This takes the same DOMMatrix class that creates 2D and pseudo-3D transforms in other contexts, but can now act as a true 3D transform to objects inside the portal context.

A blue shape-sorter puzzle board on a white background with four recesses: an octagon, a star, a cross and a triangle. An orange octagon block sits to the left of the board and an orange star block to the right."
A simple scene of shaped blocks and a board to slot them in.
<div class="world" style="spatial:portal;">
  <model id="board" src="board.usdz"></model>
  <model id="octagon" src="octagon.usdz"></model>
  <model id="star" src="star.usdz"></model> 
</div>
<style>
    #octagon { 
        transform:translateX(-50cm);
    }
    #star { 
        transform:translateX(50cm);
    }
</stye>

The code for presenting this scene and setting the blocks off to the sides.

The board and the block objects can be moved and rotated independently — an expanded settings panel shows different values. While a model’s animation timeline could manage single sequence of action, this adds the degrees of freedom required for more sophisticated interaction or configuration.

position-anchor

Fitting 3D objects together can get complicated. We need a way to attach models to specific places on other models — think of putting together pieces of furniture. Model is a void element, which means it means we can’t nest models inside other model elements the same way that other DOM is nested. Instead, we’re borrowing from the CSS concept of position-anchor and adding a way to align and orient objects according to their anchors. position-context: anchor is the way to make it work.

See it in action

The blue shape-sorter board on a light gray background with the orange octagon block fitted into its recess. The star, cross and triangle recesses are still empty, and the orange star block sits loose to the right of the board.
The scene presented earlier with the octagonal block slotted exactly into place.
<div class="world">
    <model id="board" src="board.usdz"></model>
    <model id="octagon" src="octagon.usdz"></model>
    <model id="star" src="star.usdz"></model>
</div>

<style>
    #board {
        anchor-name:--board;
    }
    #octagon {
        position-anchor:--board#octagon-position;
        position-context:anchor;
    }    
    #star {
        display:none;
    }
</style>

The code for using position-anchor to achieve the correct placement for the block.

The board used in the example consists of three separate objects inside the 3D program it was built within: The visible shape of the board itself, and two reference positions — often called “null objects” or “empties” in 3D editors. These correspond to the correct position for each of the shape blocks to slot into when they’re on the board. Here’s the scene and its contents inside Blender:

A screenshot of the Blender 5.3 Beta interface with shapeblocks.blend open. The 3D viewport shows the blue shape-sorter board and the orange octagon and star blocks. The outliner on the right lists block-star, block-octagon, target-octagon, target-star and board, and the timeline is at frame 168.
The default view of the block scene presented inside Blender. Note both the block objects and the target objects in-place on the board.

Rather than copy-pasting values from your 3D editor, or having to guess at the right transform, you can nominate specific anchor points — just like in the 2D equivalent of the feature — to place an object in the right location. These anchor points can be animated, too, making it easier to compose elements even when they’re moving around.

@environment-map

An environment map is the lighting that is reflected off of an object — think of it as the room that an object appears within.

We introduced environment maps as an HTML attribute on the model element, because it was the only element that would be able to use it. Now that there is a broader range of elements that will be able to share environment maps. Taking inspiration from @keyframes for animation, we leverage @environment-map to facilitate this. This preview provides support for 360º HDR images and adds the clarifying syntax to indicate what they are and how to work with them.

See it in action

"The shape-sorter board and both blocks in a dark scene lit from below. The board looks near-black against a murky brown background. Green, purple and orange light glows in the recesses and along the edges of the orange octagon and star blocks.
The scene showing a spooky-colored underlighting effect.
<div class="world spooky">
    <!--... -->
</div>
@environment-map {
    name: "spooky";
    format: equirectangular;
    src: url("night.hdr");
}

.world.spooky {
     environment-map: "spooky";
}

The code for setting up the spooky environment lighting.

portal-action:orbit

One of the main things that users want to do with 3D content is to look around it by rotating the scene in-place. In 3D programs this is often called an ‘orbit’, and spatial CSS enables it with the new portal-action attribute. It may be useful to add more modes in the future like pan-x or pan-y. This mirrors the model element’s stagemode attribute on the HTML element, but by configuring it in CSS it becomes more flexible.

requestVolumetricScene()

In addition to showing a spatial arrangement inside a portal, visionOS has the ability to show these scenes outside of the browser window in what we’re calling a Connected Volumetric Scene. Launch a request from a user action to remove the spatial content from its portal and present it in the user’s space:

launchSpaceButton.addEventListener("click", event=>{
    const world = document.querySelector(".world");
    world.requestVolumetricScene();
});

The code to launch the volumetric scene.
Users can place the volumetric scene anywhere in their space, and the live link between the web page and the volumetric scene will let you update the scene — add or remove objects, or move them based on your needs.

Your feedback is essential

There is a long journey ahead, and a lot more to get to in the proposed spatial CSS specification. While this feature preview is limited to visionOS, we thought it was important to release along with the full specification as an indication of how to approach bringing spatial concepts to the web. Along with the general release of the <model> element on Safari 27, we hope this gives authors enough to think about the opportunities — and requirements — that lie ahead in the spatial web. That’s also why it’s so important for authors to explore the feature preview and tell us about their experience of using it. You can download the visionOS simulator with Xcode. If you don’t already have Xcode, you can download Xcode from the Mac app store.

To share your thoughts on the Spatial CSS feature preview, find us on Mastodon at @jensimmons@front-end.social, @jondavis@mastodon.social, or on X at @zachernuk. Or send a reply on X to @webkit. You can also follow WebKit on LinkedIn. If you run into any issues, we welcome your feedback about WebKit at bugs.webkit.org. Filing issues really does make a difference. Thanks.

Read the whole story
alvinashcraft
just a second ago
reply
Pennsylvania, USA
Share this story
Delete

Microsoft Web IQ Explained - AI-Native Web Grounding at 2.5x Speed for Agents

1 Share

When Microsoft retired its legacy Bing Search APIs and rolled out the modular Microsoft IQ platform, AI architects immediately asked how custom agents were supposed to pull live internet facts without burning thousands of tokens scraping raw HTML. Microsoft Web IQ is Microsoft's dedicated answer—an AI-native web search and grounding suite built specifically for LLMs rather than human browser clicks.

 

Powering flagship assistants like Microsoft Copilot and ChatGPT at global scale, Web IQ delivers 2.5x faster grounding speed through a single REST and Model Context Protocol (MCP) endpoint at https://api.microsoft.ai/v3. Better yet, it draws a strict isolation boundary between public internet facts and your private corporate estate.

 

Microsoft Web IQ Architecture REST and MCP Endpoints for AI Grounding
Microsoft Web IQ in the Microsoft IQ stack: Delivering 2.5x faster public-web grounding via REST and MCP while keeping internal enterprise data isolated.

 

Table of Contents

 

  • Built for AI Agents, Not Blue Links: Exposes Web Search, News, Images, Videos, and Browse over REST (https://api.microsoft.ai/v3) and MCP (https://api.microsoft.ai/v3/mcp).
  • 2.5x Faster & 79.05 Grounding Score: Server-side contentFormat=passage extraction returns targeted 3,000-character segments instead of noisy full-page HTML.
  • Strict Enterprise Isolation: Web IQ only searches the public web—never accessing Microsoft 365 files, SharePoint sites, or Fabric databases.
  • Entra ID & 15 QPS Default: Bills through a paid Azure subscription resource and authenticates via Managed Identity, AgentID, or x-apikey at 15 queries per second.
  • Compliance Guardrails: Offers 0-query logging for HIPAA/GDPR workloads, enforces 200-character display limits, and bans caching raw search results.

 

 

Where Microsoft Web IQ Fits Inside the 4-Pillar IQ Stack

As we outlined in our Microsoft IQ Stack for Beginners guide, Microsoft splits enterprise intelligence across 4 distinct context layers rather than dumping everything into a single giant index. Each pillar owns a strict data boundary:

  • Microsoft Work IQ: Captures employee collaboration, emails, Teams chats, and daily Microsoft 365 work signals.
  • Microsoft Fabric IQ: Elevates analytical, real-time, and operational tables into governed business semantics.
  • Microsoft Foundry IQ: Grounds agents in internal organizational policies, engineering manuals, and authoritative SharePoint knowledge bases.
  • Microsoft Web IQ: Serves as the outside-world window, pulling live market news, regulatory updates, and public documentation via Bing's web index.

 

Because Web IQ sits squarely at the perimeter, it has 0 access to private company data. Yet through MCP federation inside Foundry IQ, an agent can seamlessly blend live competitor pricing from Web IQ with internal strategy decks from Foundry IQ in a single grounded response.

 

 

How Passage Extraction and MCP Endpoints Cut Token Costs

Traditional search APIs force developers into a painful 2-step scrape loop: fetch a list of 10 blue links, download megabytes of HTML, strip navigation menus, and pray your model's context window does not overflow. According to Microsoft Learn's official Web IQ documentation, Web IQ normalizes pages into structured documents during indexing.

 

When you call Web Search, News, or Browse with contentFormat=passage, Microsoft's servers slice out only the passages relevant to your query—capped at 3,000 characters per result by default (or up to 500,000 characters in full-document text, HTML, or markdown mode if approved). In Microsoft's 3,000-query blind benchmark, this approach delivered a 79.05 grounding satisfaction score while consuming far fewer input tokens.

 

For multi-step agent loops, Web IQ also includes a Browse API with liveCrawl: "fallback" and renderDynamicPages: true for JavaScript-heavy URLs missing from the index. Meanwhile, Named Search Scopes let billing accounts enforce reusable allow and deny lists supporting up to 10,000 unique domain or URL selectors—making it simple to restrict competitive research agents to trusted industry sources.

 

Microsoft recommends starting most grounding workloads with maxResults=10 and maxLength=3000 in passage format, splitting multi-question user prompts into separate focused API calls under the 1,000-character query limit. Notice that Web Search intentionally omits a generic snippet field because the returned content field already carries query-targeted evidence.

 

 

Azure Metering, 15 QPS Quotas and Public Endpoint Realities

Cloud architects planning production rollouts need to understand Web IQ's exact deployment topology before writing Terraform scripts. Even though you deploy a Web IQ resource in a paid Azure subscription (Visual Studio, free trial, and student credits are blocked), that Azure resource only handles billing and metering.

 

Your application never routes through an Azure VNet to hit it. Instead, every request goes over public HTTPS to https://api.microsoft.ai/v3 via Azure Front Door, using either Microsoft Entra ID OAuth 2.0 tokens (Managed Identity or AgentID) or an x-apikey header bound to your Web IQ AppID.

 

There are 3 crucial enterprise caveats to note here. First, each AppID starts at a shared 15 queries per second (QPS) rate limit (HTTP 429 above that). Second, Web IQ does not support Private Link, VNet integration, IP allowlisting, or Azure RBAC on the API path. Third, Microsoft provides no formal uptime or latency SLA under the Web IQ Terms of Use—though you can still place Azure API Management in front of your outbound calls for telemetry and governance.

 

 

Microsoft Web IQ Core APIs, Scopes and Compliance Summary

Here is a quick architectural cheat sheet covering Web IQ's endpoints, limits, and governance boundaries:

 

🌐 Endpoints, APIs & Query Limits
REST & MCP Endpoints: https://api.microsoft.ai/v3 and https://api.microsoft.ai/v3/mcp
Available APIs: Web Search (max 50 results), News, Images, Videos, Browse (Live Crawl fallback), Auto (beta)
Query & Scope Caps: 1,000-character max query; 10,000 selectors per Named Scope; 15 QPS default per AppID
🔒 Security, Privacy & Compliance Controls
Authentication: Entra ID OAuth 2.0 (Managed Identity / AgentID) or x-apikey header over TLS 1.2 / 1.3
Data Boundary: Excluded from Azure DPA and EU Data Boundary; optional 0-query logging for HIPAA/GDPR
Prompt Injection Note: Web IQ does not execute retrieved scripts, but downstream agents must still apply Prompt Shields and Azure AI Content Safety

 

 

0-Query Logging, 200-Character Excerpts and Strict Caching Limits

If your team builds AI tools for banking or healthcare, pay close attention to Web IQ's privacy and licensing rules. By default, Web IQ logs query telemetry, operates outside the Azure Data Protection Addendum (DPA) and EU Data Boundary, and performs no server-side PII masking—so Microsoft explicitly advises scrubbing sensitive user inputs with Azure AI Language PII Detection before sending queries.

 

Regulated teams under HIPAA, GDPR, GLBA, or APPI can request 0-query logging through their Microsoft account team, which strips query text, result URLs, and IP addresses from operational logs. On top of that, Web IQ's Terms of Use enforce strict 200-character source excerpt limits, require visible clickable citations for every source your model uses, and strictly forbid caching raw search results into a derivative database.

 

In practice, that means your application can store generated LLM summaries inside per-user chat histories or internal memos, and hold raw content briefly during transient "Atomic Action" agent steps, as long as it deletes raw search payloads immediately once the workflow finishes.

 

 

Frequently Asked Questions (FAQ)

  1. What is Microsoft Web IQ and is it a large language model?
    Microsoft Web IQ is an AI-native web search and grounding API suite hosted at https://api.microsoft.ai/v3 (and via MCP at https://api.microsoft.ai/v3/mcp). It is not an LLM and does not generate final answers; instead, it retrieves fresh, verifiable web passages for models like Copilot, ChatGPT, or your custom enterprise agents.
  2.  

  3. How does Web IQ differ from Foundry IQ, Work IQ, and Fabric IQ?
    Within the Microsoft IQ stack, Work IQ handles Microsoft 365 workplace signals, Fabric IQ models governed business data, and Foundry IQ manages internal organizational knowledge bases. Web IQ sits strictly outside the corporate firewall to fetch public web intelligence and never accesses SharePoint files, Teams chats, or Fabric databases.
  4.  

  5. What APIs are included inside Microsoft Web IQ?
    Each Web IQ AppID can call Web Search (up to 50 results), News Search, Images, Videos, and Browse (including optional liveCrawl fallback and JavaScript rendering), while an Auto (beta) endpoint is available on request.
  6.  

  7. Why should developers use contentFormat=passage instead of full HTML?
    Setting contentFormat=passage tells Web IQ to extract only the query-relevant segments (up to 3,000 characters per result by default) on Microsoft's servers. This cuts LLM input token costs and prevents models from hallucinating on unrelated paragraphs.
  8.  

  9. How fast and accurate is Microsoft Web IQ compared to standard search APIs?
    Microsoft reports that Web IQ delivers 2.5x faster grounding speed and achieves a 79.05 grounding satisfaction score across 3,000 blind global test queries, outperforming traditional blue-link search APIs.
  10.  

  11. How are Web IQ requests authenticated and billed in Azure?
    You create a Web IQ resource in a paid Azure subscription (Visual Studio, free trial, and student credits are excluded) for billing, then connect it to get a Web IQ AppID. Production workloads authenticate over HTTPS using Microsoft Entra ID OAuth 2.0 tokens (Managed Identity or AgentID) or an x-apikey header.
  12.  

  13. What is the default rate limit for a Web IQ AppID?
    Each Web IQ AppID starts with a default quota of 15 queries per second (QPS) shared across all bound Entra application IDs and API keys. Higher QPS limits can be requested through Web IQ Support.
  14.  

  15. Does Microsoft Web IQ support Azure Private Link, VNet integration, or an SLA?
    No. Web IQ runs as a multi-tenant service behind Azure Front Door on the public https://api.microsoft.ai/v3 endpoint. It does not support Private Link, VNet integration, IP allowlisting, EU Data Boundary commitments, or a formal uptime/latency SLA.
  16.  

  17. Can regulated enterprises disable query logging on Microsoft Web IQ?
    Yes. While Web IQ logs queries by default under the Microsoft Privacy Statement, regulated organizations (under HIPAA, GDPR, GLBA, or APPI) can request 0-query logging through their Microsoft account team so query text, URLs, and IP addresses are omitted from logs.
  18.  

  19. Can I cache Web IQ search results in my own vector database?
    No. The Web IQ Terms of Use prohibit copying, caching, or building derivative search databases from raw results. You may only keep transient Atomic Action processing state, LLM summaries inside per-user chat history, or internal work product memos with required source citations.

 

 

End Note

Microsoft Web IQ cleanly fills the public-web gap in the Microsoft IQ ecosystem, pairing Bing's global index with token-efficient passage extraction and plug-and-play MCP support. Just remember to budget for its public HTTPS architecture, 15 QPS starting cap, and strict non-caching terms before going live. Are you pairing Web IQ with Foundry IQ or Work IQ in your enterprise agents? Let me know in the comments below!

 

Microsoft Web IQ vs Foundry IQ Work IQ and Fabric IQ Comparison
Completing the Microsoft IQ Stack: How Web IQ supplies real-time public web grounding alongside Work IQ, Fabric IQ, and Foundry IQ.

 

Read the whole story
alvinashcraft
17 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Toolkit Tuesdays: SkeletonView

1 Share

Welcome to another edition of Toolkit Tuesdays! In this series, I’ll be highlighting some of the controls and helpers in the Uno Toolkit library. This library is a collection of controls and helpers that we’ve created to make life easier when building apps with Uno Platform. I hope you find them useful too!

This week it’s SkeletonView, a brand-new way to show skeleton loading placeholders in your app. It shipped in Uno Toolkit 11, which landed alongside Uno Platform 7.0, so you can install it today. If you caught my tweet about it back when it was still a pull request, this is the longer version. It’s also a natural follow-up to the LoadingView post, which mentioned a skeleton view in passing. Now we finally get to look at one.

Yes, it’s November 17 and this is Halloween themed, close enough.

No skeleton shapes declared anywhere: placeholder rows for the empty lists on first load, then a refresh whose skeleton matches the content it replaces.

The Problem (and The Solution)

Every app has a moment where the data isn’t there yet. The usual answer is a spinner, and a spinner works, but it tells the user nothing about what’s coming. Then the data lands and the whole layout jumps around.

The fix everyone reaches for is a skeleton: gray placeholder shapes that look like the content that’s about to show up. The catch is that you normally have to build them by hand. That means a second, fake version of every screen that you have to keep in sync with the real one, and keeping that in sync is MISERABLE. Spoiler: it never stays in sync.

This is where the Uno Toolkit comes to the rescue. With SkeletonView, you don’t declare a single skeleton shape. You wrap your real content, and while it’s loading, the Toolkit generates the placeholders from the layout that’s actually there.

Anatomy of a SkeletonView

While IsLoading is true, SkeletonView walks your content and drops one placeholder on top of each leaf element at its real position. The rules are short:

  1. Leaves get one placeholder each. A leaf is a TextBlock, an Image, any Shape, a button, or an input control like a TextBox, ComboBox, Slider, or ToggleSwitch. A Button gives you a single button-sized placeholder no matter what’s inside it.
  2. Containers contribute their children, not themselves. Panels and borders get no placeholder of their own, and neither does the chrome of a ListViewItem or a card.
  3. Empty values fall back to their layout slot. A TextBlock bound to data that hasn’t arrived measures as almost nothing, so the placeholder uses the space the layout gave it instead.
  4. An Ellipse becomes a circle. Everything else becomes a rounded rectangle.

Your content stays in the visual tree the whole time, so layout and bindings keep working. Only the elements covered by a placeholder get hidden, and everything else stays visible. Placeholders are also clipped to what you can actually see, so a row scrolled halfway out of a list gets half a placeholder.

The same card loaded (left) and loading (right), with callouts for each rule: a line per TextBlock, a circle for the Ellipse, one block each for the TextBox and the Button, and the Border keeping its frame

A list scrolled partway, loaded (left) and loading (right): the rows cut off by the viewport get placeholders cut off at the same spot

Usage

Basic Usage

Write your content once, as plain XAML bound to your data, and wrap it in a SkeletonView:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<utu:SkeletonView IsLoading="{Binding IsBusy}">
    <StackPanel Spacing="12">
        <StackPanel Orientation="Horizontal"
                    Spacing="12">
            <Ellipse Width="48"
                     Height="48"
                     Fill="{ThemeResource SystemControlHighlightAccentBrush}" />
            <StackPanel VerticalAlignment="Center"
                        Spacing="4">
                <TextBlock Text="{Binding Title}"
                           Style="{StaticResource SubtitleTextBlockStyle}" />
                <TextBlock Text="{Binding Subtitle}"
                           Style="{StaticResource CaptionTextBlockStyle}" />
            </StackPanel>
        </StackPanel>
        <TextBlock Text="{Binding Description}"
                   TextWrapping="Wrap" />
        <Button Content="Some action" />
    </StackPanel>
</utu:SkeletonView>

That’s it. No skeleton markup anywhere.

While IsBusy is true, you get a circle for the avatar, two text lines, a full-width line for the description that hasn’t loaded yet, and a button-shaped block. When IsBusy flips to false, the real content takes over.

The Basic Usage card while loading (left) and once loaded (right)

IsLoading defaults to true, so a SkeletonView starts out in its loading state. If your skeleton never goes away, you forgot to bind IsLoading or set a Source.

Driving It From an ILoadable

If you’ve read the LoadingView post, this part will look familiar. Instead of a flag, you can point Source at any ILoadable, like an async command, and the SkeletonView follows its IsExecuting state:

1
2
3
4
5
6
7
<Button Content="Reload"
        Command="{Binding LoadDataCommand}" />

<utu:SkeletonView Source="{Binding LoadDataCommand}">
    <TextBlock Text="{Binding Description}"
               TextWrapping="Wrap" />
</utu:SkeletonView>

One command drives the button AND the skeleton. Zero IsBusy plumbing.

The one catch is that the ILoadable has to raise its IsExecutingChanged on the UI thread. If yours finishes somewhere else, wrap it in a LoadableSource.

One command, two jobs: Reload disables itself while the skeleton is up, then the new data lands.

Refreshing Content

Here’s my favorite part. The placeholders come from the live layout, so turning IsLoading back on over content that’s already loaded gives you a skeleton that matches it exactly. Same number of list items, and the text lines match the length of the current text. A spinner would blank out everything the user was just reading, but this keeps the shape of the screen right where it was.

A loaded list (left) and its refresh skeleton (right): same five rows, and every line is as long as the text it covers

Empty Lists

There’s one obvious gap. On a first load, a list has no items yet, so there’s nothing to mirror. The fix is the Skeleton.PlaceholderCount attached property, which you set on the list or on any ancestor:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<utu:SkeletonView Source="{Binding LoadPeopleCommand}">
    <Grid RowSpacing="8">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <TextBlock Text="Team"
                   utu:Skeleton.Ignore="True" />
        <ListView Grid.Row="1"
                  utu:Skeleton.PlaceholderCount="3"
                  ItemsSource="{Binding People}"
                  ItemTemplate="{StaticResource PersonRowTemplate}" />
        <Button Grid.Row="2"
                Content="Invite someone" />
    </Grid>
</utu:SkeletonView>

Three rows out of a list with nothing in it. Not bad!

While loading, the empty ListView gets its placeholder rows built from its own ItemTemplate, and it reserves the space for them so the button underneath moves down as if the rows were really there. Your ItemsSource and the list’s place in the tree are never touched, because the rows come from a hidden copy of the list.

The Empty Lists sample on first load (left) and once loaded (right): the Team header stays visible, three placeholder rows come from PersonRowTemplate, and the Invite someone button already sits where the loaded rows push it

Tuning the Result

Did you spot Skeleton.Ignore on that “Team” header? Most of the time the generated skeleton is what you want. When it isn’t, there are two attached properties for steering it:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<utu:SkeletonView IsLoading="{Binding IsBusy}">
    <StackPanel Spacing="12">
        <!-- static header: stays visible while loading -->
        <TextBlock utu:Skeleton.Ignore="True"
                   Text="Profile" />

        <!-- one circle instead of the image inside -->
        <Border utu:Skeleton.Shape="Circle"
                Width="64"
                Height="64"
                CornerRadius="32">
            <Image Source="{Binding AvatarUrl}"
                   Stretch="UniformToFill" />
        </Border>

        <!-- one block instead of every chip inside -->
        <ItemsControl utu:Skeleton.Shape="Rectangle"
                      Height="32"
                      ItemsSource="{Binding Tags}" />
    </StackPanel>
</utu:SkeletonView>

Skeleton.Ignore keeps an element, and everything inside it, visible and out of the generation entirely. It’s perfect for headers and labels that don’t depend on the data. Skeleton.Shape forces a placeholder shape (Auto, Rectangle, or Circle) and collapses the element into a single placeholder, which is handy for something like an avatar made of an Image inside a Border.

The Tuning sample loaded, then loading with the default generation (the Profile header hidden, a square for the avatar image, a placeholder per tag), then loading with Skeleton.Ignore and Skeleton.Shape (the header stays, the avatar is one circle and the tags are one block)

Styling

Three lightweight styling resources control the look, and they apply to everything in this post: SkeletonViewBackground, SkeletonViewShimmerBrush, and SkeletonViewCornerRadius. Override them in your app resources to restyle every skeleton at once:

1
2
3
4
5
6
7
8
9
10
<ResourceDictionary.ThemeDictionaries>
    <ResourceDictionary x:Key="Light">
        <SolidColorBrush x:Key="SkeletonViewBackground"
                         Color="#E8EEF6" />
    </ResourceDictionary>
    <ResourceDictionary x:Key="Dark">
        <SolidColorBrush x:Key="SkeletonViewBackground"
                         Color="#2B3442" />
    </ResourceDictionary>
</ResourceDictionary.ThemeDictionaries>

Each SkeletonView also has per-instance properties like SkeletonBackground, PlaceholderCornerRadius, and ShimmerDuration. If the shimmer is too much for you, set EnableShimmer="False" for static placeholders, which is a nice option when you want to reduce motion.

The Basic Usage card loading with the custom SkeletonViewBackground from the snippet above, in Light (left) and Dark (right) theme

The default shimmer (left) next to EnableShimmer set to False (right), for when you'd rather keep things still.

Beyond SkeletonView

SkeletonPresenter

SkeletonView assumes your real content is in the tree while it’s loading. Sometimes it isn’t. A LoadingView’s LoadingContent is a good example, since that slot is shown INSTEAD of your content. For those cases there’s SkeletonPresenter, which builds the skeleton from a DataTemplate:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<utu:LoadingView Source="{Binding LoadPeopleCommand}">
    <ListView ItemsSource="{Binding People}"
              ItemTemplate="{StaticResource PersonRowTemplate}" />

    <utu:LoadingView.LoadingContent>
        <utu:SkeletonPresenter utu:Skeleton.PlaceholderCount="3">
            <utu:SkeletonPresenter.ContentTemplate>
                <DataTemplate>
                    <ListView ItemTemplate="{StaticResource PersonRowTemplate}" />
                </DataTemplate>
            </utu:SkeletonPresenter.ContentTemplate>
        </utu:SkeletonPresenter>
    </utu:LoadingView.LoadingContent>
</utu:LoadingView>

Look at that PersonRowTemplate. The loaded list and the skeleton share it, so the skeleton can’t drift away from the real thing.

Behind the scenes, it instantiates a private, data-less copy of the template and generates the placeholders from that, filling any empty lists with rows from their ItemTemplate. And since a LoadingView keeps its LoadingContent around once it’s done, the presenter stops its shimmer when the LoadingView finishes, so nothing keeps animating out of sight. The docs also show how to use it inside your own control template.

Three skeleton rows built from PersonRowTemplate, then the real list takes over.

FeedView

If you’re using MVUX, you’re probably wondering about FeedView. Support for it is coming separately, as a SkeletonFeedViewStyle in Uno.Extensions that uses SkeletonPresenter for the initial load and SkeletonView for refreshes. It’s still in review at the time of writing, but here’s what it’ll look like:

1
2
3
4
5
6
7
8
<mvux:FeedView Source="{Binding People}"
               Style="{StaticResource SkeletonFeedViewStyle}"
               utu:Skeleton.PlaceholderCount="6">
    <DataTemplate>
        <ListView ItemsSource="{Binding Data}"
                  ItemTemplate="{StaticResource PersonTemplate}" />
    </DataTemplate>
</mvux:FeedView>

Once it lands, one Style and your MVUX pages get the same skeleton :crossed_fingers:

Rough Edges

It’s shipped, but it isn’t perfect. Let’s still be honest about where it stands.

  • The shimmer visuals aren’t covered by the automated tests. The band structure is asserted, but I literally just eyeballed the sweep itself. So if you don’t like it, blame Claude.
  • Covered elements are hidden by setting their Opacity to 0 and restoring it afterwards. If you’re animating or binding Opacity on those elements while loading, the skeleton will win.
  • An empty list needs an ItemTemplate and a width to get rows, and ItemTemplateSelector isn’t used for placeholder rows.
  • A list’s Header and Footer aren’t mirrored.
  • Covered controls aren’t hit-testable while loading, but Tab can still reach them. Bind their IsEnabled to your loading flag if that matters for your screen.

None of these are deal-breakers, but they’re worth knowing about before you build on it.

Conclusion

SkeletonView is a lot of loading experience for very little XAML. Wrap your content, bind IsLoading, and you get a skeleton that matches the real layout, including on refresh, without maintaining a second copy of every screen.

Grab Uno Toolkit 11 and give it a spin. The Toolkit samples app has a SkeletonView page with a section for every scenario in this post, and if you hit something weird, issues and feedback are very welcome! Jump into the fun on the Uno Toolkit GitHub repo!

I hope you enjoyed this edition of Toolkit Tuesdays, and I’ll catch you in the next one :wave:

Further Reading



Read the whole story
alvinashcraft
23 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Announcing new builds for 16 November 2026

1 Share
Hello Windows Insiders, Today, we’re releasing new Windows 11 Insider Preview builds to the Beta and Experimental channels. New builds this week Select your channel below to view its release notes: Please note that we are temporarily blocking movement from Experimental or Beta to Experimental (Future Platforms), we are working to resolve this as soon as possible. Ignite 2027 We look forward to welcoming Ignite attendees to San Francisco this week (November 17-19). We will be running a Windows Insider booth where you can meet some of the faces behind the program, provide your feedback and have your chance to win some swag! If you are not attending Ignite this week, digital registration is free and you can sign up here.

Notable new features:

[Advanced security key management]

Release channel: Experimental
  • You can now see the passkeys stored on a FIDO2 (Fast Identity Online 2) security key and remove them one at a time, instead of resetting the entire key. Admins can also configure enterprise settings such as minimum PIN length, always-required user verification, and enterprise attestation.
[caption id="attachment_179274" align="aligncenter" width="1398"]Manage passkeys stored on a FIDO2 security key individually, without resetting the entire key. Manage passkeys stored on a FIDO2 security key individually, without resetting the entire key.[/caption]

[Remote Lock]

  • Remote Lock lets IT lock a lost, stolen or compromised Windows device from Microsoft Intune without wiping it. Windows signs out every active session, hides all sign-in options and shows a Device Locked screen. Nothing is erased: the device stays enrolled and managed; BitLocker stays on, and user data stays in place. Only an admin can lift it remotely, so the user picks up where they left off. Learn more: https://aka.ms/remotelock
[caption id="attachment_179275" align="aligncenter" width="1020"]The default lock screen. LockReason and RecoveryHint add your own reason and help desk contact. The default lock screen. LockReason and RecoveryHint add your own reason and help desk contact.[/caption]

[Taskbar]

  • When you hover over an app on the taskbar, Windows shows previews of its open windows to help you tell them apart and quickly see what’s in each one.
  • Now, you can choose to use the list view anytime. When list view is on, hovering over an app on the taskbar shows all its open windows by title in a list instead of as previews.
  • To turn on list view, go to Settings > Personalization > Taskbar.
[caption id="attachment_179276" align="aligncenter" width="2136"]Default taskbar hover, with previews of each open window for the app. Default taskbar hover, with previews of each open window for the app.[/caption]

[Magnifier]

Magnifier, the way you work: now with touch and touchpad
  • Magnifier already works with your keyboard, mouse, and scroll wheel. Now it also supports touchpad and touch gestures, so you can zoom and move around in whatever way feels most natural to you.
  • Before you start: Make sure Magnifier is running. Press Windows key + Plus (+) to turn it on. The gestures below work while Magnifier is on.
On a touchpad
  • Zoom in or out: Swipe up with three fingers to zoom in or swipe down to zoom out.
  • Pan around the screen: Move one finger as you normally would, and the magnified view follows your pointer.
  • Toggle between 100% and your previous zoom level: Tap with three fingers.
[caption id="attachment_179277" align="aligncenter" width="720"]Use touchpad gestures to zoom and move around with Magnifier. Use touchpad gestures to zoom and move around with Magnifier.[/caption] On a touchscreen
  • Pan around the screen: Drag with three fingers.
  • Zoom in or out: With three fingers, tap once, then tap again and keep your fingers down. Without lifting your fingers, drag up to zoom in or down to zoom out.
  • Toggle between 100% and your previous zoom level: Double-tap with three fingers.
[caption id="attachment_179278" align="aligncenter" width="720"]Use touchscreen gestures to zoom and move around with Magnifier. Use touchscreen gestures to zoom and move around with Magnifier.[/caption]
  • Both gesture sets are on by default. To turn either one off, go to Settings > Accessibility > Magnifier and turn off Control Magnifier with touchpad gestures or Control Magnifier with touch gestures.
See release notes for more features. Thanks, Stephen and The Windows Insider Program team
Read the whole story
alvinashcraft
29 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

.NET Conf 2026 Day 2: Visual Studio, Resilient Blazor, and AI Workflows

1 Share
Everything that stood out from Day 2 of .NET Conf 2026, from the new Visual Studio agent and Blazor Server resilience to WinUI, Azure, file-based C# apps, and EF Core 11 vector search, with links to jump into the replay.
Read the whole story
alvinashcraft
1 minute ago
reply
Pennsylvania, USA
Share this story
Delete

.NET Conf 2026 Day 1: .NET 11, C# 15 Unions, and Faster Builds

1 Share
Everything that stood out from Day 1 of .NET Conf 2026, from the .NET 11 launch and C# 15 unions to build speedups, runtime async, MAUI, Aspire, and the security numbers, with links to jump into the replay.
Read the whole story
alvinashcraft
1 minute ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories