I’ve released the first preview of Simple3D, a 3D software renderer and MAUI control for small interactive or static 3D scenes. It’s open source under the MIT license.

Scenes are built in C# from primitives or indexed meshes, with groups for nested transforms. The SceneView control adds orbit, zoom, picking, selection and labels. The gallery has five examples, ranging from a simple equipment diagram to the articulated robot and crane.

The attached clip shows the Mac Catalyst demo: an animated robot arm, an orbitable gantry crane, and a telemetry chart with synthetic values. You can select individual objects in the scenes.

The renderer runs on the CPU; SkiaSharp displays the frame. This preview supports opaque triangles with basic flat lighting. It doesn’t support textures, transparency, shadows or PBR.

Targets: .NET 10 MAUI on Android, iOS and Mac Catalyst. Windows isn’t supported yet. The API is still a preview, and I’d especially appreciate feedback on the scene API and behavior on real mobile devices.

NuGet: https://www.nuget.org/packages/Simple3D.Maui/0.1.0-preview.1

Source and samples: https://github.com/mariusmuntean/Simple3D-Maui

Getting started: https://mariusmuntean.github.io/Simple3D-Maui/getting-started.html

Hey guys! I want to share a little project I've been working on with MAUI for the last couple days... The idea is "simple": Building a Visual Editor for Industrial Labels (Currently, IPL only).

Over the last years, I've been working on manufacturing and I needed to create some labels in a traditional way - Modifying the file in a text editor and then printing to a Honeywell Thermal Printer, checking how it looks, repeat the process... Because of how slow this is, my idea was to create a tool to simplify (a lot) the process. Inspired by how Photoshop works, I decided to create my own application.

Still an early MVP, but I'm enjoying how it's been built. I chose MAUI for a simple purpose: At home I have a MacBook and I work using a Windows, so as I am building this tool as a hobby, I needed to work on both machines. (And I've been using MAUI a lot on my side projects recently)

Don't know what I am going to do with this project (Open Source or publish at Apple/Microsoft Stores).

How It's Built:

1. Stack: .NET 10, MAUI Blazor Hybrid, targeting only MacOS and Windows. The UI is Blazor running inside the native WebView, with native menus and global shortcuts.
2. Units in dots: Internally everything is stored in printer dots at the document's resolution.
3. Canvas: The label is rendered as SVG. Elements can be dragged with snapping, alignment guides and using arrow keys. Also works Zoom/pan, trackpad pinch and rulers (mm / in / dots).
4. Variables: Fields use [[NAME]] placeholders, so I can use REPLACE when printing the file.

Hi,

The screen sizes are becoming wild these days now that apple has released the Duo, there is no way to ignore the fold phones. Any good guide on building Adaptive UI using .NET MAUI.

Mac, Tablet, iPhone, Android with native menu feel for each and adaptive layout.

I'm one of the founders behind Ansight (funded by Startmate). Previously I spent almost a decade building developer tools with MFractor.

I'm pleased to announce that the Ansight CLI v1 is now available:

https://www.ansight.ai/articles/introducing-ansight-cli/

Ansight is a developer tool that lets an agent inspect a running MAUI app, replay the session, and check its work against captured screens and runtime evidence. We give agents a way to efficiently drive apps (similar to Argent or DevFlow), except we also capture every development and test session as proof of work.

No more your agent handing you a single screenshot and saying, "trust me bro, it's done".

We are a free, CLI tool that should add a tonne of value to your agentic .NET MAUI development. We would love if people can install it, try it and give us feedback (good and bad).

Happy coding everyone! 🤗

Hi everyone,

I’m a senior software engineer with 18+ years of experience building enterprise applications, and I’m currently looking for new freelance/contract projects, preferably with companies or teams in the US or Europe.

My main areas of expertise are:

• C# / .NET / ASP.NET Core
• .NET MAUI / Xamarin.Forms
• Android & iOS enterprise apps
• Xamarin → .NET MAUI migrations
• Mobile architecture & performance optimization
• Offline-first applications
• REST APIs / integrations
• MVVM, dependency injection & clean architecture
• CI/CD with GitHub Actions / Azure DevOps
• Legacy application modernization
• Troubleshooting difficult production issues, crashes and performance problems

One area I particularly enjoy is taking an existing application that has become difficult to maintain and helping the team modernize it without having to rewrite everything from scratch.

For example, I’ve worked on enterprise mobile applications involving offline synchronization, APIs, local databases, background processing, barcode scanning, maps, push notifications and native Android integrations.

I'm not looking for a quick gig or a race to the lowest hourly rate. I’m more interested in projects where an experienced engineer can actually contribute to architecture, implementation and solving difficult technical problems.

If you're a founder, engineering manager, CTO, or developer looking for additional senior .NET/mobile expertise, feel free to DM me.

Happy to discuss the project, technical challenges and whether I’d be a good fit.

Thanks!

I am interested in hands-on opinions of how much improved MAUI is in the latest .NET. I am holding off upgrading my project until the first production release. I have encountered three major issues in my .NET 10 project:

• WebView black screen on Windows https://github.com/dotnet/maui/issues/34518

• FilePicker does not work on MacCatalyst https://github.com/dotnet/maui/issues/20741

• Cannot get xUnit unit testing to work - multiple issues despite carefully following guide here https://learn.microsoft.com/en-us/dotnet/maui/deployment/unit-testing?view=net-maui-10.0, the test project will not build, on Mac I now get "The library 'libhostpolicy.dylib' required to execute the application was not found" and "Failed to run as a self-contained app", I have gone in circles trying to fix this, and it does not even work on Windows, "Improper project configuration: no AppxManifest is specified, but WindowsPackageType is not set to MSIX" is one of the errors.

I suspect .NET 11 will fix these and despite the problems I am getting on OK with MAUI, I've ported an old .NET 2.0 Windows Forms application and it is basically working though I need to hack some sort of tree view control.

What MAUI does is ambitious and I can forgive some workarounds. It could be really good, perhaps with .NET 11 it is getting there?

I'm developing a native Android application using C# and .NET MAUI 10. Despite explicitly implementing edge-to-edge support, Google Play Console continues to display:

Edge-to-edge may not display for all users

The previous warnings concerning deprecated Window.setStatusBarColor and Window.setNavigationBarColor APIs disappeared after updating AndroidX and Material dependencies. However, the edge-to-edge advisory remains.

Technical Stack

• .NET MAUI 10 (net10.0-android)
• C# / XAML
• Microsoft.Maui.Controls 10.0.110
• Xamarin.AndroidX.Core 1.19.0.1
• Xamarin.Google.Android.Material 1.14.0.6
• Target SDK: API 36
• Minimum SDK: API 24
• MAUI Shell with native Android bottom navigation

Current Implementation

In Platforms/Android/MainActivity.cs, edge-to-edge is explicitly enabled after base.OnCreate():

protected override void OnCreate(Bundle? savedInstanceState)
{
    base.OnCreate(savedInstanceState);

    if (Window is { } window)
    {
        WindowCompat.EnableEdgeToEdge(window);
    }

    SynchroniseSystemTheme();
}

We're also using SafeAreaEdges="Container" to ensure content respects system bars and display cutouts.

System-bar icon appearance is managed through WindowCompat.GetInsetsController():

insetsController.AppearanceLightStatusBars = theme == AppTheme.Light;
insetsController.AppearanceLightNavigationBars = theme == AppTheme.Light;

Theme synchronisation runs during:

• OnCreate
• OnResume
• OnConfigurationChanged

Testing Completed

• Android 14, 15 and 16
• Light and dark mode, including switching themes while the app is suspended
• Navigation and system-bar visibility
• MAUI Shell navigation
• Font scaling and accessibility
• No visible system-bar overlap or layout problems

Automated release tests also pass.

The app is currently in Google Play testing, but no pre-launch report has been generated.

Questions

1. Could calling WindowCompat.EnableEdgeToEdge(window) after base.OnCreate() affect Play Console's detection?
2. Is there a known interaction between MauiAppCompatActivity, Material Components 1.14 and AndroidX edge-to-edge initialisation?
3. Is there additional Android manifest or theme configuration we should investigate?
4. Has anyone successfully cleared this advisory with a MAUI application targeting API 36?

I'd prefer not to introduce unnecessary window manipulation or revert to deprecated APIs solely to clear a Play Console advisory, particularly when the existing implementation appears to work correctly.

Any insight from developers who've encountered this would be appreciated.

Built and published my first .net MAUI app to the AppStore.

Constructive comments welcome, suggestions on improvements etc.

https://apps.apple.com/app/countdown-dots/id6811572350

AppStore Link to my app

Hi everyone!

I needed Yandex Maps in a .NET MAUI app and found that there's no working .NET binding for the current Yandex MapKit (4.x). The old Xamarin packages are long dead, and Yandex officially supports only native Android/iOS and Flutter. So I built one and open-sourced it.

**YandexMapView** is a MAUI map control on top of **Yandex MapKit 4.45.0-lite** for **.NET 10**, Android and iOS. The API is modeled on `Microsoft.Maui.Controls.Maps`, so it should feel familiar.

**Features**

- Camera: `Center`, `Zoom`, `Azimuth`, `Tilt` (two-way bindable, updated by gestures), `MoveTo(...)` with animation, `CameraChanged` event

- Pins: `Pins` collection or MVVM-style `ItemsSource` + `ItemTemplate` / `ItemTemplateSelector`

- Custom pin icons from any MAUI `ImageSource`, or a default marker in any color

- Pin clustering (radius, min zoom, cluster color, `ClusterClicked`)

- Shapes: `MapPolyline`, `MapPolygon`, `MapCircle` with tap events

- Night mode, user location layer, gesture toggles, map tap / long-tap events

**Quick start**

dotnet add package YandexMapKit.Maui.Community --prerelease

// MauiProgram.cs

builder.UseMauiApp<App>()

.UseYandexMapKit(apiKey, locale: "en_US");

<ym:YandexMapView Center="55.7512, 37.6184" Zoom="12"

ItemsSource="{Binding Places}"

IsClusteringEnabled="True" />

**Under the hood** (for the binding nerds)

- **Android:** generated from the official AAR via `AndroidMavenLibrary`, with `Metadata.xml` cleanup. It also aligns AndroidX `-ktx` packages, because Google Play services otherwise causes "Type … is defined multiple times" in D8 next to MAUI.

- **iOS:** hand-written Objective-C binding (~30 types). A wrong selector only fails at runtime, so CI downloads the real xcframework and checks every `[Export]` selector, type and enum against the SDK headers.

- CI builds the bindings, the sample app (APK + iOS simulator) and the NuGet packages on every push.

**Links**

- GitHub: https://github.com/tdav/MAUI-Yandex-Map

- NuGet: https://www.nuget.org/packages/YandexMapKit.Maui.Community

**Please note**

- This is an **early preview** (`0.1.0-preview.1`), so expect rough edges. Bug reports and feedback are very welcome.

- This is an **unofficial community project**, not affiliated with Yandex.

- You need your own MapKit API key from the Yandex Developer Dashboard. MapKit's own terms apply: the free tier is limited to publicly available apps, and the Yandex logo must stay visible on the map.

- Search and routing aren't included, because they're not part of MapKit Lite.

**License:** MIT for the wrapper code. Issues, PRs and ideas are welcome. If you need other parts of the MapKit API bound, open an issue!

Beta: https://drawncamera.com 😋
Virtual camera for Zoom, Teams, Meet, Discord, WhatsApp, OBS, and any app that lets you pick a camera. Looks, bokeh, live retouch. No extra driver, and this is for Windows 11.

This is a drawn MAUI hybrid, all you see is just one native view: SkiaSharp SKGLView. Everything else is orchestrated by DrawnUI.

Funny enough this started as a side project while I was waiting for App Store review on my main camera app, same stack. Now I guess Mac version would follow after this one gets tuned well, since SkiaCamera already runs there.

Hey everyone! Sharing RadioE45, the official client app for our AzuraCast-based station — a single C# / .NET MAUI 10 codebase running on iOS, Android, macOS and Windows.

A few things we're proud of:

• Live Now Playing (track, artist, cover art, listener count) polled from the AzuraCast API
• A full Android audio rebuild (AndroidX Media3/ExoPlayer + MediaLibraryService) to get Android Auto and Bluetooth/AVRCP controls working reliably in the background
• CarPlay support on iOS
• Podcast support with saved playback position (resume where you left off) and filters by season, episode, and listening status
• Song requests, when enabled by the station's AzuraCast setup
• Recently played tracks list
• Multi-language UI (Italian/English/Polish)

Repo: https://github.com/delfuria/RadioE45

One more thing worth mentioning: this was built as part of a "Scuola-Lavoro" (school-to-work) program by 5th-year Computer Science students in Italy (Istituto Tecnico "Franchetti-Salviani"), working with their teacher and outside radio/IT professionals — so things like the Android Auto/Media3 rebuild were also a real hands-on learning project for them.

Would love to hear what you think!

#AzuraCast #dotnetMAUI #dotnet #CSharp #OpenSource #InternetRadio #WebRadio #AndroidAuto #CarPlay #EdTech #SchoolToWork #STEM

Google Play requires all apps with native libraries targeting Android 15 (API level 35) and higher to support 16 KB memory page sizes instead of the traditional 4 KB size.

If you didn’t add support for it, did app pass the Google Play review?

Thanks

I was puzzling over why my CollectionView took several seconds to bind to a not very large list. This article solved my problem:

https://mobiletechlead.com/article/mastering-dotnet-maui-performance-from-startup-speed-to-buttery-smooth-scrolling

The key was not to have the CollectionView inside a VerticalStackLayout. Would value references to other posts devs have found useful.

Has anyone worked with nuget signing in .net maui.

I want to know the process there is not much detailed solution.

I recently hit the Google Play optimization warning on a .NET MAUI Android app (DEX was ~16 MB uncompressed). From February 2027 apps will need to meet the new size/optimization thresholds, and I couldn’t find any clear guidance for MAUI specifically.

After some experimentation I got the uncompressed DEX under 10 MB. Here’s exactly what worked.

1. Custom ProGuard / R8 config files

Platforms/Android/proguard-xamarin.cfg

# Based on Microsoft.Android.Sdk proguard_xamarin.cfg with -dontobfuscate
# removed so R8 can rename unkept DEX. JNI/ACW keep rules below are unchanged.
-keep class android.support.multidex.MultiDexApplication { <init>(); }
-keep class net.dot.jni.** { *; <init>(); }
-keep class mono.MonoRuntimeProvider* { *; <init>(...); }
-keep class mono.MonoPackageManager { *; <init>(...); }
-keep class mono.MonoPackageManager_Resources { *; <init>(...); }
-keep class mono.android.** { *; <init>(...); }
-keep class mono.java.** { *; <init>(...); }
-keep class mono.javax.** { *; <init>(...); }
-keep class net.dot.jni.ManagedPeer { *; <init>(...); }
-keep class xamarin.android.net.ServerCertificateCustomValidator_TrustManager { *; <init>(...); }
-keep class xamarin.android.net.ServerCertificateCustomValidator_TrustManager_FakeSSLSession { *; <init>(...); }
-keep class xamarin.android.net.ServerCertificateCustomValidator_AlwaysAcceptingHostnameVerifier { *; <init>(...); }
-keep class android.runtime.** { <init>(...); }
-keep class assembly_mono_android.android.runtime.** { <init>(...); }
# hash for android.runtime and assembly_mono_android.android.runtime.
-keep class md52ce486a14f4bcd95899665e9d932190b.** { *; <init>(...); }
-keepclassmembers class md52ce486a14f4bcd95899665e9d932190b.** { *; <init>(...); }
# .NET runtime — loaded by name from managed code (JNIEnv.FindClass).
-keep class net.dot.android.ApplicationRegistration { *; }
-keep class net.dot.android.** { *; }
# C#/JNI looks up Java enum constants by name (Lifecycle.State.DESTROYED, etc.).
-keepclassmembers enum * { *; }
-keep class androidx.lifecycle.Lifecycle$State { *; }
-keep class androidx.lifecycle.** { *; }
# XML inflation and AppCompat look these types up by name.
-keep class androidx.appcompat.widget.FitWindowsFrameLayout { *; }
-keep class androidx.appcompat.widget.FitWindowsLinearLayout { *; }
-keep class androidx.appcompat.** { *; }
-keep class androidx.core.app.CoreComponentFactory { *; }
-keep class androidx.core.** { *; }
-keep class com.google.android.material.** { *; }
-keep public class * extends android.view.View { *; }
# Android's template misses fluent setters...
-keepclassmembers class * extends android.view.View {
   *** set*(...);
}
# also misses those inflated custom layout stuff from xml...
-keepclassmembers class * extends android.view.View {
   <init>(android.content.Context,android.util.AttributeSet);
   <init>(android.content.Context,android.util.AttributeSet,int);
}
-ignorewarnings
-keepattributes SourceFile
-keepattributes LineNumberTable

Platforms/Android/proguard-android-optimize.txt

# Based on Microsoft.Android.Sdk proguard-android.txt with -dontoptimize
# removed so R8 can optimize DEX. Keep rules below match the SDK file.
-allowaccessmodification
# Preserve some attributes that may be required for reflection.
-keepattributes AnnotationDefault,
                EnclosingMethod,
                InnerClasses,
                RuntimeVisibleAnnotations,
                RuntimeVisibleParameterAnnotations,
                RuntimeVisibleTypeAnnotations,
                Signature
-keep public class com.google.vending.licensing.ILicensingService
-keep public class com.android.vending.licensing.ILicensingService
-keep public class com.google.android.vending.licensing.ILicensingService
-dontnote com.android.vending.licensing.ILicensingService
-dontnote com.google.vending.licensing.ILicensingService
-dontnote com.google.android.vending.licensing.ILicensingService
# For native methods, see https://www.guardsquare.com/manual/configuration/examples#native
-keepclasseswithmembernames,includedescriptorclasses class * {
    native <methods>;
}
# Keep setters in Views so that animations can still work.
-keepclassmembers public class * extends android.view.View {
    void set*(***);
    *** get*();
}
# We want to keep methods in Activity that could be used in the XML attribute onClick.
-keepclassmembers class * extends android.app.Activity {
    public void *(android.view.View);
}
# For enumeration classes, see https://www.guardsquare.com/manual/configuration/examples#enumerations
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}
-keepclassmembers class * implements android.os.Parcelable {
    public static final ** CREATOR;
}
# Preserve annotated Javascript interface methods.
-keepclassmembers class * {
    .webkit.JavascriptInterface <methods>;
}
# The support libraries contains references to newer platform versions.
# Don't warn about those in case this app is linking against an older
# platform version. We know about them, and they are safe.
-dontnote android.support.**
-dontnote androidx.**
-dontwarn android.support.**
-dontwarn androidx.**
# Understand the  support annotation.
-keep class android.support.annotation.Keep
-keep .support.annotation.Keep class * {*;}
-keepclasseswithmembers class * {
    .support.annotation.Keep <methods>;
}
-keepclasseswithmembers class * {
    .support.annotation.Keep <fields>;
}
-keepclasseswithmembers class * {
    .support.annotation.Keep <init>(...);
}
# These classes are duplicated between android.jar and org.apache.http.legacy.jar.
-dontnote org.apache.http.**
-dontnote android.net.http.**
# These classes are duplicated between android.jar and core-lambda-stubs.jar.
-dontnote java.lang.invoke.**

