---

Comment

I can’t think of a better time than around WWDC to be diving back into the world of Apple as a developer. There is a huge flurry of fascinating blogs, code labs, and opinion pieces coming from all over the iOS developer community. I truly have loved taking it all in this week, though of course the hard part is distilling that down into just one newsletter.

With macOS 27 hitting the end of the line for Intel-based Macs, I can’t help but look back at my ever-growing collection of old Apple hardware. From the 2013 Mac Pro “Trash Can” that I still use as a dedicated machine for OBS and video rendering to the G5 Power Mac I was only recently using as a Minecraft server. While these machines may have stopped getting official OS updates, it is the community that keeps this hardware alive. A massive shoutout to the OpenCore Legacy Patcher developers for keeping so many old Intel Macs alive and working for so long!

It is truly the end of an era across the board, especially with macOS 27 also quietly pulling the plug on AFP (Apple Filing Protocol) and vintage AirPort Time Capsules. Seeing a networking standard that dates back to System 6 finally get sunsetted really puts the march of time into perspective (even if I am deeply in love with my M4 Max Mac Studio).

Anyway, on with this week’s selection of news from across the iOS community!

– Zachary Powell

Sponsored Link

Debugging a React Native App in Production, Live

A real production crash, triaged in real time. Simon Grimm, creator of Galaxies.dev, shows how he uses Sentry to go from alert to hypothesis with stack traces, breadcrumbs, logs, tags, replays, and Seer. It’s a hands-on look at production monitoring for anything with real users.

Save your spot

News

iOS 27, Your App, and Siri

The promise of a smarter Siri that can effortlessly parse personal context and act on voice commands is finally arriving. But what does that mean for our own apps? Jordan Morgan breaks down the essential APIs you need to know about to get your data ready. From lightweight App Entities and App Schemas to utilizing view annotations, Jordan explains how to structure your models so the system can understand them out of the box.

---

WWDC26: Xcode Tips and Tricks Group Lab - Q&A

Group labs during WWDC are always packed with hidden gems and practical advice that do not always make it into the main video sessions. Anton Gubarenko attended a range of these group labs and has been putting together some fantastic, highly scannable transcripts of the Q&A sessions. He groups the answers by topic and adds clear context, making it much easier to find solutions for common development bottlenecks.

Code

From Size Class to Available Space: Is horizontalSizeClass Still Reliable?

For years, checking the horizontal size class was the go-to shortcut to decide if our app was running on a phone or a tablet. But with recent updates allowing iPhone apps to be freely resized during desktop mirroring or inside iPad environments, those old assumptions are starting to break. Fatbobman breaks down why the traditional system traits we used to rely on are no longer suitable as a continuous width sensor. Instead, we need to shift our mindset toward adapting layouts to the actual available geometry of the view.

---

How did Apple cut launch time by 30% in iOS 27?

With the recent flurry of WWDC announcements, everyone is talking about the massive new headline features. Jacob Bartlett takes a completely different path, diving deep under the hood of the new release to figure out exactly how Apple managed to slice app launch times by a massive 30 percent. Using Instruments as his guide, Jacob walks through the core optimizations, structural adjustments, and profiling techniques that made this speed boost happen, giving us a fantastic masterclass in mobile performance tuning.

---

Swipe actions outside of List in SwiftUI

Swipe actions have been a staple of SwiftUI Lists for a long time, but what if you want to use them on custom cards, grid cells, or other standalone views? Majid Jabrayilov covers how to break swipe actions free from the constraints of List containers. He explores the underlying view modifiers and layout mechanics needed to build custom swipe gestures that feel completely native while giving you total design flexibility.

---

SwiftUI Best Practices as an Xcode Agent Skill

With agentic coding becoming a core part of the daily workflow in the new Xcode releases, the next logical step is teaching these agents how you like to write code. Antoine van der Lee walks through how to build a custom agent skill tailored for SwiftUI best practices. By defining explicit rules and architectural patterns, you can ensure your automated coding assistants generate clean, modern, and highly performant SwiftUI code that perfectly matches your team style guidelines.

---

RTSP Live Streaming on iOS with AWS

Streaming live video via RTSP on iOS has always been a bit of a challenge since AVPlayer does not support it out of the box. Hariharan Jagan has put together a comprehensive guide exploring how to bridge this gap using AWS infrastructure. The project walks through setting up an end to end pipeline to ingest RTSP camera feeds and stream them reliably to an iOS client, making it a great reference if you are building apps for IP cameras, smart home integrations, or live monitoring systems.

And finally...

I think we can all agree Apple embracing the “Crack Marketing Team” makes for a brilliant start to any keynote. Not to mention that seamless transition from cartoon to real life. Loved it!

Last week, at CSS Day, I presented on the topic of CSS Grid Lanes, an exciting new CSS layout feature coming to the web.

One part, which I didn't talk about during the presentation, is how alignment works in CSS Grid Lanes. The reason I didn't talk about it is that alignment is still being implemented in Chromium, and after some quick testing, I believe it's also not fully implemented in Safari.

In this article, let's quickly go over how alignment will eventually work in CSS Grid Lanes.

Two axes of alignment

Like in other layout systems, there are two axes to consider when aligning items in Grid Lanes, and the way we refer to them isn't very intuitive, at least to me, so let's go over them quickly:

• The grid axis

  That's the axis along which the lanes are laid out. In a column-orientation grid lanes layout (and assuming a left-to-right, top-to-bottom writing mode), this axis is horizontal.

• The stacking axis

  That's the axis along which the items are stacked within a lane. In a column-orientation grid lanes layout (still assuming a left-to-right, top-to-bottom writing mode), that's the vertical axis.

This diagram of a column-orientation layout should help clarify the two axes:

Grid axis alignment

Let's first align things along the grid axis. Sort of easy, because this works exactly the same as in a regular CSS Grid layout.

Who am I kidding though, who can even remember whether to use justify-* or align-*? Well, here it is:

• To align a column-orientation grid lanes layout along the grid axis, use justify-*.
• To align a row-orientation grid lanes layout along the grid axis, use align-*.

Said differently, use justify-* to align horizontally, and align-* to align vertically.

And then, it depends on what you want to do:

• Either align the entire grid lanes layout, in which case you use the -content suffix for these properties.
• Or, align the items within their lanes, in which case you use the -items suffix (or the equivalent -self suffix on the individual items).

Aligning the entire layout

For example, let's imagine a column-orientation layout, and let's say we want to align the entire set of grid lanes to the center of the container:

.layout {
  /* Create the layout. */
  display: grid-lanes;
  
  /* Create the column lanes. */
  grid-template-columns: 20rem 1fr 10rem 100px;

  /* Center the set of lanes in the container. */
  justify-content: center;
}

For a row-orientation layout, the equivalent would be to use align-content instead of justify-content.

Aligning items within their lanes

Now, if you instead want to align each individual item within its lane, you would use justify-items. For example, to align items to the right (or end) of their lanes, you would do this:

.layout {
  /* Create the layout. */
  display: grid-lanes;
  
  /* Create the column lanes. */
  grid-template-columns: 20rem 1fr 10rem 100px;

  /* Center the items in their lanes. */
  justify-items: end;
}

To do the same in a row-orientation layout, you would use align-items instead of justify-items here.

Note that you can also use justify-self (or align-self in a row-orientation layout) on individual items to override the alignment for that specific item.

For example, let's say we want the first item to always stretch instead of being aligned to the right, we could do this:

.layout {
  /* Same as above, aligning all items to the right */
  display: grid-lanes;
  grid-template-columns: 20rem 1fr 10rem 100px;
  justify-items: end;
}

.layout > *:first-child {
  /* Override the alignment for the first item. */
  justify-self: stretch;
}

And we'd get this:

Stacking axis alignment

Now on to alignment along the stacking axis. This is where things will become more interesting because grid lanes has a magic feature that will allow you to fill leftover space, if any.

But first, let's review the alignment properties you'll be using along the stacking axis:

• To align a column-orientation grid lanes layout along the stacking axis, use align-*.
• To align a row-orientation grid lanes layout along the stacking axis, use justify-*.

Said differently, use align-* to align vertically, and justify-* to align horizontally. Hey, that's the same as for grid axis alignment! So, again, assuming left-to-right, top-to-bottom writing mode, always use align-* to align vertically, and justify-* to align horizontally.

Aligning the entire layout

Nothing too special here, this is similar to the other (grid) axis: you can align the entire layout within its container, along the stacking axis, if there's space to do so.

For example, to align a column-orientation layout to the center of its container, you would do this:

.layout {
  /* Create the layout. */
  display: grid-lanes;
  
  /* Create the column lanes. */
  grid-template-columns: 20rem 1fr 10rem 100px;

  /* Center the layout vertically in the container. */
  align-content: center;
}

Which would give you this:

For a row-orientation layout, the equivalent would be to use justify-content instead of align-content.

Aligning items within their lanes

And now here is the really interesting part, aligning individual items along the stacking axis.

At first sight, this might seem surprising. After all, CSS Grid Lanes fills any available space along the stacking axis. That's the whole point, right? When a lane is shorter than the other lanes, the next item to be placed goes in that lane, filling the space. So, when can you end up with leftover space in a lane? Well, here are two ways:

1. When you start spanning items across multiple lanes, that might create gaps in the layout, where no items can be.

   

2. Once all items have been placed, you usually end up with a ragged end edge, with some lanes taller than others.

   

What stacking axis alignment allows you to do is fill that gap!

For example, in a column-orientation layout, with some gap above a spanning item, you could set align-items: stretch to force all items to fill the remaining space in their lanes:

.layout {
  /* Create the layout. */
  display: grid-lanes;
  
  /* Create the column lanes. */
  grid-template-columns: 20rem 1fr 10rem 100px;

  /* Stretch items to fill their lanes. */
  align-items: stretch;
}

.large-item {
  /* Make one of the items span 2 columns. */
  grid-column: span 2;
}

Which would give you this, effectively filling the gap above the spanning item with the item above it, and filling the rest of the lanes with the bottom items:

Again, this is for a column-orientation layout. For a row-orientation layout, you would use justify-items: stretch instead of align-items: stretch.

And with this, I think we've covered all the alignment options in CSS Grid Lanes. I hope this article has helped clarify how things work in this new layout.

Last thing, my team at Microsoft Edge tells me they're very close to getting alignment working in all cases, in Chromium, so I'm very excited by the possibilities, and will probably be posting demos about this in the future. Stay tuned!

June 5 – 18, 2026

Welcome back to the WordPress.com changelog! These two weeks smoothed out everyday work — sharper image editing and easier-to-scan notifications. And if you connect an AI agent like Claude or ChatGPT to your site, it can now do a lot more, including editing your site’s design and managing plugins.

Editing and media

Crop and resize without the friction

Working with images on your site just got more forgiving. The in-editor crop and resize tools are now available across all WordPress.com sites, so you can frame a photo exactly how you want it without leaving the editor or opening a separate app.

Open a post or page, add an image, and then click the crop button to launch the new experience:

Plugins

Desktop Mode: a new, free way to multitask in WordPress

If you juggle a lot at once — drafting a post while uploading media, tidying pages, clearing comments — Desktop Mode turns your WordPress admin into a workspace that’s reminiscent of your computer desktop.

Open posts, pages, and media as separate windows you can resize and arrange, jump anywhere with a quick command search, and recover anything from a single Recycle Bin that covers posts, pages, media, and comments.

It’s a free, open-source plugin from Automattic, available now. Install it on any paid WordPress.com plan.

AI

Your AI agent can now do more on your WordPress.com site

If you connect an AI agent to WordPress.com, it can now help you with a lot more. On top of managing your content, a connected agent can now also:

• Edit your site’s design: templates, menus, navigation, and styles
• Manage plugins on plugin-enabled sites: search, install, activate, and update
• Handle team access: invite people, change roles, and manage permissions
• Create a site: spin up a new WordPress.com site from a description
• Look up account details: billing and subscriptions

As before, you stay in control. It’s off until you turn it on, every tool is opt-in, and you can disable it for specific sites at any time.

Fixes and improvements

We also shipped a round of polish and reliability updates across WordPress.com, including:

• Fixing an error that caused the Add Mailbox page to fail the first time you opened it, so adding a mailbox to your email no longer needs a refresh.
• Fixing a crash in the post editor after generating a video Clip on a site without specific settings.
• Correcting renewal dates shown in checkout terms to show in your display language.
• Fixed social shares to Threads not showing a link preview card when the post used a custom message without the URL. Posts now include the link card automatically.

In the last 5 posts we created an agentic application using Python. Let’s migrate that to C#. Here’s the set of files we’ll create:

And here is the output after running it as a test using the prompt Use of multi-agents in writing a C# application:

Blogger Blogger: No research yet, directing to researcher Decision: researcher Task: Research the topic: use of multiagents in writing a C# application

RESEARCHER Researching: Research the topic: use of multiagents in writing a C# application Found: The search results highlight several key findings regarding the use of multi-agent systems in C# app…

Author Draft created: 3066 characters

REVIEWER Review: APPROVED – The draft effectively introduces the concept of multi-agent systems in C# applications an… ✓ Draft APPROVED

========== RESULTS ========== Task: use of multiagents in writing a C# application

Research Findings (1):

• The search results highlight several key findings regarding the use of multi-agent systems in C# applications:

1. Creating Multi-Agent Applications: Jesse Liberty discusses the development of a multi-agent application designed to generate blog posts. The article suggests a step-by-step approach to understanding the application, indicating that the process involves both design and implementation phases.
2. Creative Writing Assistant: A sample application showcased by Microsoft demonstrates the use of multi-agent systems in a creative writing context. This application utilizes the Semantic Kernel and .NET Aspire, illustrating practical applications of multi-agent frameworks in enhancing creative tasks.
3. Challenges in Multi-Agent Systems: Elliot One emphasizes a critical perspective on multi-agent systems, warning that simply adding more agents does not necessarily improve the quality of outputs. Instead, it can complicate the identification of errors, suggesting that careful design and management of agents are crucial for effective outcomes.

