1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
|
---
title: A 2025 Survey of Rust GUI Libraries
---
I did this [in 2020](/_posts/2020-08-21-survey-of-rust-gui-libraries.md) and then again [in 2021](/_posts/2021-10-24-2021-survey-of-rust-gui-libraries.md), but I’m in the mood to look around again.
Let’s look through [Are We GUI Yet?](https://www.areweguiyet.com/) and see what’s up these days.
The task today is to have a text label and an input field that can change the text in the label.
In React, for example, this is basically free:
```jsx
const Demo = () => {
let [state, setState] = useState("Hello, world!");
return (
<div>
<p>{state}</p>
<input type="text" value={state} onInput={evt => setState(evt.target.value)} />
</div>
);
}
```
Choosing a task this simple means I can actually have a shot at completing this at a reasonable pace (although it took me two weeks), but it also means frameworks that prioritize scaling over initial setup will be at a disadvantage here.
If you’ve found this post looking for specific guidance for a project that’s going to be substantially more complicated than this, don’t assume my conclusions are valid in your context.
A few other reasons my context may not match yours:
- I’m developing this, like nearly all my personal projects, on Windows.
I’m in good company there — per the [2024 Stack Overflow developer survey](https://survey.stackoverflow.co/2024/technology/#1-operating-system), “Windows is the most popular operating system for developers, across both personal and professional use” — but for a handful of reasons Windows is an afterthought in a lot of open source development.
I find some of those reasons more compelling than others, but for GUI libraries in particular I think avoiding Windows is avoiding success, and if Windows support is lower on your roadmap than trend chasing AI bullshit, you are not serious.
- I am checking that the text label can be read out from Windows Narrator.
Screen reader accessibility is another frequent afterthought, and it’s not load-bearing for me personally but it’s a lot more important as a matter of principle (and potentially a matter of law, depending on the project).
- New in the 2025 version of this exercise: I will be using the [Windows Japanese IME](https://go.microsoft.com/fwlink/?linkid=2007440) to type in the kanji for Tokyo, <span lang="ja">`東京`</span> (which on my US-layout-emulating keyboard I do with `toukyou<Tab><Return>`).
I don’t speak Japanese (although there are [more obscure IMEs](https://github.com/dec32/Ajemi) that I’m more interested in), and there are a lot of internationalization pieces that a minimal GUI library can reasonably decide to ignore, but if you’ve implemented text fields from scratch and you’re just appending keystrokes to a buffer then you have rejected compatibility with a lot of languages that are more complicated than that.
I’m feeling very slightly more patient this time around, so I’m not going to give up instantly if something takes very slightly more setup than just `cargo add`, but I’ve got a lot of things to check, so that’s gotta be enough preamble.
I’m writing this in linear order in parallel with my development, so it’s more of a journal than a reference and it probably reads best top to bottom, but if you want a TL;DR or you’re coming back for reference you can skip right to [the conclusion](#conclusion) or [the table](#the-table).
## Azul
[Azul](https://azul.rs/) is the first beneficiary of my newfound patience: you have to manually download the prebuilt `.dll` (via a link that doesn’t quite work, or directly off the GitHub release), and the last time I was here I balked at that request.
It’s not a great sign that the [getting started guide](https://azul.rs/guide/1.0.0-alpha1/GettingStarted) has samples for C++ and Python but not Rust, but there are [examples in the repo](https://github.com/fschutt/azul/tree/master/examples/rust) that aren’t too hard to follow.
However, the hello world sample doesn’t actually work if I copy and paste it into my `main.rs` - it looks like the API has changed somewhat since the latest release.
There’s a bit of a theme of release versioning issues with Azul - following the guide appears to give me version `1.0.0-alpha4`, but the only Git tag is `1.0.0-alpha1` and it’s not clear what may have changed between alpha1 and alpha4.
The broader issue, though, is that even if I download the `1.0.0-alpha1` examples off the GitHub release and try to run the same code myself, I am beset with `error LNK2019: unresolved external symbol __imp_AzCallbackInfo_getNodeIdOfRootDataset` and 47 other unresolved symbols.
I made an honest attempt to get Azul working, but it still doesn’t work.
I’ll see you in a couple years, Azul.
## cacao
[Cocoa](https://en.wikipedia.org/wiki/Cocoa_(API)) is some subset of the macOS API; it has [Rust bindings](https://github.com/ryanmcgrath/cacao) named Cacao.
I could have *sworn* that the cocoa/cacao wordplay had been done forever ago in the macOS space, but maybe I just couldn’t fucking read, because the only things I’m able to find are this crate.
Unsurprisingly, this does not work on Windows.
## core-foundation
[Core Foundation](https://en.wikipedia.org/wiki/Core_Foundation) is a different subset of the macOS API; it has [Rust bindings](https://github.com/servo/core-foundation-rs).
Also not useful from Windows.
## Crux
[Crux](https://github.com/redbadger/crux/) is new, and I find it really intriguing.
The idea of writing a shared library with business logic and then writing an ideally minimal native UI shell around it is also how Kotlin Multiplatform works (if you adopted it before Compose Multiplatform on iOS was out of alpha, at least), and I’ve been using that at my day job for a year and a half with only a handful of complaints.
The [initial project setup](https://redbadger.github.io/crux/getting_started/core.html) accurately describes itself as a sharp edge that needs better tooling, but it’s not miserable.
[Manually defining](https://redbadger.github.io/crux/getting_started/core.html#the-interface-definitions) the entire shared library interface feels like it would get old fast, but this task is faster.
Unfortunately, though, I’m just now processing that Crux doesn’t actually support desktop GUI development, only mobile and web!
It’s very interesting that this exists, though, and if my aim today was actually mobile development I’d be very curious if actual Swift bindings solve my Kotlin Multiplatform woes (I suspect that they might).
Hang on, though, this isn’t even a GUI library, the whole point is that you still use the native GUI library directly from each platform, and in fact several of the web examples use libraries that will be coming back later in this very list.
I’m not quite certain I agree with listing it on Are We GUI Yet? in the first place, although I guess the current design doesn’t have space for a separate section for non-GUI frameworks that would be useful for GUI applications.
## Cushy
[Cushy](https://crates.io/crates/cushy) is another new entrant - apparently there’s been a lot of movement in the space in the last four years.
The README code snippet has a funny but inconsequential mistake:
```rust
// Create a dynamic usize.
let count = Dynamic::new(0_isize);
```
Maybe one day clippy will be able to detect comments that don’t actually match the code.
The README example actually works (it’s a Christmas miracle!) but it spams stderr with a ton of eyebrow-raising Vulkan/DirectX 12 errors:
```text
2025-04-03T04:20:03.810927Z ERROR wgpu_hal::auxil::dxgi::exception: ID3D12CommandQueue::ExecuteCommandLists: Using ClearRenderTargetView on Command List (0x0000026C511CF250:'Unnamed ID3D12GraphicsCommandList Object'): Resource state (0x0: D3D12_RESOURCE_STATE_[COMMON|PRESENT]) of resource (0x0000026C510E4EB0:'Unnamed ID3D12Resource Object') (subresource: 0) is invalid for use as a render target. Expected State Bits (all): 0x4: D3D12_RESOURCE_STATE_RENDER_TARGET, Actual State: 0x0: D3D12_RESOURCE_STATE_[COMMON|PRESENT], Missing State: 0x4: D3D12_RESOURCE_STATE_RENDER_TARGET. [ EXECUTION ERROR #538: INVALID_SUBRESOURCE_STATE]
2025-04-03T04:20:03.812586Z ERROR wgpu_hal::auxil::dxgi::exception: ID3D12CommandQueue::ExecuteCommandLists: Using IDXGISwapChain::Present on Command List (0x0000026C51057910:'Internal DXGI CommandList'): Resource state (0x4: D3D12_RESOURCE_STATE_RENDER_TARGET) of resource (0x0000026C510E4EB0:'Unnamed ID3D12Resource Object') (subresource: 0) is invalid for use as a PRESENT_SOURCE. Expected State Bits (all): 0x0: D3D12_RESOURCE_STATE_[COMMON|PRESENT], Actual State: 0x4: D3D12_RESOURCE_STATE_RENDER_TARGET, Missing State: 0x0: D3D12_RESOURCE_STATE_[COMMON|PRESENT]. [ EXECUTION ERROR #538: INVALID_SUBRESOURCE_STATE]
```
It’s probably fine, though.
The actual application is about as simple as you’d hope it’d be:
```rust
let text = Dynamic::new("Hello, world!".to_string());
let label = text.map_each(|text| text.clone());
let text_input = text.into_input();
label.and(text_input).into_rows().run()
```

Unfortunately, Windows Narrator has no idea what’s inside this window.
Kanji input with the IME sorta works, though; I don’t get to see the <span lang="ja">`とうきょう`</span> that my `toukyou` becomes as I type it, but when I press Return I do in fact get the kanji I was expecting.
In IME jargon, turning `toukyou` into <span lang="ja">`とうきょう`</span> is the job of the *composer* and turning <span lang="ja">`とうきょう`</span> into <span lang="ja">`東京`</span> is the job of the *converter*, so the composer step is hidden but the converter step works fine.
I’m not sure whether Cushy has done anything in particular to accept IME results in its text input widgets or if the IME just dispatches the selected kanji as though they were typed directly, but I suspect it’s the latter.
I know Windows is pretty flexible with how it treats keyboard input — every curly quote in this blog post was hand-curled with [WinCompose](https://wincompose.info/) despite my Markdown renderer almost certainly doing smart quotes automatically — so maybe the IME result is just dispatched as though it’s a direct input of U+6771 CJK Unified Ideograph and then U+4EAC CJK Unified Ideograph.
(I had forgotten about Han unification; I’m curious how if at all using the Japanese IME causes the Japanese kanji to be displayed instead of the theoretically-equivalent hanzi/hanja, but I suspect the answer is that it doesn’t, and that scares me.)
## CXX-Qt
[CXX-Qt](https://kdab.github.io/cxx-qt/book/) is a framework for using the well-established Qt C++ GUI library from Rust.
I have been avoiding Qt for years, but it seems like it’s time to stop.
It’s annoying that I have to make an account to install Qt, and it’s very annoying that they want my name and location before they’ll let me download it.
I was right to hate this the whole time.
Their sample code will not run due to 1058 linker errors:
```text
Creating library C:\Users\Melody\Projects\misc\2025\rust-gui-survey\target\debug\deps\cxx_qt_demo.lib and object C:\Users\Melody\Projects\misc\2025\rust-gui-survey\target\debug\deps\cxx_qt_demo.exp␍
0245cd17b2ba3548-com_kdab_cxx_qt_demo_plugin_init.o : error LNK2019: unresolved external symbol "__declspec(dllimport) void __cdecl qRegisterStaticPluginFunction(struct QStaticPlugin)" (__imp_?qRegisterStaticPluginFunction@@YAXUQStaticPlugin@@@Z) referenced in function "public: __cdecl Staticcom_kdab_cxx_qt_demo_pluginPluginInstance::Staticcom_kdab_cxx_qt_demo_pluginPluginInstance(void)" (??0Staticcom_kdab_cxx_qt_demo_pluginPluginInstance@@QEAA@XZ)␍
libcxx_qt_lib-c91f193d907e83ae.rlib(badec7f11aadc5df-qcoreapplication.o) : error LNK2001: unresolved external symbol "__declspec(dllimport) void __cdecl qt_assert(char const *,char const *,int)" (__imp_?qt_assert@@YAXPEBD0H@Z)␍
<...>
libcxx_qt-464ae71fe424547a.rlib(0602fb52cb66f316-connection.o) : error LNK2019: unresolved external symbol "__declspec(dllimport) public: __cdecl QMetaObject::Connection::Connection(void)" (__imp_??0Connection@QMetaObject@@QEAA@XZ) referenced in function "class QMetaObject::Connection __cdecl rust::cxxqt1::qmetaobjectconnectionDefault(void)" (?qmetaobjectconnectionDefault@cxxqt1@rust@@YA?AVConnection@QMetaObject@@XZ)␍
libcxx_qt-464ae71fe424547a.rlib(0602fb52cb66f316-connection.o) : error LNK2019: unresolved external symbol "__declspec(dllimport) public: static bool __cdecl QObject::disconnect(class QMetaObject::Connection const &)" (__imp_?disconnect@QObject@@SA_NAEBVConnection@QMetaObject@@@Z) referenced in function "bool __cdecl rust::cxxqt1::qmetaobjectconnectionDisconnect(class QMetaObject::Connection const &)" (?qmetaobjectconnectionDisconnect@cxxqt1@rust@@YA_NAEBVConnection@QMetaObject@@@Z)␍
C:\Users\Melody\Projects\misc\2025\rust-gui-survey\target\debug\deps\cxx_qt_demo.exe : fatal error LNK1120: 1058 unresolved externals␍
```
I suspect it’s the entire Qt standard library that’s missing.
The linker args all look reasonable, though — it’s looking for `C:/Qt/6.9.0/mingw_64/lib\libQt6Qml.a`, which aside from the mixed slashes is a real path that exists — so I’m not sure what the problem is.
This is a complete bust.
There’s a section in the docs about building projects with CMake instead of cargo, but it says it’s optional, and it’s not like I’m desperate for more opportunities to use CMake, so I’m not going to try it.
## Dioxus
I think I remember [Dioxus](https://dioxuslabs.com/) as being one of the Rust frontend web dev frameworks; apparently they’ve branched out.
Their tutorial involves building “*HotDog* - basically Tinder, but for dogs!”, and by that they mean the app lets you swipe through a pile of dog photos and then view the ones you’ve swiped whichever direction is good on.
That is not what I would expect “Tinder, but for dogs” to be, but maybe I don’t know what Tinder is.
Apparently the way Dioxus supports desktop development is through WebView2/WebKitGTK, so they haven’t branched very far out.
I’m a little bit skeptical that Diet Electron is really the future, but given that [Electron](https://en.wikipedia.org/wiki/Electron_(software_framework)) is the present, maybe I need to take what I can get.
I also have some concerns about leaning this hard into cloning React — React hooks are a fascinating hack to almost build algebraic effects in JS, and it’s not like Rust really has algebraic effects, either, but maybe the real compilation step means they can do a little more magic and make it actually work reasonably.
At this scale, though, it’s hard to argue with the results:
```rust
let mut text = use_signal(|| "Hello, world!".to_string());
rsx! {
p { "{text}" }
input {
type: "text",
oninput: move |event| text.set(event.value()),
value: "{text}"
}
}
```

Windows Narrator can even see what the text is, although it feels a little clumsy (it’s saying “Web content region” on its way into the body of the frame).
The IME works perfectly, too.
I guess there are benefits to letting Chrome-via-Edge-via-WebView2 be responsible for all the UI machinery.
Dioxus did not invent the Diet Electron approach (that was Tauri, whose WebView2/WebKitGTK/macOS things library Dioxus builds its desktop support on), but the Rust-all-the-way-through approach feels like a way better idea than how Tauri works, which I’ll get into once I make it that far through my list.
If Diet Electron is really the best thing out there, I may be a little bit sad, but it’s probably possible to use Dioxus for real work without constantly being miserable, and that’s a new high water mark for this blog series.
## Dominator
[Dominator](https://github.com/Pauan/rust-dominator) is a Web-only UI crate, and unlike Dioxus it does not also offer a blessed desktop stack.
## egui
[egui](https://www.egui.rs/), and its framework `eframe`, have been around for a while.
The setup process has always been pretty straightforward, which is nice.
It’s pretty simple to use, too:
```rust
egui::CentralPanel::default().show(ctx, |ui| {
ui.label(&self.label);
ui.text_edit_singleline(&mut self.label);
});
```

Windows Narrator can even see this text!
It feels a little janky trying to get Narrator into the text field, though, but maybe that’s just the ceiling of how well Windows Narrator can work, or maybe I’m just holding it wrong and there’s a way to get behavior that feels more intuitive that I just can’t think of.
The default font doesn’t have hiragana or kanji coverage, though, and if I manually load a system font (which requires loading the bytes directly instead of just specifying a system font name, which is suboptimal but probably common), my Tab press to select <span lang="ja">`東京`</span> as the kanji for <span lang="ja">`とうきょう`</span> gets eaten by egui and I’m stuck with the hiragana forever.
I prefer this default appearance to Cushy’s or Dioxus’s, although it’s probably possible to make anything look like anything if you try hard and believe in yourself.
I’m not sure I love immediate mode on principle, although at this scale it extremely doesn’t matter.
<details>
<summary>Digression: “Immediate mode” and “retained mode”</summary>
<aside>
In an “immediate mode” GUI, your code that builds your widgets runs every frame, and the widgets don’t really _exist_ per se.
This can be simpler to work with — I can create the label with `&self.label` and the text edit widget with `&mut self.label` and there’s no issue because the label and the text field don’t actually exist at the same time.
I think it’s also easier to integrate into a game engine, since the GUI library doesn’t need as much control over communication with the GPU; that doesn’t matter for me today, but it may matter for you.
“Retained mode” is the opposite of that, where the code that builds the widgets only runs when it has something to do, and the widgets keep existing after they’re created.
My understanding is that this can have better performance since you aren’t rebuilding your entire UI from scratch every frame, although presumably serious immediate mode libraries do some amount of caching under the hood so you aren’t actually rebuilding your entire UI from scratch every frame.
I’m not sure how much of a difference it actually makes; it would be impossible to tell with anything this small.
</aside>
</details>
The fact that it’s possible to render your UI yourself and still have real accessibility support is definitely a good thing, and if it weren’t for the weird IME issues this would be perfect.
If you don’t need IME support and you want better styles out of the box or an immediate mode library you can plug into your existing game engine, egui seems like a perfectly reasonable choice, and that IME issue will probably get fixed eventually.
## Floem
[Floem](https://lap.dev/floem/) is the UI framework developed for [Lapce](https://lap.dev/lapce/), the cooler VSCode-but-in-Rust IDE.
I haven’t used Lapce in a while — several years ago when I last checked, its support for non-Rust languages was pretty weak, and I don’t actually prefer VSCode-style lightweight IDEs anyway (I pay for the JetBrains suite despite not doing enough personal development to justify that expense) — but everything that exists and is good enough for me once existed and was not.
It’s cool that it exists; let’s see if their UI framework is any good.
Getting from zero to today’s sample is pretty straightforward:
```rust
let label = create_rw_signal("Hello, world!".to_owned());
(
dyn_view(move || label),
text_input(label),
).style(|s| s.flex_col())
```

Windows Narrator can’t see any of this text, and the IME won’t even start, I’m stuck with “toukyou” forever.
Building layouts out of tuples feels a little bit weird — you can only have [up to 16](https://docs.rs/floem/0.2.0/floem/trait.IntoView.html#impl-IntoView-for-(A,+B,+C,+D,+E,+F,+G,+H,+I,+J,+K,+L,+M,+N,+O,+P)) widgets directly within a container at once, due to tuple generics in Rust being [still obviously incomplete after 11 years and counting](https://github.com/rust-lang/rfcs/issues/376) — but it’s probably better than Cushy’s `.and()`.
The complete lack of accessibility or IME support is the real issue, though.
Maybe one day they’ll fix it, but for now, this is no good.
## fltk
[FLTK](https://www.fltk.org/) is a C++ library with [Rust bindings](https://github.com/fltk-rs/fltk-rs).
Conveniently, the Rust bindings offer a `bundled` feature so I don’t have to figure out how to build FLTK from source on Windows.
Unfortunately, FLTK doesn’t appear to have an idea of widgets having an inherent size, and its whole layout subsystem leaves something to be desired:
```rust
let app = App::default();
let mut wind = Window::new(100, 100, 400, 300, "Hello from rust");
let mut pack = Pack::default_fill().with_type(PackType::Vertical);
let mut label = Frame::default();
label.set_label("Hello, world!");
let mut input = Input::default();
input.set_value("Hello, world!");
input.set_callback(move |input| label.set_label(&input.value()));
input.set_trigger(CallbackTrigger::Changed);
pack.end();
pack.auto_layout();
wind.end();
wind.show();
app.run().unwrap();
```

Windows Narrator has no idea what’s going on in here, but I did notice a two-year-stale [fltk-accesskit](https://github.com/fltk-rs/fltk-accesskit) repo under the `fltk-rs` org, and that works but it requires its own ugly setup (you have to pass it a redundant list of all your widgets, which is tough because I moved one of them into the callback for the other).
The IME works perfectly, which I wasn’t expecting.
The main issue here is the layout subsystem, which appears to have no concept of widgets having intrinsic sizes.
You can manually position and size everything, or you can use one of the clumsy automatic layouts, but neither of those is particularly satisfying.
The fact that adding widgets to containers happens in implicit global state and you have to `.end()` a container to stop adding items to it is a little bit horrifying, I can’t lie.
I don’t like this API design one bit.
## flutter_rust_bridge
[Flutter](https://flutter.dev/) is a Google framework for cross-platform UI development, but you use it from [Dart](https://dart.dev/).
Dart has [`switch` statements](https://dart.dev/language/branches#switch-statements) and [`switch` expressions](https://dart.dev/language/branches#switch-expressions) with completely different syntax.
Dart sucks.
Maybe using Flutter from Rust doesn’t suck?
It’s very funny to me that Flutter for Windows [claims](https://docs.flutter.dev/get-started/install/windows/desktop#hardware-requirements) you absolutely need a 1366x768 display; as an act of spite I will be disabling my primary display and only using my 1024x768 secondary display for the remainder of this section.
Oh god this is cramped, I regret this already.
Flutter hates my MSVC toolchain for some reason, and the Visual Studio installer does not want to be this narrow, but if I tab offscreen or move the window to the side I can still add the right components.
Apparently “MSVC v143 - VS 2022 C++ x64/x86 build tools” and “Windows 11 SDK” aren’t good enough, and Flutter absolutely insists on having specifically “MSVC v142 - VS 2019 C++ x64/x86 build tools” and “Windows 10 SDK”.
If I install those, though, `flutter doctor` still doesn’t think I have them for some reason.
It seems like my issue, which `flutter doctor` failed to detect for some reason, was that I didn’t have the “Desktop development with C++” workload installed in Visual Studio.
Getting flutter_rust_bridge set up is easy once Flutter itself is working, although having to run `flutter_rust_bridge_codegen generate` explicitly is no good; it can’t hook into the Flutter/Dart build process because [the only piece that anything can hook into](https://dart.dev/tools/build_runner) runs completely outside the Flutter/Dart build process.
However, what you actually get with flutter_rust_bridge is the opportunity to write your business logic in Rust and your UI in Dart still.
You can write your UI state in Rust if you want, but you still have to define your widgets in Dart:
```rust
#[frb(ui_state)]
pub struct RustState {
pub label: String,
}
impl RustState {
pub fn new() -> Self {
Self {
label: "Hello, world!".to_owned(),
base_state: Default::default(),
}
}
#[frb(ui_mutation)]
pub fn set_label(&mut self, label: String) {
self.label = label;
}
}
```
```dart
void main() => runRustApp(body: body, state: RustState.new);
Widget body(RustState state) {
return Column(
children: [
Text(state.label),
TextField(
controller: TextEditingController(text: state.label),
onChanged: (text) => state.setLabel(label: text),
),
],
);
}
```

This doesn’t even actually work, though: typing happens in reverse in the input field, because the `TextEditingController` contains the caret position but keeps getting reset.
In pure Flutter, you’d probably solve this by moving the controller into the widget state, but it’s not obvious how to do that here since our widget state is being defined in Rust instead.
Windows Narrator appears to be able to see this text, at least, although it feels janky trying to move between the label and the input.
The IME sort of works, but for presumably the same `TextEditingController` reasons, the intermediate states aren’t being cleared as I type in the IME, so the actual value that I’ve entered with `toukyou<Tab><Return>` is `東京東京東京東京とうきょうとうきょうとうきょとうきょとうkyとうkyとうkとうkとうとうととt`.
I’d get slightly better functionality if I moved this widget state to Flutter, I’m sure, but then there’d be no Rust code at all.
If I wanted to write my UIs in Flutter, I’d just do that.
If you want to write your UIs in Flutter and just some business logic in Rust, this might work alright for you, but that is not what I want.
## Freya
Per the README, [Freya](https://freyaui.dev/) is “a cross-platform GUI library for Rust powered by 🧬 Dioxus and 🎨 Skia.”
[Evidently](https://book.freyaui.dev/differences_with_dioxus.html), it takes the logic and structure of Dioxus and but renders everything itself instead of using Diet Electron.
I did grumble about the Diet Electron-hood of Dioxus, so maybe this is the exact thing I was hoping for all along.
*Edit 2025-04-15*: I’ve been asked to run this again with the week-old release candidate rather than the year-old latest stable release, and I’ve ignored other year-old latest stable releases so it’s fair to do that here too.
Next time, unless I forget to, I’m deciding up front when to use a stable release vs an unstable release vs the main branch.
Freya’s README example uses `rsx!()` rather than the Dioxus docs’ `rsx! {}`, and it still feels weird to me that those are interchangeable, but aside from that, the only difference from the Dioxus code is some component names:
```rust
let mut text = use_signal(|| "Hello, world!".to_string());
rsx!(
label { "{text}" }
Input {
value: text.read().clone(),
onchange: move |value| text.set(value),
}
)
```

Narrator sees the text label fine, but something’s gone wacky with the text input: Narrator can see that there’s a text input with those bounds on the screen, but it doesn’t seem like it actually knows the contents of the text input.
The IME shows up in the corner of the screen, and the provisional states aren’t displayed at all, but the final kanji land correctly in the text input once I accept them from the converter.
There are some drawbacks to rendering things yourself instead of letting Chrome-via-Edge-via-WebView2 do it for you, it seems.
Regardless, it’s extremely cool that Dioxus is set up in a way that makes this possible, and it’s extremely cool that someone’s trying to do it.
I’m not sure that Freya is quite ready for serious use yet, but it’s definitely promising.
## fui
[FUI](https://github.com/marek-g/rust-fui) does not have a lot of high-level documentation I can use to figure out what to put here.
The example in the README has drifted from the examples in the code, which I suppose is natural but which is rarely auspicious.
Even less auspicious is that I can’t build `fui_system`:
```text
qmake.stderr: Project ERROR: Cannot run compiler 'g++'. Output:
===================
===================
Maybe you forgot to setup the environment?
```
I can find no documentation about how to set up my environment, and if I really need `g++` then that’s not great.
## GemGui
The last commit to [GemGui](https://github.com/mmertama/gemgui-rs) was two years ago; that’s rarely a good sign.
GemGui leans even further into Diet Electron by actually running your frontend on an HTTP server and by default just opening it in your regular browser.
There’s a setting to run it in its own application frame instead, but that appears to have a load-bearing dependency on Python being installed in a way that I currently don’t have it installed.
It also looks like you’re only really intended to define the UI elements in HTML and wire up the business logic in Rust.
If I give this a venv and then manually ensure `python3` will do the right thing, that isn’t enough, because the Python dependency doesn’t actually work or something.
“Embed an HTTP server and then use a Web framework and open your server in the system default browser” is a very boring way to technically claim that you’re doing GUI development.
This repo has four stars on GitHub.
Why is it even listed in Are We GUI Yet?
## GPUI
[GPUI](https://gpui.rs/) is the UI framework developed for [Zed](https://zed.dev/), the other VSCode-but-in-Rust IDE.
Are We GUI Yet? links to [someone squatting it on crates.io](https://crates.io/crates/gpui), which is silly.
Remember this piece from the intro?
> if Windows support is lower on your roadmap than trend chasing AI bullshit, you are not serious.
Well, that’s Zed.
It’s a heavily-LLM-focused IDE with [no Windows support](https://github.com/zed-industries/zed/issues/5391).
GPUI appears to work alright on Windows, though.
It looks like GPUI doesn’t have a basic text input widget, though; their [text input example](https://github.com/zed-industries/zed/blob/a2fbe82c42601221482e8422d7f8db5fee649b8e/crates/gpui/examples/input.rs) is over 700 lines of code.
It’s possible to shuffle that example around to at least get something that’ll meet the task I’m working on, though.
```rust
// this isn’t even the bad part!
div()
.flex()
.key_context("TextInput")
.track_focus(&self.focus_handle(cx))
.cursor(CursorStyle::IBeam)
.on_action(cx.listener(Self::backspace))
.on_action(cx.listener(Self::delete))
.on_action(cx.listener(Self::left))
.on_action(cx.listener(Self::right))
.on_action(cx.listener(Self::select_left))
.on_action(cx.listener(Self::select_right))
.on_action(cx.listener(Self::select_all))
.on_action(cx.listener(Self::home))
.on_action(cx.listener(Self::end))
.on_action(cx.listener(Self::show_character_palette))
.on_action(cx.listener(Self::paste))
.on_action(cx.listener(Self::cut))
.on_action(cx.listener(Self::copy))
.on_mouse_down(MouseButton::Left, cx.listener(Self::on_mouse_down))
.on_mouse_up(MouseButton::Left, cx.listener(Self::on_mouse_up))
.on_mouse_up_out(MouseButton::Left, cx.listener(Self::on_mouse_up))
.on_mouse_move(cx.listener(Self::on_mouse_move))
.bg(rgb(0xeeeeee))
.line_height(px(30.))
.text_size(px(24.))
.child(
div()
.h(px(30. + 4. * 2.))
.w_full()
.p(px(4.))
.bg(white())
.child(TextElement {
input: cx.entity().clone(),
}),
)
```

Narrator has no idea what’s going on inside this window (and it’s in good company there).
The IME works fine, though.
I’m not sure you’re actually supposed to use GPUI at this stage; the documentation is spotty, the installation is janky, and the standard library is woefully inadequate.
But at least you can generate bad code way faster, and clearly that’s enough to get your Series A in.
Was inflicting Electron on us all by way of Atom not enough?
## GTK 3
> UNMAINTAINED Rust bindings for the GTK+ 3 library (use gtk4 instead).
OK then.
## GTK 4
[GTK](https://gtk.org/) is the GNOME toolkit (although apparently that’s not actually what it stands for); it’s got [Rust bindings](https://gtk-rs.org/).
Conveniently, there are [specific installation instructions for Windows](https://gtk-rs.org/gtk4-rs/stable/latest/book/installation_windows.html).
It’s not clear whether or not just downloading the prebuilt binaries would work, and it’d certainly save a lot of time if they would, but I’m going to assume building the binaries myself will be more likely to work.
That only took five minutes, astonishingly.
I find it a little bit counterintuitive that the single-line text widget is named `Entry`, but it does kinda rule that GTK’s property bindings mean I don’t have to keep any state at all:
```rust
let label = Label::builder()
.label("Hello, world!")
.build();
let entry = Entry::builder()
.text("Hello, world!")
.build();
entry
.bind_property("text", &label, "label")
.build();
let r#box = Box::builder()
.orientation(Orientation::Vertical)
.build();
r#box.append(&label);
r#box.append(&entry);
let window = ApplicationWindow::builder()
.application(app)
.title("My GTK App")
.child(&r#box)
.build();
window.present();
```

Not only can Narrator not see this text, it can’t even see the minimize/maximize/close buttons, and that’s not a failure state I had realized was possible.
The IME works fine.
You may have noticed that this is not the idiomatic Windows window decoration; these minimize/maximize/close buttons are very GNOMEy, which makes sense but isn’t really what I want.
Maybe Adwaita will solve this?
For some reason, `gvsbuild build libadwaita librsvg` (as [recommended](https://gtk-rs.org/gtk4-rs/stable/latest/book/libadwaita.html#if-using-gvsbuild) by the `gtk-rs` book) is building fucking libsass; not the actually maintained stop-trying-to-make-Dart-happen rewrite dart-sass, but the old and busted last-commit-two-years-ago libsass.
rsvg also appears to depend on some yanked crate versions, which is concerning but not my problem today.
Well, Adwaita certainly makes it look different:

I’ve got way more drop shadow or something that’s extending the ShareX window capture way beyond the actual boundary of the window, and I’ve got dark mode and a purple emphasis color (which I’m not sure if they’re reading from somewhere or if the default was just picked out by someone with good taste).
It still doesn’t look like a Windows window, though, and Adwaita has not magically fixed the accessibility.
Using GTK4 from Rust on Windows works, I guess, but I would have to lower my standards a lot to call this good enough.
## Iced
[Iced](https://iced.rs/) says it’s inspired by Elm, and that’s cool.
[Elm](https://elm-lang.org/) was your favorite programming language’s favorite programming language.
I miss it sometimes.
```rust
struct State {
label: String,
}
impl Default for State {
fn default() -> Self {
Self { label: "Hello, world!".to_owned() }
}
}
impl State {
fn update(&mut self, message: Message) {
match message {
Message::SetLabel(label) => self.label = label
}
}
fn view(&self) -> Column<Message> {
column![
text(&self.label),
text_input("", &self.label)
.on_input(Message::SetLabel),
]
}
}
#[derive(Clone, Debug)]
enum Message {
SetLabel(String),
}
```

Windows Narrator can’t see into this window, and the IME won’t even switch into active mode when I try to switch it into active mode, which may actually be a better failure state than having it just not work.
Apparently System76 is all in on Iced for Pop!_OS’s COSMIC shell, so for their users’ sake I hope accessibility and IME support are actually happening at some point.
## imgui
[Dear ImGui](https://github.com/ocornut/imgui) is a minimalist C++ GUI library with [Rust bindings](https://github.com/imgui-rs/imgui-rs).
I will always think of it as being called `dear imgui,`, even though it hasn’t been canonically spelled that way since [2018](https://github.com/ocornut/imgui/commit/84d1ce39584161dfd027613b0defe305637f3867); the trailing comma is delightful in an [e e cummings](https://www.poetryfoundation.org/poetrymagazine/poems/49493/i-carry-your-heart-with-mei-carry-it-in) sort of way, and they should bring it back.
Unfortunately, since Dear ImGui is designed to be plugged into an existing game engine, starting with it from scratch is a little bit annoying.
There’s a downright Linux-desktop-environment number of different ways to use imgui-rs, but apparently “The most tested platform/renderer combination is `imgui-glow-renderer` + `imgui-winit-support` + `winit`”, so that’s what I’ll use.
Or at least it would be what I’d use if the [examples](https://github.com/imgui-rs/imgui-examples) didn’t all use `imgui-glium-renderer` instead; that one’s [deprecated](https://github.com/imgui-rs/imgui-glium-renderer/issues/1) and it doesn’t appear to work with the latest version of `glium` but I can’t figure out how to get `glow` working instead.
Open source!
```rust
// eliding the 160 lines of glue i copied and pasted without understanding
let mut label = "Hello, world!".to_string();
support::simple_init(file!(), move |_, ui| {
ui.window("Hello world")
.size([300.0, 110.0], Condition::FirstUseEver)
.build(|| {
ui.text_wrapped(&label);
ui.input_text("Text", &mut label)
.build();
});
});
```

Windows Narrator can’t see this text, and the IME refuses to activate.
The tiny window within the huge window is hilarious, and it makes sense if you’re actually doing game dev and there’s a game in the rest of the window, but I am not, and the massive white void is not something I would tolerate even in an application I was building solely for myself.
If I had a graphics stack picked out already because I was doing game dev, I might not mind the flexibility of supporting what feels like hundreds of different renderers and backends, but since that is not my current situation I very much do mind the flexibility.
This is what Sartre meant by being “condemned to freedom”: you have innumerable options available to you, but nobody can rescue you from the responsibility of deciding between them.
<details>
<summary>digression: the irony you may have noticed</summary>
<aside>
This blog post offers you, in some sense, an escape from the responsibility of deciding between the innumerable (43) options available to people trying to develop desktop GUIs in Rust.
However, deciding whether or not to listen to me is as much an exercise of that responsibility as it is a surrender of it, and part of the reason I frontloaded so much context is that I want you to take that responsibility seriously.
If you decide for yourself that you value Windows support, screen reader accessibility, and IME handling like I do, then you have done the important part already.
</aside>
</details>
## KAS
[KAS](https://github.com/kas-gui/kas), the toolKit Abstraction System, is written from scratch in Rust.
The tutorials are a bit out of date — some things appear to have been moved around between when the tutorials were written and the most recent stable release — but the examples in the actual repo appear to work.
I’m not sure I quite understand how the state management is designed, but after a bit of fumbling I can at least complete the task:
```rust
let tree = column![
format_value!("{}"),
EditBox::instant_parser(|x: &String| x.clone(), SetLabel),
];
Adapt::new(tree, "Hello, world!".to_string())
.on_message(|_, label, SetLabel(text)| *label = text)
```

Narrator can’t see this text, and the IME won’t activate.
The part that confuses me the most is why the `EditBox` needs to be explicitly told that it’s a `String` that’s being edited; that seems like it shouldn’t require an explicit declaration.
Maybe if the tutorial were up to date it’d be easier to understand.
Regardless, it seems like this isn’t really ready for prime time yet.
## kittest
[kittest](https://github.com/rerun-io/kittest) is an AccessKit-driven testing library that only supports egui.
This is cool, but it’s not in the same category as the sort of thing I’m actually looking for.
If I maintained Are We GUI Yet? I’d probably split the list up into separate categories like [Are We Web Yet?](https://www.arewewebyet.org/) has.
## Leptos
[Leptos](https://github.com/leptos-rs/leptos) is a Web frontend framework that is for some reason on the Are We GUI Yet? list.
The README [has an FAQ about native GUIs](https://github.com/leptos-rs/leptos/tree/v0.7.8?tab=readme-ov-file#can-i-use-this-for-native-gui) that says it’d be possible to build native GUIs with Leptos but it’s not actually supported because it sent the whole codebase into generics hell when they tried it.
## lvgl
[LVGL](https://lvgl.io/), the Lightweight and Versatile Graphics Library, is a C GUI library designed for embedded use; it has [Rust bindings](https://github.com/lvgl/lv_binding_rust) that are `#![no_std]` compatible by default, which is neat if you need that.
Unfortunately, after copying around the C header files that define the configuration, I’m getting C compiler errors:
```text
C:\Users\Melody\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\lvgl-sys-0.6.2\vendor\lv_drivers\display\fbdev.c(13): fatal error C1083: Cannot open include file: 'unistd.h': No such file or directory
```
It seems like the LVGL configuration in the Rust binding samples is not designed to work on Windows, and if I figure out the flag to disable the framebuffer driver I get similar errors about not finding SDL, and if I disable SDL I get bindgen not being able to find libclang, and if I come back after fixing bindgen for a later library I get errors about the linker not finding SDL even though I already turned off SDL.
I wouldn’t be surprised if doing desktop development with LVGL is missing the point, though, and I’m holding it wrong by not cross compiling to some slightly cursed embedded Linux target.
## Makepad
[Makepad](https://github.com/makepad/makepad) is another novel Rust GUI framework.
They’re publishing versions to crates.io but not creating Git tags to match those versions, so it’s hard to find the examples that are supposed to work with the published crates, and it’s easier to just point the dependency right at the Git repo so the examples from their main branch will work.
They’ve got a macro DSL with no documentation I can find, but a bit of persistence is all it takes to turn the simplest example into something that works:
```rust
live_design! {
import makepad_widgets::base::*;
import makepad_widgets::theme_desktop_dark::*;
App = {{App}} {
ui: <Root> {
main_window = <Window> {
body = <ScrollXYView> {
flow: Down,
spacing: 10,
align: { x: 0.5, y: 0.5 },
label1 = <Label> {
text: "Hello, world!",
}
input1 = <TextInput> {
text: "Hello, world!",
}
}
}
}
}
}
impl MatchEvent for App {
fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions) {
let input1 = self.ui.text_input(id!(input1));
if let Some(new_text) = input1.changed(&actions) {
let label1 = self.ui.label(id!(label1));
label1.set_text(&new_text);
label1.redraw(cx);
}
}
}
```

Narrator can’t even see the minimize/maximize/close buttons, much less the content of the window.
The IME opens in the corner of the display and has its own wrapper to show the kana while I’m typing, but when I press Enter the kanji get correctly entered into the text field.
I kinda like the Blender aesthetic they’ve got for their stock widgets, but the lack of accessibility support is a downer, and the lack of documentation around the load-bearing DSL may be worse.
Maybe the documentation exists and I just can’t find it (they’ve got a Discord server that I’m not joining), but I suspect that Makepad is built for the Makepad team right now, and any utility anyone else can get out of it is coincidental.
A lot of projects start in that stage, and most of mine never leave, so that’s not a bad thing, but I do kinda wish Are We GUI Yet? was doing a little more pruning.
I’ve been working on this post for almost a week already, and I’m only 58% of the way through the list.
## masonry
[Masonry](https://github.com/linebender/xilem/tree/main/masonry) is a pure-Rust GUI library that’s the successor to the discontinued Druid framework that I found really impressive early on.
It primarily serves as the foundation for Xilem, a kinda Elm-ish kinda SwiftUI-ish framework I’m looking forward to trying once I get all the way down the list.
The last release of Masonry was 11 months ago, and it looks like a lot has changed since then, so I’m going to just point to the `main` branch directly.
```rust
fn on_action(&mut self, ctx: &mut DriverCtx<'_>, _widget_id: WidgetId, action: Action) {
match action {
Action::TextChanged(new_text) => {
ctx.render_root().edit_widget(self.label_id, |mut label| {
let mut label = label.downcast::<Label>();
Label::set_text(&mut label, new_text);
});
}
_ => {}
}
}
let main_widget = Portal::new(
Flex::column()
.with_child(Label::new("Hello, world!").with_id(label_id))
.with_child(Textbox::new("Hello, world!"))
.with_spacer(VERTICAL_WIDGET_SPACING),
);
```

Confusingly, Narrator can tell that there’s a text field in here, but it’s wrong about where in the window it is.
Kanji input via the IME works, but the default font appears to not support the fullwidth Latin characters that show up in provisional states before the hiragana replace them, so there’s a bit of [tofu](https://en.wikipedia.org/wiki/Unicode_input#Availability) in the intermediate states `☐`, `とう☐`, and `とう☐☐` (after the `t`, `k`, and `y` in `toukyou`).
I think it’s fair to say that you aren’t really supposed to use Masonry directly, the intent is to build an architecture on top of Masonry.
The API ergonomics feel like they match that: you probably could build a nontrivial application directly in Masonry, but I wouldn’t recommend it.
## Maycoon
[Maycoon](https://maycoon-ui.github.io/) is another new from scratch pure Rust framework.
It looks like it’s still pretty new.
The quick start guide is out of date, but the in-repo examples are still good.
(It’s very nice that Cargo defaults to compiling examples as part of running tests.)
Maycoon doesn’t appear to have a text input widget.
GPUI didn’t, either, but at least they had an example that involved building one from scratch that I could just copy.
Maycoon is too new to be usable for this task.
## Pax
[Pax](https://www.pax.dev/) is “a revolutionary new canvas for building apps & websites with AI.”
🤮🤮🤮
Shipping a real visual editor for your GUI DSL is a good idea, though, although I think I broke the fancy editor somehow because it stopped responding to anything and started logging a bunch of index out of bounds errors.
Alas, the only desktop target Pax supports [is macOS](https://docs.pax.dev/installation/app-targets/desktop/), which is useless to me today.
Maybe one day an AI bro who pays for Twitter will contribute something positive to society, but this is not that day.
## qmetaobject
[QMetaObject](https://github.com/woboq/qmetaobject-rs) is a different approach to Qt bindings than [CXX-Qt](#cxx-qt) that appears to try to put even more code into Rust.
Unfortunately, it appears to not work nicely with the `windows-msvc` target, and I don’t appear to have a gcc toolchain installed in a place that it likes.
## relm
[relm](https://github.com/antoyo/relm) is named after Elm, which is neat.
Unfortunately, relm is built on the unmaintained GTK 3 bindings, and even if I did install GTK 3 I’m not certain it would’ve worked, because some load-bearing components are making incorrect UNIX-centric assumptions about how lists of paths work:
```text
pkg-config exited with status code 1
> PKG_CONFIG_PATH=C:\Users\Melody\Projects\_resources\gtk-build\gtk\x64\release\lib\pkgconfig PKG_CONFIG_ALLOW_SYSTEM_CFLAGS=1 pkg-config --libs --cflags gdk-3.0 'gdk-3.0 >= 3.22'
The system library `gdk-3.0` required by crate `gdk-sys` was not found.
The file `gdk-3.0.pc` needs to be installed and the PKG_CONFIG_PATH environment variable must contain its parent directory.
PKG_CONFIG_PATH contains the following:
- C
- \Users\Melody\Projects\_resources\gtk-build\gtk\x64\release\lib\pkgconfig
```
I wonder if there’s a library that’s like relm but built on GTK 4?
## Relm4
[Relm4](https://relm4.org/) is like relm but built on GTK 4.
```rust
view! {
gtk::Window {
set_title: Some("Simple app"),
set_default_size: (300, 100),
gtk::Box {
set_orientation: gtk::Orientation::Vertical,
set_spacing: 5,
set_margin_all: 5,
gtk::Label {
#[watch]
set_label: &model.label,
set_margin_all: 5,
},
gtk::Entry {
set_text: &model.label,
connect_changed[sender] => move |x| sender.input(Msg::SetLabel(x.text().into())),
},
}
}
}
```

As was the case with the GTK 4 test, Narrator can’t even see the window chrome, and the IME works fine.
This architecture is probably easier to work with at scale than throwing GTK 4 widgets around directly would be, but it also inherits all of the problems of GTK 4 on Windows, of which there are many.
Also, that `view!` macro is (like all Rust macros) really annoying to try to debug if your input is slightly incorrect, which mine was while I tried to figure out how to get `connect_changed` working.
If you love the widgets of GTK 4 but want a nicer architecture, you might like Relm4, but if you are not in that situation, this library has nothing to offer you.
## Ribir
[Ribir](https://ribir.org/) is a bespoke Rust GUI framework that markets itself as being “non-intrusive”, [meaning](https://ribir.org/docs/introduction#non-intrusive-programming-model) that your GUI components read and write your model objects directly, with no intermediate state layers or constraints on model objects.
I’m not sure that this is actually a problem with other frameworks, and I feel like there might be a clearer way to pitch that, but it’s in principle good to be trying to stand out in what I had not quite realized was this crowded of a landscape.
The [website docs](https://ribir.org/docs/introduction) only have options for 0.2.x and main despite 0.3.0 coming out last August.
Well, I can’t get the pile of macro magic to work correctly, and I’m not sure why. This code looks like it should work, but the text I type into the input field doesn’t actually appear in the label:
```rust
App::run(fn_widget! {
let label = State::value("Hello, world!".to_string());
let input = @Input { auto_focus: true };
$input.write().set_text("Hello, world!");
@Column {
@Text { text: pipe!($label.to_string()) }
@ $input {
on_key_up: move |_| {
label.set($input.text().to_string());
},
}
}
});
```

Windows Narrator can’t see any of the text inside this window.
The IME opens in a random corner of my monitor, the composer state is hidden, and the default font doesn’t have kanji, but there are two missing-glyph symbols after I confirm from the IME converter, so it seems like the IME technically a little bit works.
If the pitch was that you don’t need to think about the mechanisms of state going into and out of the UI, then the pitch was overstated, because I have an app that looks like it should work but doesn’t because that glue has gone wrong.
## Rinf
[Rinf](https://github.com/cunarist/rinf) is another framework for using Rust for business logic and Flutter for UIs.
I want that even less now than I did a few days ago when I wrote the [flutter_rust_bridge](#flutter_rust_bridge) section.
## rui
[rui](https://github.com/audulus/rui) is a Rust GUI library “inspired by SwiftUI”; as someone who’s worked with SwiftUI a lot at my day job, I’m reading that as meaning that this will be almost good but its state management will be clumsy and annoying to work with.
It’s pretty alright at scales this small, though, so that may not be fair:
```rust
rui(state(
|| "Hello, world!".to_string(),
|label, cx| {
vstack((
text(&cx[label]).padding(Auto),
text_editor(label).padding(Auto),
))
},
));
```

Narrator can’t see this text, and the IME won’t even activate.
I think I kinda like the aesthetic — a strong [default font](https://www.brumale.xyz/anodina/) goes a long way towards giving a GUI toolkit a cohesive look — and I also like the lack of load-bearing macros, but I’m of course less wild about the lack of accessibility or IME support.
## Slint
[Slint](https://slint.dev/) is like if Qt had been invented 30 years later.
Like Qt, it’s got its own bespoke DSL, and like Qt, the business model is to be GPL and sell exceptions, but unlike Qt, desktop and web exceptions are free and it’s only embedded development that they want you to pay for.
There’s no inherent guarantee that that’ll always be the case, but also, doing this stuff right is hard and I am in favor of people getting paid for the work that they do.
This DSL kinda rules, I can’t lie:
```slint
export component AppWindow inherits Window {
property <string> label: "Hello, world!";
VerticalBox {
Text {
text: root.label;
}
LineEdit {
text <=> root.label;
}
}
}
```

Narrator works perfectly.
The IME renders all its provisional states as just missing-character glyphs `☐`, which makes me think the default font just doesn’t have fullwidth Latin or hiragana or kanji, but once I accept the kanji from the converter I get the actual kanji displaying correctly, so that may actually be a bug and not just a font selection issue.
Using `<=>` as the operator to create a [two-way data binding](https://docs.slint.dev/latest/docs/slint/guide/language/concepts/reactivity/#two-way-bindings) is really clever, I hope they’re proud of that.
Also, since this DSL is a standalone language and not just a pile of Rust macros, the ceiling on error message quality is way higher.
I don’t think they’re actually hitting that ceiling yet, though: before I stumbled into the two-way data binding operator I had a callback with a syntax error and the Slint compiler wasn’t a ton of help.
They’ve even got C++, JS, and Python bindings, and it’s cool that you can write a library once in Rust and then use it from that many different languages.
I [suggested](/_posts/2021-10-24-2021-survey-of-rust-gui-libraries.md#summary) towards the end of my previous excursion here that Slint (then still called SixtyFPS) would merit a more thorough look once it had better accessibility support, and it certainly does.
It’s not perfect, but it’s come a long way in the last four years, and I’m curious what the next couple years will look like for Slint.
## Tauri
Do you like Electron but wish it was Rust?
[Tauri](https://tauri.app/) is that.
To their credit, they’ve also swapped out the bundled Chromium for just binding to the system’s inherent web browser, whether that’s [WebView2](https://developer.microsoft.com/en-us/microsoft-edge/webview2/) on Windows, WebKit on macOS, or WebKitGTK on Linux, so Tauri applications don’t fill your hard drive with a dozen copies of the same web browser.
Unfortunately, they have not touched the architecture; you still have a host process running outside of the browser and an independent frontend running inside the browser.
Building that frontend is not something Tauri is concerned with; you have to decide for yourself what you want your stack to look like.
I want to write Rust, so in the new project wizard I pick Rust as my frontend language (rather than JavaScript/TypeScript or, for all three diehard Blazor fans, C#).
I’m then asked which Rust frontend framework I want, and I don’t really want to have to pick between Dioxus and Leptos and Sycamore and Yew right now, so I pick “Vanilla” assuming that it’ll give me bare [web-sys](https://rustwasm.github.io/wasm-bindgen/web-sys/index.html) to make the same DOM API calls as vanilla JS but in Rust; I’ve done this before, and it’s not very good, but at this scale it’d be completely tolerable.
Instead, though, “Vanilla” means vanilla JS even if I selected Rust, and since I selected Rust I don’t even get an option of vanilla TS instead.
This was [reported a year and a half ago](https://github.com/tauri-apps/create-tauri-app/issues/550) and ignored.
If I’m stuck making a choice, I need an excuse to ignore three of the four provided options.
I already looked at Dioxus, so that’d be boring to use again.
Yew’s 0.22 release was [announced in October 2024](https://yew.rs/blog/2024/10/14/release-0-22), [added to the changelog in December 2024](https://github.com/yewstack/yew/commit/d77cf0196b65486a35b9d1a02aaaed6faafbf8cc), and released on crates.io [literally never (as of April 2025)](https://crates.io/crates/yew/versions); that’s not great.
The [Leptos book](https://book.leptos.dev/) says that it’s “most similar to frameworks like Solid and Sycamore”; maybe that’s a sign that it doesn’t matter, or maybe it’s a sign that I should try both.
```rust
// leptos
#[component]
pub fn App() -> impl IntoView {
let (label, set_label) = signal("Hello, world!".to_string());
let update_label = move |ev| {
let v = event_target_value(&ev);
set_label.set(v);
};
view! {
<p>{ move || label.get() }</p>
<input type="text" value={ move || label.get() } on:input=update_label />
}
}
// sycamore
#[component]
pub fn App() -> View {
let label = create_signal("Hello, world!".to_string());
view! {
p { (label) }
input(r#type="text", bind:value=label)
}
}
```

Narrator can see all this text, and the IME provisional states are drawn in the corner of the screen rather than inline but they work correctly and the final kanji look fine.
I guess the main difference between these two Web frameworks that we can see from here is that Sycamore has a `bind:` modifier for attributes (very good!) but can’t quite handle `input type=` because `type` is a Rust keyword and requires `r#type` instead (very bad!).
The largest issue, though, is something I haven’t captured here, because today’s task is so trivial it can be done entirely within the frontend, and I let that count for GTK so I have to let it count here too.
If I add the requirement that the new value of the label be printed to standard output when the label changes (as a stand-in for, say, performing some file I/O), in most frameworks it suffices to either add a `println!` to the existing event handler or subscribe to a two-way-bound state with a `println!`.
Even Dioxus, built on the same WebView2/WebKitGTK library as Tauri, will do the right thing if I `println!` from an event handler.
In Tauri, though, a `println!` from the frontend will be completely ignored, and if we want to be able to `println!` we need inter-process communication between the frontend and the host process.
In the host, this is nice and easy due to the magic of proc macros:
```rust
#[tauri::command]
fn print(text: &str) {
println!("{}", text);
}
```
In the frontend, however, there is a lot more boilerplate:
```rust
#[wasm_bindgen]
extern "C" {
#[wasm_bindgen(js_namespace = ["window", "__TAURI__", "core"])]
async fn invoke(cmd: &str, args: JsValue) -> JsValue;
}
#[derive(Serialize, Deserialize)]
struct PrintArgs<'a> {
text: &'a str,
}
#[component]
pub fn App() -> View {
// ...
create_effect(move || {
let label = label.get_clone();
spawn_local_scoped(async move {
let args = serde_wasm_bindgen::to_value(&PrintArgs { text: &label }).unwrap();
invoke("print", args).await;
})
});
// ...
}
```
This makes me sad for two reasons.
The first is a question of principle: this arbitrary boundary drawn through the middle of my application means that if I discover I need a new piece of functionality I may need to move a substantial chunk of code from the frontend to the backend, and if it’s something load-bearing within the frontend I’m going to have a real motherfucker of a time pivoting my architecture on short notice for no reason.
The second is a question of type safety: as you may have noticed, the IPC interface in the frontend takes an `&str` for the command name and a `JsValue` for the command arguments, meaning frontend IPC calls have *no type checking*.
Indeed, if I rename the argument in the host from `text` to `text_to_print` and don’t update the `PrintArgs` in the frontend, I get not even a warning at compile time, and at runtime I get
```text
panicked at src\app.rs:6:1:
unexpected exception: JsValue("invalid args `textToPrint` for command `print`: command print missing required key textToPrint")
Uncaught RuntimeError: unreachable
```
If I then change the label, I get
```text
panicked at C:\Users\Melody\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\wasm-bindgen-futures-0.4.50\src\task\singlethread.rs:103:37:
already borrowed: BorrowMutError
```
and this is all just misery upon misery.
Half the point of Rust is the sheer quantity of bugs that it can catch at compile time, and if your IPC is just tossing strings around and praying at runtime, you may as well be just writing vanilla JavaScript.
(I checked, and even if your frontend is TypeScript, the `invoke` IPC boundary just takes a `string` rather than a union of the actual legal values.)
*edit 2026-01-03*: I learned at the [Utah Rust meetup](https://www.meetup.com/utah-rust/) that if you’re writing your frontend in TypeScript you can use [tauri-specta](https://github.com/specta-rs/tauri-specta) to generate type safe IPC wrappers.
Hilariously, the Tauri docs [claim](https://tauri.app/develop/calling-rust/) that the command mechanism is “for reaching Rust functions with type safety”, as distinct from their event system, which is even less type safe.
With events, you’re tossing strings and arbitrary JavaScript payloads around in both the frontend and the host, so technically it’s not false to claim that only doing that on one end is more type safe, but type checking only at one end is like putting a lock on your bike but not running it through the bike rack: you aren’t tying two things together, you’re just tying one thing to itself and praying.
Even to the limited extent that half of type safety could be useful, though, they’ve picked the wrong half: there’s inherently only one implementation of the command, but there can be many calls to it, so it’d be far more valuable to have type safety at the call sites than at the implementation site.
Commands only go from the frontend to the host, so type checking in the host and YOLOing in the frontend is being picky at the receive end and sloppy at the send end, which is the exact opposite of [Postel’s law](https://en.wikipedia.org/wiki/Robustness_principle).
<details>
<summary>digression: Postel’s law</summary>
<aside>
The common formulation of Postel’s law is “be conservative in what you emit and liberal in what you accept”, and it’d be more recognizable if I used those terms instead of “picky” and “sloppy”.
I haven’t done that, though, because you should be conservative never and liberal very rarely.
Be radically leftist in everything, even technical blog posts that aren’t intrinsically political.
</aside>
</details>
If there was an unnecessary IPC boundary but it was type safe, or if there was bad stringly typed nonsense somewhere but no unnecessary IPC boundary, I might find it within myself to forgive that, but the combination of the entirely unnecessary split-brain architecture with the absolute lack of type safety at the boundary means that I think I genuinely hate Tauri.
## tinyfiledialogs
[tinyfiledialogs](https://sourceforge.net/projects/tinyfiledialogs/) is a C library with [Rust bindings](https://github.com/jdm/tinyfiledialogs-rs) providing a handful of basic prompts, including message boxes, text input a la JS’s `window.prompt`, and, as the name implies, file dialogs.
I can’t actually complete today’s task with those.
## Tk
[Tk](https://www.tcl-lang.org/) is the GUI framework for [Tcl](https://www.tcl-lang.org/), a fascinating late-80s programming language that I would describe as weird in a Lua way, weird in a LISP way, and weird in its own way all at once.
[Evidently](https://github.com/oooutlk/tcltk) it has Rust bindings.
The docs for the Rust bindings [recommend](https://oooutlk.github.io/tk/installing_tk_on_windows.html) ActiveState’s ActiveTcl, but I can’t find an actual way to download ActiveTcl, and ActiveState’s [pricing page](https://www.activestate.com/pricing/) has an FAQ entry that doesn’t inspire confidence:
> **Can I still get ActivePerl, ActivePython, or ActiveTcl?**
>
> If you still need access to our legacy releases, please get in touch with us via our Contact us page.
I’m installing [Magicsplat Tcl](https://www.magicsplat.com/tcl-installer/index.html) instead.
It doesn’t appear to have been enough, though:
```text
thread 'main' panicked at C:\Users\Melody\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\bindgen-0.64.0\lib.rs:2393:31:
Unable to find libclang: "couldn't find any valid shared libraries matching: ['clang.dll', 'libclang.dll'], set the `LIBCLANG_PATH` environment variable to a path where one of these files can be found (invalid: [])"
```
[Apparently](https://rust-lang.github.io/rust-bindgen/requirements.html#windows) this can be fixed with just `winget install LLVM.LLVM`.
```rust
let tk = make_tk!()?;
let root = tk.root();
let c = root
.add_ttk_frame("c" -padding((3, 3, 12, 12)))?
.grid(-column(0) -row(0) -sticky("nwes"))?;
root.grid_columnconfigure(0, -weight(1))?;
root.grid_rowconfigure(0, -weight(1))?;
let label = c
.add_ttk_label("label" -text("Hello, world!"))?
.grid(-column(1) -row(1))?;
let entry = c
.add_ttk_entry("entry" -textvariable("label"))?
.grid(-column(1) -row(2))?;
entry.insert(0, "Hello, world!")?;
entry.bind(
event::any_key_release(),
tclosure!(tk, || label.configure(-text(entry.get()?))),
)?;
```

Windows Narrator can’t see any of this text, and the IME works fine.
I guess translating `ttk::label "label" -text "Hello, world!"` (which is how Tcl works, I’m fairly certain) to `add_ttk_label("label" -text("Hello, world!"))` makes sense for existing Tcl users, but it feels really weird, and `cargo fmt` is understandably confused by it.
It’s also hard to tell which options are actually supported on which widgets, because of all the trait magic that’s going on; it took me a while to discover that `.insert()` is the way you set the initial text of the text field.
There’s also a bit of jank in the example — [apparently](https://oooutlk.github.io/tk/a_first_real_example.html) attaching a callback to a button requires `unsafe`.
Plus, after I uninstalled Tcl/Tk, the binary stopped working, so you can only ship a binary to people who also manually install Tcl/Tk.
If you already know and love Tcl/Tk and just wish (heh) you could use it from Rust, maybe you’d find this useful, but I am not in that situation and I do not.
## Vizia
[Vizia](https://github.com/vizia/vizia) is another novel Rust GUI library.
The [book](https://book.vizia.dev/quickstart/setup.html) says to depend on the Git repo rather than the latest release, which I usually try to avoid, but sure.
Conveniently, the counter example is pretty easy to adapt for what I need here, and there’s no list of widgets in the book (at least that I could find) but there is a list of widgets [in the docs](https://docs.vizia.dev/vizia/views/index.html#structs) so I don’t have to spend fifteen minutes guessing what they call their text field.
```rust
#[derive(Lens)]
pub struct AppData {
label: String,
}
pub enum AppEvent {
SetText(String),
}
impl Model for AppData {
fn event(&mut self, _: &mut EventContext, event: &mut Event) {
event.map(|app_event, _| match app_event {
AppEvent::SetText(text) => {
self.label = text.clone();
}
});
}
}
fn main() -> Result<(), ApplicationError> {
Application::new(|cx| {
AppData {
label: "Hello, world!".to_string(),
}
.build(cx);
VStack::new(cx, |cx| {
Label::new(cx, AppData::label);
Textbox::new(cx, AppData::label).on_edit(|cx, text| cx.emit(AppEvent::SetText(text)));
})
.alignment(Alignment::Center);
})
.title("Counter") // Configure window properties
.inner_size((400, 100))
.run()
}
```

Something weird happens to the internal padding in the text field when I focus it, though:

Narrator can see that there’s a text label and a text input within this window, but it doesn’t appear to be able to see what the text actually is in either widget, which is a new one.
The IME converter dropdown appears in the corner of the screen, but the provisional states draw correctly in the text field, and the final kanji go in correctly.
The structure that’s present here seems promising, but Vizia doesn’t seem to be quite ready for serious use yet.
## WebRender
[WebRender](https://github.com/servo/webrender) is part of the guts of Servo, the Rust-based web browser engine that Mozilla founded and then [abandoned](https://www.zdnet.com/article/mozilla-lays-off-250-employees-while-it-refocuses-on-commercial-products/) (an event which prompted [my biggest hit on this blog](/_posts/2020-08-13-post-open-source.md)).
It’s been picked back up and is [some amount of back](https://servo.org/), although quite how back its new team wants it to be [is still up in the air](https://github.com/servo/servo/discussions/36379).
The in-repo [examples](https://github.com/servo/webrender/tree/beccb13247f1c3799957e4c85468d79ba47033c2/examples) are so old they’re [still using the 2018 language edition](https://github.com/servo/webrender/blob/beccb13247f1c3799957e4c85468d79ba47033c2/examples/Cargo.toml#L7), and the [latest version published on crates.io](https://crates.io/crates/webrender/versions) is from 2020, so I guess I’m depending on the Git repo again.
There’s a `main` branch last updated four months ago and an `upstream` branch updated last week; presumably the `upstream` branch is the right one to use, but it’d be nice if that was actually explained somewhere.
Looking a bit at the examples, WebRender does not have widgets, it just has shapes; this is a low-level graphics crate and not a high-level GUI crate, and it’s not clear why it’s on the Are We GUI Yet? list.
## windows
[Windows](https://www.microsoft.com/en-us/windows/) is an operating system created by Microsoft in the mid-1980s; its APIs have [Rust bindings](https://github.com/microsoft/windows-rs).
I do not know how to do GUI development with bare Win32 API calls, though, so doing them from Rust is not exciting.
XAML, which is to my understanding the shiny new way to do desktop GUI development in specifically Windows, is [explicitly not included in the `windows` crate](https://kennykerr.ca/rust-getting-started/what-apis-are-included.html) because “Xaml is also focused and tailored for C# app development so this API isn't applicable to Rust developers.”
This is confusing, because the XAML-based [WinUI 3](https://github.com/microsoft/microsoft-ui-xaml) is also supported on C++, not just C#.
Ah, Microsoft.
## WinSafe
[WinSafe](https://github.com/rodrigocfd/winsafe) is apparently a set of Rust wrappers around the Win32 GUI API.
```rust
#[derive(Clone)]
pub struct MyWindow {
wnd: gui::WindowMain,
label: gui::Label,
field: gui::Edit,
}
impl MyWindow {
pub fn new() -> Self {
let wnd = gui::WindowMain::new(
gui::WindowMainOpts {
title: "My window title".to_owned(),
size: (300, 150),
..Default::default()
},
);
let label = gui::Label::new(
&wnd,
gui::LabelOpts {
text: "Hello, world!".to_string(),
position: (20, 20),
..Default::default()
},
);
let field = gui::Edit::new(
&wnd,
gui::EditOpts {
text: "Hello, world!".to_string(),
position: (20, 50),
..Default::default()
},
);
let new_self = Self { wnd, label, field };
new_self.events(); // attach our events
new_self
}
pub fn run(&self) -> AnyResult<i32> {
self.wnd.run_main(None) // simply let the window manager do the hard work
}
fn events(&self) {
let ready = Arc::new(AtomicBool::new(false));
let ready2 = ready.clone();
self.wnd.on().wm_create(move |_| {
ready2.store(true, Ordering::SeqCst);
Ok(0)
});
let self2 = self.clone();
self.field.on().en_change(move || {
if ready.load(Ordering::SeqCst) {
self2.label.set_text(&self2.field.text());
}
Ok(())
});
}
}
```

Unsurprisingly, Narrator and the IME both work.
Manual positioning is no good, and the alternatives involve Win32 `.res` file editing and other Pandora’s boxen I don’t want to open.
Also, I had to add that `ready` tracking myself, because the callback was firing for the first time before the window had been created, which was causing crashes.
This isn’t great, and of course it’s only useful on Windows.
## Xilem
[Xilem](https://github.com/linebender/xilem/) is another novel pure-Rust framework, built on top of the previously discussed [masonry](#masonry), the successor to Druid, which I thought was really promising when I first got started with this series.
It hasn’t had a numbered release in almost a year, so I’m pointing at the Git repo again.
Conveniently, they’ve got a todo list example that I can sculpt into what I need today mostly by deleting.
```rust
struct State {
label: String,
}
fn app_logic(state: &mut State) -> impl WidgetView<State> + use<> {
flex((
label(state.label.clone()),
textbox(state.label.clone(), |state: &mut State, new_value| {
state.label = new_value;
}),
))
}
fn run(event_loop: EventLoopBuilder) -> Result<(), EventLoopError> {
let data = State {
label: "Hello, world!".to_string(),
};
let app = Xilem::new(data, app_logic);
app.run_windowed(event_loop, "First Example".into())
}
fn main() -> Result<(), EventLoopError> {
run(EventLoop::with_user_event())
}
```

As was the case when using Masonry directly, Narrator sees the text but is wrong about its position, and some IME provisional states have missing glyphs but the IME behavior works fine.
This architecture seems pretty neat, although of course this is not sufficient to know how well it works at any reasonable scale.
Honestly, aside from the screen reader jank, my only gripe is the lack of versioning, and presumably that’ll be coming as Xilem matures.
## Conclusion
What a list, huh?
If I had counted how many of these there were before I got started, I might’ve never started, because 43 is a lot.
It’s good that there are this many different people working in this space, but the more options there are, the more important it is for people to be sifting through them to distinguish the ones that aren’t ready to use from the ones that are.
Let’s pick some winners.
If you’d rather take the quirks of CSS layout over the quirks of some other layout engine, [Dioxus](#dioxus) seems like a pretty reasonable choice; Diet Electron is definitely better than regular Electron, and that may be good enough for you, but it feels not-better-enough to me (although my sense of not-better-enough is [non-standard](https://en.wikipedia.org/wiki/Obsessive%E2%80%93compulsive_personality_disorder)).
If you like DSL-driven UIs that are putting serious effort into developer tooling, [Slint](#slint) might be for you.
If you want to avoid DSLs and macros and write only regular Rust, [egui](#egui) offers that.
If you’re looking for something to invest in early, [Freya](#freya) and [Xilem](#xilem) are both basically usable now if you don’t mind living on the bleeding edge and putting up with some jank.
There are open issues for improving accessibility in [Floem](https://github.com/lapce/floem/issues/8) and [iced](https://github.com/iced-rs/iced/issues/552), so it may be worth at least keeping an eye on those issues, although the iced issue has been open for 4½ years now.
I would not describe any of these as a super easy slam dunk obviously correct choice, but there are a lot of reasonable options available, and that’s better than 2021, where I was [longing for wxPython](/_posts/2021-10-24-2021-survey-of-rust-gui-libraries.md#whining) by the end of the post.
Maybe better things are possible after all.
Now if you’ll excuse me, I’ve got some `cargo clean`s to run:

## The Table
| library | works at all? | screen reader accessible? | IME works? |
|---------------------------------------------|---------------------------|----------------------------------|------------------------------------------------------------------------------------------|
| [Azul](#azul) | linker hell | | |
| [cacao](#cacao) | macOS-specific | | |
| [core-foundation](#core-foundation) | macOS-specific | | |
| [Crux](#crux) | no desktop targets | | |
| [Cushy](#cushy) | yes! | nope | composer hidden, converter works |
| [CXX-Qt](#cxx-qt) | linker hell | | |
| [Dioxus](#dioxus) | yes! | yes! | yes! |
| [Dominator](#dominator) | web-specific | | |
| [egui](#egui) | yes! | yes! | composer works, Tab press stolen from converter |
| [Floem](#floem) | yes! | nope | nope |
| [fltk](#fltk) | yes! | with extra crate | yes! |
| [flutter_rust_bridge](#flutter_rust_bridge) | kinda, but state hell | yes! | kinda, but state hell |
| [Freya](#freya) | yes! | mostly, but some content missing | composer hidden, converter works |
| [fui](#fui) | qmake hell | | |
| [GemGui](#gemgui) | technically | | |
| [GPUI](#gpui) | yes! | nope | yes! |
| [GTK 3](#gtk-3) | unmaintained | | |
| [GTK 4](#gtk-4) | yes! | nope | yes! |
| [Iced](#iced) | yes! | nope | nope |
| [imgui](#imgui) | yes! | nope | nope |
| [KAS](#kas) | yes! | nope | nope |
| [kittest](#kittest) | only for testing | | |
| [Leptos](#leptos) | web-specific | | |
| [lvgl](#lvgl) | C dependency hell | | |
| [Makepad](#makepad) | yes! | nope | composer outside window, converter works |
| [masonry](#masonry) | yes! | content but not position | yes! but some temporary tofu |
| [Maycoon](#maycoon) | no text input widget | | |
| [Pax](#pax) | no Windows support | | |
| [qmetaobject](#qmetaobject) | no windows-msvc | | |
| [relm](#relm) | uses unmaintained GTK 3 | | |
| [Relm4](#relm4) | yes! | nope | yes! |
| [Ribir](#ribir) | kinda, but state hell | nope | composer hidden, converter works |
| [Rinf](#rinf) | does not use Rust for GUI | | |
| [rui](#rui) | yes! | nope | nope |
| [Slint](#slint) | yes! | yes! | missing glyphs in provisional states but logic works and final kanji displayed correctly |
| [Tauri](#tauri) | yes! | yes! | composer outside window, converter works |
| [tinyfiledialogs](#tinyfiledialogs) | not general-purpose | | |
| [Tk](#tk) | yes! | nope | yes! |
| [Vizia](#vizia) | yes! | structure but not content | converter outside window, everything works |
| [WebRender](#webrender) | too low-level | | |
| [windows](#windows) | i don’t know Win32 | | |
| [WinSafe](#winsafe) | yes! | yes! | yes! |
| [Xilem](#xilem) | yes! | content but not position | yes! but some temporary tofu |
|