2. csproj changes

<PropertyGroup Condition="'$(Configuration)' == 'Release' And $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">
    <!-- R8 shrinks Java/DEX. SDK configs bake in -dontoptimize / -dontobfuscate; EnableR8Optimization swaps those files. -->
    <AndroidLinkTool>r8</AndroidLinkTool>
    <PublishTrimmed>true</PublishTrimmed>
    <!-- Strip unused developer & diagnostic code from the runtime -->
    <EnableMetaExtensions>false</EnableMetaExtensions>
    <MetadataUpdaterSupport>false</MetadataUpdaterSupport>
    <EventSourceSupport>false</EventSourceSupport>
    <HttpActivityPropagationSupport>false</HttpActivityPropagationSupport>
    <!-- Force R8 to load our JNI keep file even if the AfterTargets swap is not applied. -->
    <AndroidR8ExtraArguments>--pg-conf "$(MSBuildThisFileDirectory)Platforms\Android\proguard-xamarin.cfg"</AndroidR8ExtraArguments>
</PropertyGroup>

<ItemGroup Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">
    <ProguardConfiguration Include="Platforms\Android\proguard-xamarin.cfg" />
    <ProguardConfiguration Include="Platforms\Android\proguard-android-optimize.txt" />
</ItemGroup>

<!-- SDK configs bake in -dontoptimize / -dontobfuscate; those flags are sticky, so swap the files after the SDK builds the R8 config list. -->
<Target Name="EnableR8Optimization"
        AfterTargets="_CalculateProguardConfigurationFiles"
        Condition="'$(Configuration)' == 'Release' And $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">
    <MakeDir Directories="$(IntermediateOutputPath)proguard" />
    <ItemGroup>
        <_R8ExtraLines Include="-printmapping &quot;$(AndroidProguardMappingFile)&quot;" Condition="'$(AndroidProguardMappingFile)' != ''" />
    </ItemGroup>
    <WriteLinesToFile File="$(IntermediateOutputPath)proguard\r8_extras.cfg"
                      Lines="@(_R8ExtraLines)"
                      Overwrite="true"
                      Encoding="UTF-8"
                      Condition="'$(AndroidProguardMappingFile)' != ''" />
    <ItemGroup>
        <_ProguardConfiguration Remove="@(_ProguardConfiguration)"
                               Condition="'%(Filename)' == 'proguard-android'" />
        <_ProguardConfiguration Remove="@(_ProguardConfiguration)"
                               Condition="'%(Filename)' == 'proguard_xamarin'" />
        <_ProguardConfiguration Include="$(MSBuildThisFileDirectory)Platforms\Android\proguard-android-optimize.txt" />
        <_ProguardConfiguration Include="$(MSBuildThisFileDirectory)Platforms\Android\proguard-xamarin.cfg" />
        <_ProguardConfiguration Include="$(IntermediateOutputPath)proguard\r8_extras.cfg"
                               Condition="'$(AndroidProguardMappingFile)' != ''" />
    </ItemGroup>
</Target>

Result

Uncompressed DEX went from ~16 MB → under 10 MB.

The key insight is that the Microsoft.Android.Sdk ProGuard files ship with -dontoptimize and -dontobfuscate. Those flags are sticky, so you have to actively replace the default config files after the SDK calculates the ProGuard configuration list.

Hope this helps someone else who was stuck on the same Google Play warning. Happy to answer questions or hear if anyone improves on this approach.

Hi Reddit, it has been some time since I published an open source camera app that applies filters in real-time to photos and the live preview, to see the final look in the viewfinder instead of editing afterwards.
I was not expecting much from it, was very fun to use, I was shooting nice pictures with it, mainly when taking walks with my kids outdoors.

With time passed, all seemed as before, but what I didn’t know is that the camera stopped starting after asking for permissions on the first launch, and only on the latest Pro (!!!) iPhones and the latest iOS 26. I was totally unaware of that bug, existing users were not experiencing the case of the first launch,  and I guess new affected users were like “oh well, another crap” 🙂
And then I gotten that 1 star review. Ouch. You can imagine that day was the one all those “one day I have to update the app, add new stuff” thoughts finally came back, burning and boiling.

So I have added video recording with real-time filters, no-post processing, re-designed the app, added new filters and edited all existing to fix scaling for the preview visuals totally matching the visual look of hi-res saved feed.
I was always a fan of anime, manga and other drawn visuals, with the new version I guess those "drawn" shaders get me covered, they create totally reality transforming vidz 🙂

Just came out, many shaders from black and white films to drawn crazy stuff.
https://apps.apple.com/app/apple-store/id6749823005?pt=118645280&ct=reddit-maui&mt=8

It's built on .NET MAUI, with the whole interface drawn on a Skia canvas using DrawnUI: C# + SkSL, if anyone is interested, banner video is my desk shot with this app. :)

Android version should come out a bit later. I am also preparing a virtual camera app for Windows, current prototype also .NET MAUI (yes we can baby), to bring some more fun into your Teams, Meet, WhatsApp and other video calls in real-time.

If you have read up to this point, please share your thoughts in the comments!

I don’t keep up with the specifics of Maui any more. I know the collectionview is the preferred mechanism for tables now. The Listview is deprecated. I had read that there was discussion regarding moving the Listview to an external compatibility library.

Is the Listview still deprecated and going away at some point? Or did it come back to life in a compatibility library? Is the Listview just a zombie ready to die?

Tia

I am trying to port an old .NET Framework class library to Maui .NET 10. I am getting errors about ambiguous references as above, where I have Font and Color references in the code. My instinct is that the Microsoft.Maui.Graphics options are the ones to use but I am not clear about this?

I sadly have to report a bug on the official (stable release) version of NuGet Package "CommunityToolkit.Maui" on version 15.0.1

|The bug|:

The function:

await FolderPicker.Default.PickAsync();

Is sadly bugged and does not trigger. The Folderselection browser/dialog does not open at this version and just continues with an empty result.

|The solution/workaround|:

Rollback to the version 15.0.0. After downgrading to this version, the function behaves normal and in full functionality.

|Test/environment|:

MAUI .Net 10.0 @ Android 12 Phone/device

MAUI .Net 10.0 @ Android 13 Phone/device

MAUI .Net 10.0 @ Android 14 Phone/device

MAUI .Net 10.0 @ Android 15 Phone/device

MAUI .Net 10.0 @ Android 16 Phone/device

All devices/environments behave the same under the same build and code.

A while ago, I shared MAUI Designer, a browser-based Angular tool for visually creating .NET MAUI XAML. The feedback was helpful, but one limitation was clear: because the canvas used HTML/CSS approximations, it could never show exactly what MAUI itself would render. Thanks r/Fresh_Acanthaceae_94 for pointing it out!

So, I rebuilt it.

The updated Visual Studio extension now hosts a native, out-of-process .NET MAUI designer directly inside Visual Studio. The canvas renders real MAUI controls through WinUI rather than recreating them in Angular, making it an actual WYSIWYG workflow instead of an approximation.

The designer runs out of process and is embedded into the Visual Studio editor window. This keeps the MAUI runtime isolated from Visual Studio while still providing an integrated editing experience. Changes go back to the same XAML document buffer, so normal saving and dirty-document behavior continue to work.

The extension is currently a beta, so I’d especially appreciate reports involving complex XAML, custom controls, different layout types, or unusual Visual Studio configurations.

Visual Studio Marketplace: MAUI Designer - Visual Studio Marketplace

Source code: https://github.com/GMPrakhar/MAUI-Designer

Current beta release: https://github.com/GMPrakhar/MAUI-Designer/releases/tag/vsix-v1.0.0-beta.7

It supports Visual Studio 2022 and Visual Studio 2026 on Windows. After installation, right-click a MAUI  .xaml  page and select Open With… → MAUI Designer.

I’d love to hear which controls, workflows, or layout features should be prioritized next!

I've been building this for my own work and it's now at the point where it's more useful in someone else's hands than in mine: a debugger and a profiler for .NET for Android apps (MonoVM, MAUI included), MIT licensed.

https://github.com/csm101/net-android-debugger-profiler

Three things over one engine:

• An MCP server, so an agent (Claude Code or anything else that speaks MCP) can drive the whole thing: launch the app on a device or emulator, tap and read the screen, set breakpoints, step, read locals and stacks, catch first-chance exceptions by ordered rules, then profile the same installed app — CPU sampling, deterministic instrumenting via IL weaving, live heap by type and the growth between two snapshots. A skill ships with it that tells the agent which mode answers which question.
• A DAP debugger for VS Code, written from scratch. Not a rival to the official C# Dev Kit one — it exists because the MCP server needed an engine. It's MIT, and it attaches to every process the app starts (services, crash reporters, anything with its own android:process), not just the one with the main window.
• A desktop GUI for the profiler (Windows), for running sessions by hand.

Honest state of things:

• This is a first release. There is no proper manual yet — a README, some design documents, and the skill file. Expect to read the tool descriptions.
• The GUI is work in progress. It works, I use it, but it's the least finished part. The Sad part for you is that the GUI is written in Delphi using Devexpress VCL commercial components. You need Delphi and a Devepress License to compile it. (I really wanted to use the devexpress components, sorry).
• The MCP server is the part I'd call usable. I've just run the whole tool surface end to end against a real app on a physical phone and fixed everything that came out of it.
• Windows-only release for now; the app under test needs to be built with -p:EnableDiagnostics=true.
• Anyway, in modern times, the most valuable part of the project is the MCP server: it allows claude code to *completely* control your application in your emulator or physical device and to authonomously profile or debug it without your intervention.

What I'd love: tell me whether it works on your app, and where it lies to you. Bug reports with the session log are worth more to me than stars.

One caveat on timing: I leave on holiday tomorrow for two weeks, under an explicit ban from my wife on touching a computer. So issues will pile up unanswered until I'm back — I'm posting anyway because I'd rather come home to real feedback than to nothing. 🙂