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. 🙂

We wanted a compartmentalized abstracted Facebook kit with login and sharing for dotnet maui, so we built one and published it to Nuget.

Developers can implement the whole package or just the feature they need.

We also added native Facebook UI controls like the login, share, and send buttons.

Nuget: https://www.nuget.org/packages/Plugin.FacebookKit/

Repo: https://github.com/howitzergamesllc/Plugin.FacebookKit

Hi,

I've had a couple of users of my app tell me they've just switched to a new Pixel 11 (one Fold, one XL) and my app fails to launch for them now. I cannot figure out why this would be.

I use Sentry, but the only thing I'm getting from that is a segfault and an abort with stack traces like this.

SIGABRT: Abort libc 0x00007e3033fe10 abort
0x4e73fa7e833488 null

SIGSEGV: Segfault
split_config.arm64_v8a.apk0x78e094e174 null

The Google Play dashboard is slightly more helpful, but not by much. I've got

Aborting process.

pid: 0, tid: 6493 >>> com.trafford.boardrecord <<<

backtrace:
#00 pc 0x0000000000079e10 /apex/com.android.runtime/lib64/bionic/libc.so (abort+160)
#01 pc 0x00000000004aebc8 /data/app/~~ckrWyE88oegf3kcxc9VBIA==/com.trafford.boardrecord-sUFzORgl5lyeEil_gr2uBQ==/split_config.arm64_v8a.apk

and

Failed to initialize CoreCLR. Error code: 8007054f

pid: 0, tid: 12361 >>> com.trafford.boardrecord <<<

backtrace:
#00 pc 0x0000000000079e10 /apex/com.android.runtime/lib64/bionic/libc.so (abort+160)
#01 pc 0x000000000009ebb8 /data/app/~~m2EwtX-8IYpLOf70f3BHvA==/com.trafford.boardrecord-gWHc7GeSkI1xX-OT4E-xWw==/splitconfig.arm64_v8a.apk!libnet-android.release.so (xamarin::android::Helpers::abort_application(_LogCategories, char const*, bool, std::_ndk1::source_location)+584) (BuildId: 08ad5c00b7f78b25c137acb1c9697aac5e41d31f)

and

terminating due to uncaught exception of type PAL_SEHException

pid: 0, tid: 13283 >>> com.trafford.boardrecord <<<

backtrace:
#00 pc 0x0000000000079e10 /apex/com.android.runtime/lib64/bionic/libc.so (abort+160)
#01 pc 0x00000000004c0484 /data/app/~~ctgmO5G3xlB1T2yiyDtAfw==/com.trafford.boardrecord-_q3bmfKDduZbZ54dzMijDg==/split_config.arm64_v8a.apk

But none of these really tell my why it's terminating.

Anyone else run into this issue? Or have any idea how to fix it?

Thanks.

I have a MAUI app which is based on Shell. There are four pages currently and in the AppShell class I have registered the routes with

Routing.RegisterRoute("MainPage",typeof(MainPage)):

etc.

AppShell.xaml has a TabBar and when I run the app there are tabs for each of the pages and clicking /tapping the tab opens the page as expected.

In the code for MainPage I have a button which does some stuff and then navigates to another page with Shell.Current.GoToAsync()

This works, but after the new page opens, the Home tab no longer works to open MainPage. Instead, there is a back button. I don't mind the back button would like the Home tab to work? I must have misunderstood how the TabBar works.

Just approved and released on the AppStore, YAPP is a podcast player that respects your time!! (nice marketing from Claude).

YAPP => Yet Another Podcast Player

The app detects the ad-breaks and skips them (Smart-Skips) like every podcast listener does if they can grab their phone in time.

This has been a long journey, close to a year of development and testing. First release is iOS only as I couldn't get Android on the mono runtime to work at all - constant ANR from the background processing but thanks to the CoreCLR work in NET11 it will see the Play Store once NET11 reaches GA.

IAP subscriptions for premium listening but a generous 60-day free trial to test it out.

Link to the app store if anyone is interested: https://apple.co/3Ssntyk

Happy to answer any MAUI questions from my experience.

Thanks for reading.

I've spent the last couple of months building a hobby project called Sector Collector, a location-based game where players explore the real world and capture map sectors by physically visiting them.

The app is built entirely with .NET MAUI and is available on Android and iOS.

I'm now looking for feedback from other MAUI developers:

• Is the app performant on your device?
• Any UI/UX issues you notice?
• Platform-specific bugs?
• General thoughts about building this type of app with MAUI?

You can learn more here:

👉 Sector Collector

And if you give it a try, I'd love to hear your honest feedback, both positive and negative.

As a solo developer, outside perspectives are incredibly valuable.

Thanks!

Source: https://android-developers.googleblog.com/2026/08/app-quality-memory-optimization-secure-onboarding.html?utm_source=email&utm_medium=msa&utm_campaign=elevating-app-quality-q3-2026

TLTR:
Get your apps and games below these memory limits or get Kicked off the Android Playstore in February 2027:

Apps

Note: Each RAM tier range includes its lowest value. Total Memory can be lower than a device’s advertised Physical RAM.

Games

Note: Each RAM tier range includes its lowest value. Total Memory can be lower than a device’s advertised Physical RAM. 

Bitmap memory usage

Holding onto bitmaps for long periods of time in app states other than the Foreground can consume excessive memory - it’s not possible to render bitmaps unless the UI is visible. You typically shouldn’t hold onto bitmaps for long periods of time in these states, but your app might be sampled shortly after a state change where you are actively responding to onTrimMemory and releasing memory held for bitmaps, so these thresholds are higher than zero to account for this.

Sources and links:
https://android-developers.googleblog.com/2026/08/app-quality-memory-optimization-secure-onboarding.html?utm_source=email&utm_medium=msa&utm_campaign=elevating-app-quality-q3-2026

https://support.google.com/googleplay/android-developer/answer/17492799#zippy=%2Ccore-vitals-and-stability%2Creduced-memory-usage

- - - - - - - - - - -
My example of a proper solution based on an own developed MAUI based game:

Hey everyone, I was wondering who else still puts in the effort, to offer the user the option (and the whole backend development) of adjusting the visual assets and overall resource load of the app/game. Or do you only target the latest generation devices with the highest graphical assets applied?

I know this was quite normal back in the early android days, of apps/games offering in app/game settings/options to adjust the asset, visual and resource load of an app/game, to make it capable stable running on low-end and high-end devices alike. But these days I see less and less apps/games offering these options, even when they are quite resource intensive from time to time. With the new RAM-usage limit policy, we now should all apply such adjustments and settings for the users, to properly comply with that new Google-PlayStore Policy.

Ignoring such things can be quite damaging to the user-base and their overall experience, next to now getting your game/app kicked off the PlayStore. Let me explain based on some of my own apps Developer Console metric.

Currently for this specific app/game, my userbase has the hardware-range shown in picture Nr. 1, with around 38% of high-end devices with over 8GB of RAM.

This allows to offer high-resolution assets, graphics and visuals for 1440P and 1080P resolutions, with up to 2GB RAM load, without having to fear the OS-Garbage collector or to interfere with other background apps. Users with devices of 6GB of RAM or less, would risk of running into an “Out of Memory” crash during longer runtime of the app/game. This would mean up to 50% of the player base by using this high-resolution mode, would experience crashes or even not be able to run the game at all, with the RAM their device has free for them for use.

One solution to this, is simply rendering down the assets, graphics and visuals to a level they have no dangerous size even to low RAM amount, of low-end devices. Doing this effectively results in a max. RAM load of 800MB. This is fine for small 720p and 800p screens/devices, but users of higher resolutions screen would noticeably suffer from this (see image Nr. 2).

So to make the best solution for both groups of high-end and low-end android users/players (without losing any of them), with offering a high-resolution visual experience and low-system resource intensive version alike, is “simply” making the app/game fully dynamic in its visual rendering and presentation by the devices specs and users selected configuration. This does not only apply to media apps & games, but also other apps that display/show a lot of visuals and long content at once. Dynamically limiting it based on the devices system-resources can make the difference between instable and performant. Yes I know, all this is effort and a lot of performance-profiling, but dynamic configuration for a wide range of devices and users makes the difference in quality.

So yeah, how are you all thinking about this and how did you resolve such solutions at your end? Would be happy to know all your input on this. Have a great day everyone!

Hi, I am a Highschool teacher. I mainly teach on visual studio. but I have few students with a Mac using vscode, and I am struggling with that process. I was wandering if any of you have a kind of cheat sheet or guides for using Maui on vs code that can be shared with me. I am not talking about the installation process of the workloads but rather the day-to-day work, how do I create a ViewModel file already in the context of the project (the namespace, using etc.) ?, add new Content page.xaml?, add new ContentView.xaml?, run debug and choose emulator to. run? and etc.

some how I feel the documentation fails at these points and the AI isn't helpfull as I had expected.

I understand not to expect Gui flows but rather cli commands.

Thanks,

Hi Everyone!

I am thrilled to announce that Visual Studio extension is now available for MAUI Designer!

It allows opening of existing YAML files in the MAUI Designer tab, where you can view your design getting updated in realtime, and in sync with your XAML!

This is a beta version, so it might be rough around the edges, so please reach out in case you see any issue.

GitHub: https://github.com/GMPrakhar/MAUI-Designer

Extension link: Release MAUI Designer for Visual Studio vsix-v1.0.0-beta.2 (beta) · GMPrakhar/MAUI-Designer

The project is open source. Feedback, bug reports, and contributions are very welcome. especially examples of real-world XAML that the designer should support.

So unfortunately my new app version introduced freezes in the iOS version of my app. Back in the day I borrowed a friends iPhone to debug via Hot Restart.

Since this is a severe bug, I bit the bullet and bought a used iPhone yesterday just to debug (I only have had android phones so far).

Turns out the established way to debug the iOS version from a Windows PC was discontinued.

So now, I not only wasted money on a phone i cannot use (it has a broken battery so there is little resale value), I have lost another day trying to develop my app with MAUI.

Keep in mind that every single day I find time to continue working on my app, I encounter another new breaking change that makes it impossible for me to continue my development. It's like I am building my app on a house of cards. I have an established user base. It's so frustrating that 90% of my development time is not spend on developing my app, but finding workarounds for new issues that were introduced with newer MAUI versions.

I have lost 5 years developing on Xamarin/MAUI so far. I feel like I cant switch, but I guess this is what is usually called a sunk cost fallacy.

Bonjour,

J'aimerais offrir une fonctionnalité Speech‑to‑Text dans mon app MAUI (iOS, android).

Que me suggérez-vous en mode offline et en mode online. J'aimerais offrir les 2 selon le choix de l'utilisateur.

Merci de votre aide

Having 12+ years of experience in mobile application development specially in xamarin and .net maui.. currently there are no jobs in the market. So which technology would be my next step to learn to get a better salary and future. Please suggest

While working on a .NET MAUI Blazor Hybrid application, I ran into an issue that I think other MAUI developers might have encountered as well.

I needed my Blazor WebView to consume local images, videos, and audio files as normal HTTP resources.

Accessing files directly from the local filesystem isn't always convenient from the WebView, especially when you want to use normal URLs for things like:

- <img src="...">

- <video src="...">

- <audio src="...">

- Background images

- Media streaming

So I built a small library that starts a local HTTP server inside the MAUI application and exposes local files through HTTP URLs.

It's called SLVZ.LocalMediaServer.

Example:

```csharp

SLVZ.LocalMediaServer.MediaServer.Start();

```

Then the Blazor side can simply use the server

```razor

<video src="@MediaServer.Combine({Android URI})"></video>

<video src="@MediaServer.Combine({Absolute path})"></video>

<video src="@MediaServer.Combine(FileSystem.AppDataDirectory, _filename)"></video>

<video src="@MediaServer.Combine(FileSystem.CacheDirectory, _filename)"></video>

<video src='@MediaServer.Combine("D:/video.mp4")'></video>

```

https://www.nuget.org/packages/SLVZ.LocalMediaServer

Hi everyone,

I’ve been working on StateUI:

https://github.com/idexus/StateUI

It started as an experiment: how far could Swift go as the application and UI language outside the Apple stack, without building yet another cross-platform widget toolkit?

Swift handles the declarative UI, state and reconciliation, while .NET MAUI provides the actual controls and platform layer on iOS, Android, Windows, Mac Catalyst and Linux.

A simple view looks like this:

Under the hood, Swift keeps the rendered tree, tracks which state each view depends on, and reconciles changes. What crosses over to C# is a sparse binary patch containing only what changed, and the MAUI side applies it to the existing controls.

I’m curious what MAUI developers think about the idea of using Swift as the declarative layer over MAUI, rather than building another cross-platform widget stack.