Introducing XAML.io v0.9: Build .NET Apps From a Prompt, in Your Browser

Mon, 21 Sep 2026 15:30:00 +0200

Prompt-to-app builders have changed how a lot of software gets started. You open a browser, describe what you want, and a few minutes later something is running. But most of these tools generate React and TypeScript. If your team’s skills, libraries, and existing applications are in .NET, you end up with a prototype in a stack you don’t maintain.

Today we’re releasing XAML.io v0.9, which brings that starting point to C# and XAML. You describe an application, and an AI agent writes it, compiles it, reads the compiler errors, and fixes them until it runs. You get a standard .NET solution. You can keep changing it with the agent, by editing the code, or in the visual designer. When it’s ready, publish it to the Web in one click or open it in Visual Studio.

New to XAML.io? XAML.io is a free, browser-based IDE for building .NET apps with C# and XAML: a drag-and-drop designer with 100+ controls, a code editor, and in-browser .NET compilation via WebAssembly. No install, no signup. Built by Userware, powered by open-source OpenSilver. Try it →

What’s new in v0.9

An AI coding agent that works across the whole C#/XAML solution. It creates and edits files, builds, reads diagnostics, and fixes errors.
Diff review and Version History, so you can see exactly what changed and go back to any checkpoint.
One-click Web publishing to a hosted xaml.cloud URL.
Model choice and per-request cost, shown in dollars.
AI-assisted WPF migration for the cases our deterministic tooling can’t handle alone.
Free AI usage on every account (up to $5 a month), and XAML.io Pro at $20 per month with $20 of AI usage included.

One prompt: Paint, as it looked in Windows 98

A to-do list wouldn’t tell you much, so we picked something harder. We opened a blank project and typed one sentence:

Build a Paint clone as it appeared in Windows 98.

Then we left it alone. The agent created the C# and XAML files and implemented the UI and the drawing behavior. It compiled the project, hit errors, fixed them, and kept going. Nobody sent a follow-up prompt or touched the code during the run.

The agent worked for 42 minutes and produced about 3,500 lines of C# and XAML.

An edited overview of the run and the finished application.

Paint is a harder test than it looks. Pointer input, drawing tools, selections, colors, menus, dialogs, and application state all have to work together. A bug in any of them is visible as soon as you pick up the pencil.

We used GPT-6 Astra at High reasoning effort, the most capable setting XAML.io offers today, because we wanted to see how far a single request could go. That makes it a stress test rather than a typical request, and we’ll come back to what it cost. Like any AI output, a second run of the same prompt would produce a different application.

You can check the result yourself. No account is needed:

Open the Paint project →

Click Run, draw something, try the tools and menus, then open the source the agent wrote.

Then change it

You can make any change to the application in three ways. You can describe it to the agent, edit the C# and XAML yourself, or adjust the UI in the visual designer. All three work on the same files, so nothing needs to be synced or exported between them, and you can switch whenever the task changes. The best choice depends on the change:

Describe it when the change is an outcome that spans many files. “Add a gradient fill tool” means a new toolbox button, an icon, the drawing logic, and a way to pick the two colors. The agent can work through all of that and build the result.
Edit the code when you know exactly what to change. To make the airbrush spray more densely, opening the C# and changing it yourself is often faster than explaining it.
Use the designer for precise UI work. If the toolbox needs more spacing or the color palette should be larger, select it and adjust it directly.

We don’t think every software change should become a conversation with an AI. The point is to use whichever tool fits the change in front of you.

See exactly what the agent changed

When the agent finishes, you can review a diff of every file it touched.

Version History keeps checkpoints as the project evolves. You can compare versions, go back, or try a different approach without losing the one you like.

This matters most for large changes. A successful build tells you the code compiles. It doesn’t tell you the application behaves correctly. Review the diff, run the app, and then decide.

Publish, and send someone a link

When the application is ready for someone else, click Publish. XAML.io builds it and hosts it at a xaml.cloud URL.

The person you send the link to gets the running application, not the IDE. Sharing a project is still there for when you want someone to read or fork the source. Publishing is for when you want them to use the app. That makes the loop short:

Build → run → publish → get feedback → change → publish again.

One-click hosting has been on our roadmap since v0.6, and it’s here now. If you’d rather host the app yourself, you can still download the static Web build and put it on any server.

The same Publish menu also produces desktop apps for Windows, macOS, and Linux, which we added in v0.7. Your C# runs as native .NET. The UI is rendered by a WebView, so the app looks consistent on all three platforms. (How it works →)

It’s still a .NET project

We want XAML.io to make the start easier without creating a separate world you’d have to leave later.

