Modernise a WinForms or WPF app
Keep the business logic of the old forms and put a new, drawn UI on top of it — from the inside out: first the data grid, then a panel, then the shell. No rewrite, no switch to the web, and the application ships the whole time.
Why and for whom, in short: Modernise.
Preview A guide, not a product. Everything in the code below exists in 0.1.0-preview.1 and is part of ArionUI Core; the repository has a sample that walks one form through all three steps (below).
Inside out
ArionUI goes into an existing window as ordinary controls: ArionGridControl and ArionControlSurface on WinForms, ArionGrid and ArionControlSurface on WPF. Each replaces one piece of the old window, and the old code around it keeps running. The reverse does not work: an old native control cannot go inside an ArionUI board. So the order is fixed:
- The data grid. The piece that usually hurts first — slow with many rows, dated, hard to style. Swapping it touches one panel and a handful of event handlers.
- A panel. A figures panel, a filter bar, a detail form becomes a board. It reads the old state and calls the old methods.
- The shell. Side bar, header and status line become ArionUI; the old forms keep their place next to them until they are replaced too.
Form with docked panels — every visible part is an ArionControlSurface or an ArionGridControl. Screenshot of the running app (0.1.0-preview.1).Pilot · free during the preview
We modernise one of your forms together with you
You have a WinForms or WPF application whose forms sit on a DataGridView, a DataTable or a BindingSource. Pick one form that hurts. We take it through the first steps with your developers — the grid on your own data, then a panel — and the code stays yours.
- Free of charge during the preview. In return we learn where the path is still rough, and that goes into the next preview.
- A limited number of pilots. We answer every request and say honestly whether it fits.
- What it needs: one representative form, a developer on your side, and an application on .NET 10 or a plan to get there.
Ask for a pilot office@arionui.com — two lines on what the form does and what it runs on are enough.
What a pilot involves → who it is for, what we do together, what you give and get, and its limits.
Before you start
- .NET 10. The hosts target
net10.0-windows(WPF) andnet10.0-windows10.0.19041(WinForms). An application on .NET Framework has to move to .NET first; that is a step of its own. - The packages.
dotnet add package ArionUI.Rendering.WinForms --prereleaseorArionUI.Rendering.Wpf; for DataTable and DataView alsoArionUI.Data(the WinForms host brings it along). See Install. - Name clashes. WinForms and WPF have their own
Button,Label,TextBox. Alias ArionUI's controls (using Drawn = ArionUI.Presentation.Controls;) or build boards in files of their own.
Path A: swap the grid, keep the DataTable
A WinForms form with a DataGridView on a BindingSource over a DataTable. The table stays, the binding source stays, the handlers stay; one control changes.
using ArionUI.Presentation; // ArionTheme
using ArionUI.Rendering.WinForms; // ArionGridControl, LinkPosition, ArionTheme.FromSystem()
var orders = new BindingSource { DataSource = ordersTable }; // the form's BindingSource stays
// before: panelOrders.Controls.Add(new DataGridView { Dock = DockStyle.Fill, DataSource = orders });
var grid = new ArionGridControl
{
Dock = DockStyle.Fill,
DataSource = orders, // a DataTable, a DataView, a list of objects or a BindingSource over one
VisualTheme = ArionTheme.FromSystem(), // the window's colours and font
};
panelOrders.Controls.Add(grid);
// The old handlers stay. Only the event they hang on changes.
grid.Api.Events.RowActivated += item => OpenOrder((DataRowView)item);
grid.Api.CommandInputs.EditRefused += reason => toolStripStatus.Text = reason;What DataSource does, as on a DataGridView:
- Columns from the schema. One column per
DataColumn, typed from itsDataType— check box, number in the column's own type (adecimalnever passes throughdouble), date, text — with the caption, keyed by the column name, editable unless the column is read-only. A column added to or removed from the table rebuilds them. - Live rows. Rows the table gains or loses, and changed values, appear by themselves; a changed value repaints its cell. Sort and filter in the grid, not on the view.
- The table's rules. A number the type cannot hold, an empty value where nulls are not allowed, a text over
MaxLength, a duplicate key and what aColumnChanginghandler rejects are refused before the write; nothing the table throws reaches the form. The reason comes throughEditRefused; cells with a column error are framed. - The binding source's position. The grid's current row and
BindingSource.Positionfollow each other, by row and not by index, so a grid that sorts on its own still lands on the right row. The old text boxes and aBindingNavigatoron the same source keep working.
A form that binds business objects instead of a table swaps the grid the same way. A BindingList<T> or a List<T>, directly or through a BindingSource, shows a column per public property of the item type. A BindingList<T> reports added, removed and replaced items, and changed properties of items that raise INotifyPropertyChanged. A List<T> reports nothing, as on a DataGridView: change it through the binding source, or call ResetBindings after changing it. The columns are made by reflection at run time, so this way is not safe for trimming or native AOT.
var orders = new BindingList<Order>(); // or a List<Order> through a BindingSource
var grid = new ArionGridControl
{
Dock = DockStyle.Fill,
DataSource = orders, // a column per public property of Order
};
panelOrders.Controls.Add(grid);
orders.Add(new Order { Number = "A-1001", Total = 240m }); // appears by itselfWith a view of your own — your own columns, a card view — grid.Api.LinkPosition(orders) keeps the position link:
IDisposable link = grid.Api.LinkPosition(orders); // the grid shows the same rows, with a view of your ownThe same table on WPF or Avalonia
BindingSource is WinForms; the rest lives in the Core package ArionUI.Data and works in any host:
using ArionUI.Core; // Column (Column.FromDataTable comes from ArionUI.Data)
using ArionUI.Data; // DataTableItemsSource, DataErrorEditPolicy
using ArionUI.Presentation; // GridView
var view = new GridView<DataRowView>(
Column.FromDataTable(ordersTable), // one typed column per DataColumn, keyed by its name
new DataTableItemsSource(ordersTable)) // rows added, deleted and changed appear by themselves
.AsDataGrid();
grid.MainView = view;
grid.EditPolicy = new DataErrorEditPolicy(view); // the table's own rules refuse a wrong valueBy default the policy tries a value on the row first and refuses it when the table reports an error (DataErrorMode.Veto); the old value stays. DataErrorMode.Show writes it and frames the cell until the row reports the error gone:
grid.EditPolicy = new DataErrorEditPolicy(view) { Mode = DataErrorMode.Show }; // write, then frame the cellRows that are view models rather than DataRows report their errors through IDataErrorInfo or INotifyDataErrorInfo; the same policy reads them, and ShowDataErrors() on a column frames its cells. View models are never tried before the write — only data rows are (Editing).
Path B: replace a panel with a board (WPF, MVVM)
A WPF window with a detail panel bound to a view model. The panel becomes a board whose controls are bound to the same view model with board.Bind. Build it in a file of its own, where WPF's control names are not imported:
using ArionUI.Core; // Track
using ArionUI.Presentation; // BoardView, ArionTheme
using ArionUI.Presentation.Controls; // Board, Label, TextBox, CheckBox, board.Bind
public static Board Build(OrderViewModel order)
{
var board = new Board
{
Columns = [Track.Auto, Track.Star()],
Rows = [Track.Auto, Track.Auto, Track.Auto, Track.Auto],
ColumnGap = 12,
RowGap = 10,
Padding = 14,
};
var title = board.Bind(order, x => x.Title); // read-only property: one way
var total = board.Bind(order, x => x.Total);
var delivered = board.Bind(order, x => x.Delivered);
return board
.Add(new Label { Text = title.Get }, row: 0, col: 0, colSpan: 2)
.Add(new Label { Text = () => "Customer" }, row: 1, col: 0, vAlign: TileAlign.Center)
.Add(board.Bind(new TextBox { Spoken = () => "Customer" }, order, x => x.Customer), row: 1, col: 1)
.Add(new Label { Text = () => "Total" }, row: 2, col: 0, vAlign: TileAlign.Center)
.Add(new Label { Text = total.Get }, row: 2, col: 1, vAlign: TileAlign.Center)
.Add(new CheckBox { Text = () => "Delivered", Value = delivered.Get, Toggle = delivered.Toggle }, row: 3, col: 1);
}In the window, an ArionGrid takes the place of the old panel — <arion:ArionGrid x:Name="OrderBoard" /> in XAML, with xmlns:arion="clr-namespace:ArionUI.Rendering.Wpf;assembly=ArionUI.Rendering.Wpf" — and shows the board:
var vm = (OrderViewModel)DataContext;
OrderBoard.MainView = new BoardView(OrderPanel.Build(vm));
OrderBoard.VisualTheme = ArionTheme.FromSystem(); // WPF's system colours and fontNo refresh code: a PropertyChanged from the view model, on any thread, reaches the board on its UI thread, and only what it changed repaints. A text box writes each keystroke to the view model; what the view model makes of it shows when the focus leaves. ArionTheme.FromSystem() reads the system colours, the high-contrast scheme and the font, so the board does not look like a different application. Details: Binding to a view model. For a panel of a few controls without view tiles, an ArionControlSurface with SetRoot(board) does the same job on the CPU (Control surface).
Path C: a new shell, the old forms next to it
The navigation and the header become ArionUI; the old UserControls are loaded into a plain panel beside them. Nothing of the old forms changes.
using System.Windows.Forms;
using ArionUI.Rendering.WinForms; // ArionControlSurface
using Drawn = ArionUI.Presentation.Controls; // StackPanel, Label, Button
var header = new ArionControlSurface { Dock = DockStyle.Top, Height = 52 };
var nav = new ArionControlSurface { Dock = DockStyle.Left, Width = 220 };
var legacyHost = new Panel { Dock = DockStyle.Fill }; // the old UserControls load in here
void Open(LegacyPage page)
{
legacyHost.Controls.Clear();
page.Dock = DockStyle.Fill;
legacyHost.Controls.Add(page);
current = page;
header.Invalidate();
}
nav.SetRoot(new Drawn.StackPanel { Gap = 4, MainPadding = 12 }
.Add(new Drawn.Button { Text = () => "Orders", Click = () => Open(new OrdersControl()) })
.Add(new Drawn.Button { Text = () => "Customers", Click = () => Open(new CustomersControl()) }));
header.SetRoot(new Drawn.StackPanel { Horizontal = true, Gap = 12, MainPadding = 12 }
.Add(new Drawn.Label { Text = () => current?.Title ?? "" }, Drawn.StackPanel.Fill)
.Add(new Drawn.Button { Text = () => "Save", Classes = ["primary"], Click = () => current?.Save() }, cross: 30));
Controls.Add(legacyHost);
Controls.Add(nav);
Controls.Add(header); // WinForms docks the control added last firstThis is side by side in the host's layout, not one board: a board cannot hold a native control. Once the shell is ArionUI, let it follow the system while the form is open:
// Colours, contrast scheme and font follow Windows while the form is open;
// stops by itself when the form is disposed.
ArionTheme.FollowSystem(this, theme =>
{
grid.VisualTheme = theme;
panel.VisualTheme = theme;
});The sample: one form, three steps
samples/ArionUI.Sample.WinFormsModernize in the repository is a classic order form — a DataGridView, text boxes and a BindingSource over a DataTable — and the same form after each step. The business logic is one file all four forms share.
| Step | What changes |
|---|---|
| 0 | Nothing: the form as it was. |
| 1 | The DataGridView becomes an ArionGridControl on the same BindingSource; the old text boxes still follow the current row. ArionTheme.FromSystem() gives it the window's colours and font. |
| 2 | The text boxes become a board bound to a view model with board.Bind; the view model follows the BindingSource and calls the same rules the old event handlers called. |
| 3 | Tool bar and status bar move into the board; ArionTheme.FollowSystem keeps the look in step with Windows. |
dotnet run --project samples/ArionUI.Sample.WinFormsModernize # chooser
dotnet run --project samples/ArionUI.Sample.WinFormsModernize -- 2 # one stepThe showcase has the same result as the scene “Modernised WinForms form”, and the DataTable part on its own as “DataTable and BindingSource”.
DataTable in the grid, the detail panel a board bound to a view model with board.Bind. WinForms host, screenshot of the running app (0.1.0-preview.1).What works today
- A grid over a
DataTable,DataVieworBindingSourcewith columns, rules and position from the data — or over any list, sorted, filtered, edited and searched, with its events andICommandinputs for the old handlers (The grid API, MVVM). - Bindable properties on the WinForms control, so
Control.DataBindingsworks withItemsSource,CurrentItem,SelectedItemand the others. - Boards bound to view models, with the controls a form needs — tabs, option groups, combo boxes, number and date fields, menus, validation (Controls) — in a grid control or on an
ArionControlSurface; many of them in one window, as the WinForms showcase shows. - A theme from the system, and one that follows it.
- The same code on WinForms, WPF and Avalonia: a board or a view written for one host draws on the others.
Recently built
Built The modernisation kit
- The WinForms host as a NuGet package A WinForms team adds one package and tries ArionUI in its own form, without building anything from source.
- DataTable and DataView as live sources, columns generated from the table Most old forms hold their data in a DataTable; the grid sees its inserts, deletes and edits and types its columns from the schema.
- BindingSource support, with its position kept in step with the grid's current row Forms built in the designer navigate through a BindingSource; text boxes and navigators bound to it keep working next to the grid.
- Validation from the DataTable, IDataErrorInfo and INotifyDataErrorInfo as a ready edit policy Rules an application already has refuse or mark a wrong value in the grid, without a second validation layer.
- View-model binding for board controls board.Bind(viewModel, x => x.Property): a PropertyChanged on any thread repaints only what changed, on the UI thread.
- A theme from the system colours and the form's font, and one that follows Windows An ArionUI island in an old window looks like it belongs there, high-contrast schemes included.
- Lists of objects as a WinForms DataSource: BindingList<T> and List<T>, directly or through a BindingSource Forms that bind business objects instead of a DataTable swap the grid the same way; a BindingList reports its changes by itself.
- A WinForms sample: one form with a DataTable, from before to after in three steps A migration path is believable when you can open every step and compare.
Everything the plan of 4 October 2026 listed is built. The roadmap shows what comes now, next and later, what is built and what is not planned.
Honest limits
- No native control inside a tile. A report viewer, a browser control or a third-party grid stays a WinForms or WPF control next to ArionUI, not inside a board. It would leave the immediate-mode contract and the parity between the hosts; it is not planned.
- No VB6, Delphi or Access. There is no ActiveX wrapper. Hosting a .NET window from such an application would be a project of its own with an open outcome.
- Windows only so far. Avalonia runs on Linux and macOS; ArionUI is developed and tested on Windows.
- No designer. Boards, columns and style sheets are C#. The cascade explains itself through
Explain, but there is no drag-and-drop surface in Visual Studio. - No floating panels. Tiles dock beside one another and as tabs inside a board; a panel cannot be torn out into a window of its own.
- A preview. The API still moves between preview versions. Try a path on one form before you plan a migration around it.
All of it, built and not planned, on one page: Roadmap.
Get release news
One e-mail per new version, nothing else, never passed on. Every e-mail has a link that unsubscribes you.