Overall, these findings suggest that while multi-agent systems can enhance functionality in applications like creative writing, they also present challenges that require careful consideration in their design and implementation.

Draft:

Harnessing Multi-Agent Systems in C# Applications: A Guide to Creative Writing

In the evolving landscape of software development, multi-agent systems (MAS) have emerged as a powerful paradigm, particularly in applications that require creativity and collaboration. This post explores the implementation of multi-agent systems in C# applications, focusing on their role in enhancing creative writing tasks.

Understanding Multi-Agent Systems

Multi-agent systems consist of multiple interacting agents, each capable of autonomous decision-making. These agents can collaborate, negotiate, and share information, making them ideal for complex tasks that benefit from diverse perspectives. In the context of writing applications, MAS can facilitate the generation of content, brainstorming ideas, and even editing drafts.

Creating a Multi-Agent Application

Jesse Liberty outlines a structured approach to developing a multi-agent application aimed at generating blog posts. The process involves two key phases: design and implementation. During the design phase, developers must define the roles and responsibilities of each agent, ensuring that they complement one another. The implementation phase focuses on coding the agents, integrating them into a cohesive system, and testing their interactions.

Example Application: Creative Writing Assistant

A practical example of multi-agent systems in action is a creative writing assistant developed using Microsoft’s Semantic Kernel and .NET Aspire. This application showcases how agents can work together to enhance the writing process. For instance, one agent might focus on generating ideas, while another refines the language and style. By leveraging the strengths of each agent, the application can produce high-quality content that resonates with readers.

Challenges in Multi-Agent Systems

While the potential of multi-agent systems is significant, it is essential to approach their implementation with caution. Elliot One highlights a critical challenge: simply adding more agents does not guarantee improved outcomes. In fact, an increase in agents can complicate error identification and management. Therefore, careful design and oversight are crucial to ensure that the agents work harmoniously and effectively.

Conclusion

The integration of multi-agent systems in C# applications, particularly for creative writing, offers exciting possibilities for enhancing productivity and creativity. By understanding the design and implementation processes, as well as the potential challenges, developers can create robust applications that leverage the strengths of multiple agents. As the field continues to evolve, the thoughtful application of these systems will undoubtedly lead to innovative solutions in various domains.

In summary, multi-agent systems represent a promising frontier in software development, particularly for applications that thrive on collaboration and creativity. Embracing this technology can empower developers to create more dynamic and engaging user experiences.

Review Notes: APPROVED Revision Number: 1

In the next post we’ll begin looking at each file and how it relates to what we had in Python.

Hello Windows Insiders, We have new releases today with builds across Beta and Experimental, including Windows 11, version 26H2 for Experimental. Windows 11, version 26H2 Windows 11, version 26H2 represents our yearly second half major update as part of our standard annual Windows 11 update cadence. As Windows 11, version 26H2 shares the same servicing branch as Windows 11, version 25H2, the update is implemented through an enablement package (eKB). This means your device will be updated to the next version through a single restart – providing a familiar, fast, and reliable update experience. Devices already enrolled in the Experimental channel will begin seeing their versioning updated to version 26H2 under Settings > System > About (and winver). If you are in the Beta channel and would like to switch to the Experimental, you can easily do so under Settings > Windows Update > Windows Insider Program. Remember, you can easily switch back to Beta at any time, without having to do a full Windows reinstall. Not currently enrolled in the Windows Insider Program and wanting to preview version 26H2? Register for WIP selecting the Dev channel, while it's transitioning to Experimental. Once the transition is complete, the new channel name to preview version 26H2 will appear as Experimental. For more information on Windows 11, version 26H2, especially for IT professionals, please see Get ready for Windows 11, version 26H2. Note: Devices running Windows 11, version 26H1 will not be able to update to version 26H2. Instead, they’ll have a path to update to a future Windows release. This is because Windows 11, version 26H1 is based on a different Windows core than Windows 11, versions 24H2, 25H2, and 26H2. Here’s What to know about Windows 11, version 26H1. New builds this week Today we are releasing new Windows 11 Insider Preview Builds. As a reminder, all Insiders can find the release notes for your device based on the new channel system, even if you haven’t moved yet. This is to make finding build information as easy as possible during the transition. See your channel release notes here: • Beta: Build 26220.8690 • Experimental: Build 26300.8697 For those on other specific build versions, here are today’s new builds and release notes: • Beta (26H1): Build 28020.2308 • Experimental (26H1): Build 28120.2315 • Experimental (Future Platforms) – Including Canary 29600 series: Build 29613.1000 Thanks, Stephen and the Windows Insider Program team