The agent writes C# and XAML. The XAML follows WPF syntax, so if you’ve built WPF applications, you can read and change what the agent writes. Projects can use compatible NuGet packages, and the visual designer edits the same XAML files. For everyday edit-build-run cycles, Roslyn compiles your C# inside the browser via WebAssembly, with no server involved.

When you want to continue elsewhere, download the project as a standard .NET 10 solution. You can open it in Visual Studio, VS Code, or Rider and use your usual source control, debugging, testing, and CI/CD. Or you can keep working in XAML.io.

All of this runs on OpenSilver, our MIT-licensed open-source C#/XAML framework. The runtime your application depends on isn’t locked inside our product.

What runs where

XAML.io has always kept compilation local, so it’s worth being precise about what changes with AI.

Editing, compiling, and running your project still happen in your browser. That includes the WPF compatibility analyzer and source import. Agent tasks are different: they can run for a long time and chain many edits, builds, and fixes. So they run in a temporary, isolated cloud environment. When you use the agent, the project files it needs are sent to that environment and to the AI model provider you selected.

AI is opt-in. If you don’t use it, your code stays where it was. Your code is never used to train any AI model.

What about the WPF applications you already have?

Starting a new application from a prompt is one side of the story. The other side is the large amount of .NET software that already exists in WPF.

XAML.io v0.8 introduced Migrate from WPF, which pairs a compatibility analyzer with deterministic transformations for migration patterns we know how to handle reliably. In that post we said the tooling doesn’t rewrite your code with AI. That principle hasn’t changed: we don’t regenerate working code. What v0.9 adds is help with the cases that need context rather than a rule.

Say an application uses a desktop functionality that has no browser equivalent. The agent can look at how the API is used and read the surrounding code. It can then make targeted changes across the affected files, rebuild, and keep working through the diagnostics. The deterministic fixes still run first, and the agent handles what’s left. Every edit it makes shows up in the same diff and Version History as any other change.

Family.Show shows the foundation underneath. It’s the WPF reference application Vertigo built for Microsoft, and our Web migration keeps 97% of the original C# and XAML unchanged.

Run Family.Show →

Inspect the migrated source →

We migrated Family.Show before the agent existed, so it isn’t an AI demo. It shows the migration layer the agent now builds on. That layer comes from our team’s more than 13 years of experience migrating customer applications, with over 10 million lines of production front-end C# and XAML migrated.

The approach is simple. Use deterministic transformations where a known migration works reliably, and use AI where the problem requires understanding the rest of the application.

Choose the model. See the cost.

A one-line fix and a 3,500-line application are very different AI workloads. XAML.io lets you choose among supported models and, where available, reasoning levels. Every request shows the model, the token usage, and its actual cost in dollars.

The Paint run sits at the far end of that range: our most capable model, at a high reasoning setting, working for 42 minutes. It cost about $57. Adding a significant new feature using the most capable model, such as adding the gradient fill tool in the Paint app, costs $1-$5, and a small edit can cost just a few cents.

We don’t convert AI usage into an internal currency. If one request costs a few cents and another costs several dollars, you see the difference directly, and you can pick a smaller model for smaller jobs.

Free accounts include up to $5 of AI usage per month, with at most $3 in a single day. XAML.io Pro costs $20 per month and includes $20 of AI usage every month, plus access to the frontier models. If your usage runs out partway through a task, the agent pauses and the code it has written so far is synced to your project, so nothing is lost. Once you top up, you can resume the task whenever you like.

Limitations

v0.9 is still part of our Preview series, and we want to be upfront about its limits:

Review the agent’s work as you would a teammate’s pull request. The agent builds its own code and fixes what the compiler catches. But like any developer, it can make mistakes a compiler won’t flag. The diff view makes that review quick, and running and testing the app is still the final check before you ship.
Results vary. The same prompt produces a different app on a different run. Large requests on top-tier models can cost tens of dollars.
Front end only, for now. Applications can already call existing APIs and services. A built-in database with user authentication is coming soon (see below).
Web apps run in the browser sandbox. Things a browser can’t do, such as Win32 calls, P/Invoke, or unrestricted file system access, need the desktop build or a different approach.

What’s next

The next step is data. In Q4 2026, we plan to add a built-in PostgreSQL database and user authentication. The agent will be able to create and update the database as it builds your app. That means you’ll be able to go from a prompt to a multi-user application that stores its data and knows who is signed in, then publish it the way you publish today.

You can already see the shape of the product in v0.9. You start with a prompt in the browser. You keep working with AI, visual design, or code. Then you publish to the Web, ship to the desktop, or move into Visual Studio and the rest of .NET.

Try XAML.io v0.9

XAML.io v0.9 is available today at xaml.io. The editor, visual designer, NuGet package manager, compiler, and runtime work without an account. A free account adds cloud saving, sharing, Web publishing, and AI.

If you want something concrete to start with, open Paint: