AntdUI rebuilds the Ant Design look with pure GDI on WinForms

A WinForms control library shaped like Ant Design

AntdUI is a WinForms interface library based on Ant Design, and it exists because Ant Design itself is a web component set. The problem it solves is concrete: a Windows desktop team that wants the visual language of a modern product without shipping a browser engine inside the application, and without rebuilding rounded corners, segmented switches and ripple-like feedback by hand in every form.

The project positions itself as Ant Design for WinForms, reimagining desktop app aesthetics with modern frontend design elements. The implementation is a set of UserControls, which is the natural fit for WinForms since you drop them onto a Form in the designer and they behave like any other control. The repository layout matches that: a solution file AntdUI.sln, a src directory for the library itself, a test directory, an example directory and a doc directory holding the wiki.

The audience is specific and not large: Windows application developers who care about appearance, who are working with .NET Framework 4.0 and above, .NET Framework 4.8, .NET 8.0 or .NET 10.0, and who would rather adopt a component set than commission a design system implementation. The stated requirements cover that whole range, which also tells you the library is not tied to the modern .NET runtime.

Pure GDI drawing, no image resources, AOT compatible

The single most consequential line in the documentation is that the library uses pure GDI graphics, requires no image resources, and fully supports AOT. That is a design decision with consequences on both sides.

On the plus side, a control drawn with GDI is resolution independent by construction, so the same code scales across displays, and the project lists DPI adaptation as a feature. It also means there are no icon atlases to license, no skin files to ship and nothing to go missing at runtime. Vector rendering comes from SVG support, which the feature list calls out, and the shadow effects are drawn rather than baked into bitmaps. Anti aliased text rendering is listed as a separate feature, which matters for a UI that is otherwise made of curves.

On the other side, GDI is an immediate-mode drawing API, not a retained scene graph. A rounded button with a shadow and a smooth transition means the library has to manage redraw timing itself, and the documentation notes that the dynamic effects are comfortable and can be interrupted. Interruptible animation is a deliberate property, and it is a harder thing to build than an animation that always runs to completion.

AOT support is the other detail that changes who can use it. Native AOT trimmed away reflection based rendering and many third party UI libraries stopped working under it. A library that paints with GDI and ships no image resources sits comfortably in that world, and the feature list marks AOT Release as a headline item. The trade-off is that GDI means Windows, so the library is not portable to Linux or macOS, whatever the underlying.NET version.

Seventy one controls, grouped the way a designer would group them

The control table in the project documentation is grouped into eight families and the counts are worth keeping straight, because they tell you what kind of library this is. General has 2 controls, Button and FloatButton. Layout has 5: Divider, StackPanel, FlowPanel, GridPanel and Splitter. Navigation has 7, covering Breadcrumb, Dropdown, Menu, PageHeader, TabHeader, Pagination and Steps.

Data Entry is the largest functional group with 16, running from Checkbox, ColorPicker and the two date pickers through Input, InputNumber and Radio to Rate, the two Select controls, the two sliders, Switch, TimePicker, Transfer and UploadDragger. Data Display is larger still with 23, including Avatar, Badge, Calendar, Panel, Carousel, Collapse, Preview, ImagePreview, Popover, Segmented, Table, Tabs, Tag, Timeline, Tooltip, Tour, Tree, a set of Label variants, and Chart. Feedback has 8, covering Alert, Drawer, Message, Modal, Notification, Progress, Spin and Watermark. Chat has 2, MsgList for a friend message list and ChatList for a chat bubble list, and Other has 8 including Battery, Signal, Shield, ContextMenuStrip, Image3D, Docking, Ribbon and OutlookBar.

That last group is the tell. A generic component port would stop at Modal and Table. Docking, Ribbon, OutlookBar and Image3D are desktop specific, and the demo notes that the chat UI is pure GDI drawing without inheriting from TextBox, which is exactly the kind of implementation detail that a port of a web library usually does not include.

Animation is a per control feature, and the table says which

Each row of the control table carries two markers, one for animation support and one for whether the control can be disabled. Reading the animation column is the most useful thing an evaluator can do, because it separates the library from a static component set.

Animation is available on most of the interactive controls: Button and FloatButton, Dropdown, Menu, PageHeader, TabHeader, Pagination, the date pickers, Input, InputNumber, Radio, Select, SelectNumber, Switch, TimePicker, the display controls such as Panel, Preview, Segmented, Table, Tabs and Tree, the feedback controls Alert through Watermark, and the chat lists. The exceptions are structural or static controls: Divider, StackPanel, FlowPanel, GridPanel, Splitter, Steps, Avatar, Timeline, Shield.

The distinction is logical. A container does not animate, an icon does not animate, but a control that a user presses should give feedback. Reading the markers rather than the marketing line tells you where the effort went, and it also tells you where you will need to build your own motion if the stock look is not what you want.

The Disable column works the same way, marking controls that support a disabled state. For a form-heavy application that distinction is not cosmetic, since a disabled input, a disabled switch and a disabled menu item each need their own visual treatment.

Where to get it and what to check before you start

The project does not publish an install command, so the distribution route is the NuGet package. The package is named AntdUI, and the documentation links the NuGet listing and the download badge for it. There is also a separate demo repository, AntdUI-Demo, linked from the project page, and the wiki entry point is doc/wiki/en/Home.md with an UpdateLog at doc/wiki/en/UpdateLog.md.

Before writing any code, the fastest evaluation is the example directory in the repository. It contains six projects with clear intent: Demo for the component gallery, ChatUI for the messaging interface, BallTest, FontTest, SVGView and ExtendedTest for the rendering edge cases. The FontTest and SVGView projects in particular are where you can judge the text rendering and vector work that the rest of the library depends on.

A second thing to check is the supported runtimes, because the requirement list spans .NET 10.0, .NET 8.0, .NET Framework 4.8 and .NET Framework 4.0 and above. The widest floor means you can drop the library into a long-lived .NET Framework application, which is a real advantage for business software, but it also means you are committing to whatever the lowest common denominator is in terms of language and runtime features.

The documentation and the source are bilingual, with a Chinese README and an English one, and the wiki is maintained in the doc directory of the repository rather than on a separate site, so component pages travel with the code.

Apache 2.0, an open contribution process, and a version gap worth reading

The licence is Apache 2.0, which is the permissive end of the scale and includes an express patent grant. For a commercial Windows product that matters, because Apache 2.0 is the licence many companies require their dependencies to carry. The repository also contains CONTRIBUTING.md and CONTRIBUTING.zh.md plus a CODE_OF_CONDUCT.md, so contribution is a documented process rather than an invitation to send patches.

On maintenance, the repository is not archived and the last push was on 2026-10-19. The tagged releases are slower than the pushes. v2.2.0 was released on 2025-11-14, v2.2.7 on 2026-01-01 and v2.3.0 on 2026-02-27. That leaves a gap of more than seven months between the most recent tag and the last push, which usually means work is landing on main that has not been packaged yet.

That gap is the thing to verify before you commit to a version. The update log in the wiki is the place where those changes are described, and NuGet is where the packaged versions live, so comparing the two tells you whether you would be pinning to v2.3.0 from February or waiting for a newer package to appear. The project publishes a version badge for the NuGet package, so the published version is visible at a glance.

The internationalisation entry in the feature list, and the separate security zone feature, both point to a library that is used on a real product surface rather than only in a demo, which is mild but real evidence about the scope of the work.

Where it sits against the other ways to get this look

There are two other routes to a modern looking Windows application, and the difference matters.

The first is the web. Put the real Ant Design components in a page and host them in a WebView2 control. You get the exact component set and the exact behaviour, and you get none of the native integration, since a WebView2 host is heavier, has a different text rendering model, and complicates things like menus, tooltips and drag and drop across the boundary. AntdUI takes the opposite route, reproducing the design language as native UserControls that behave like WinForms controls in every other respect.

The second is hand painting. You can derive from Control and write your own OnPaint code for rounded buttons, or buy into a general purpose WinForms theming kit. The cost is that every control in the set has to be built, animated and maintained by you, and the animation work in particular is the part that eats time.

The trade-off AntdUI makes is coverage against depth. It gives you 71 controls with consistent motion and theming, but the set is fixed and it is the set you get, so anything Ant Design has and this library does not, you will be drawing yourself. It also stays on Windows, since GDI is a Windows API. A team shipping one Windows desktop product with a tight deadline gets the most out of it; a team shipping on three platforms, or one that needs a control outside the table, gets less.

Editorial conclusion

AntdUI is a sensible choice for a Windows desktop application that has to look like a modern web product without adopting a web view, and for teams already shipping WinForms who want to stop hand-painting controls. It is the wrong choice for a cross platform product, for a project that needs more than the listed control set, or for a team unwilling to accept that a UI library upgrade can change control behaviour. Before adopting it, open the demo in the example/Demo project and check the UpdateLog at doc/wiki/en/UpdateLog.md against the AntdUI package version you plan to reference, because the most recent tagged release is v2.3.0 from 2026-02-27 while the repository itself was pushed to on 2026-10-19, and the wiki is where the unreleased changes are described.

Frequently asked questions

Official sources

1. AntdUI/AntdUI on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases