# How to create standalone applications for Windows with a \[G\]UI in Julia 1.11 or 1.12 **URL:** \ **Category:** General Usage\ **Tags:** question\ **Created:** [April 7, 2025, 11:09pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823 "2025-04-07T23:09:40Z")\ **Posts on this page:** 20\ **Page:** 2

**Author:** ![uwestoehr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/uwestoehr/32/216201_2.png) [@uwestoehr](https://discourse.julialang.org/u/uwestoehr)\ **Post date:** [April 9, 2025, 2:01pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/21 "2025-04-09T14:01:13Z")

> [@goerz](#): > > What you are asking for is at the very bleeding edge of Julia development I am surprised. I mean, go to any research lab of a company of your choice and look how they work: 1. there are lab workers handling different machines, perform measurements etc. 2. there are scientists who take the data to develop new things 3. there are scientists that have to work parallel to the running production, to do the quality assurance and deal with guarantee cases. Person class 1 need software that “just works”. Most of them have never seen any program code in their life. They need software with a menu in which they can select the tasks they have to perform (loading/saving a file, creating a plot etc.) Person class 2 might be interested in the source code, adapt it, write own scripts and libraries. But not at a daily basis. If you develop e.g. a better process for a chemical reaction, you need to evaluate sensor data like temperature. You then just need software that does this job for you and also the job of automatically plotting the data, analyzing it using a pre-trained neuronal network. Or you want to teach a new neuronal network with your sensor data. Then you also need a proper UI that guides you through this. Person class 3 also need software that “just works”. They have no time to work with program code. They need to perform measurements, generate reports etc. Julia aims to be a programming language for scientific tasks. So it should also focus on how development and science is done in practice outside of universities. Maybe I misunderstood you, but saying that serving many thousand lab workers all over the world across all kinds of science is “not a typical use case” sounds arrogant to me. ---

**Author:** ![goerz](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/goerz/32/3269_2.png) [@goerz](https://discourse.julialang.org/u/goerz)\ **Post date:** [April 9, 2025, 2:17pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/22 "2025-04-09T14:17:38Z")

> [@uwestoehr](#): > > I mean, go to any research lab of a company of your choice and look how they work To the limited extend that I have insight into industry research labs (IBM, Google, various quantum-computing startups), they don’t seem that _fundamentally_ different from a university research lab environment. > [@uwestoehr](#): > > [lab worker] need software that “just works” You can certainly write software in Julia that “just works” and that does not expose source code to the user. But especially for a lab worker inside a research lab, I don’t see that they wouldn’t have staff to set up their lab computer with the Julia environment (or whatever else is required) to run the UI that they need to operate the experiment. I was under the impression that you were more talking about shipping commercial software to lab workers of an _outside_ organization, where smooth deployment is much more of a difficult concern. > [@uwestoehr](#): > > saying that serving many thousand lab workers all over the world across all kinds of science is “not a typical use case” sounds arrogant to me. It’s not intended as a value judgement, merely as a description of the state of things. I would be more than happy with developments in Julia that make it easier to ship small binaries, or even native GUI applications. But I’m pretty sure it’s not “typical” for what most current Julia users do. Like I said, I don’t think what you’re asking for is _unreasonable_, but it’s not something that Julia currently provides a great solution for. ---

**Author:** ![mbauman](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mbauman/32/31082_2.png) [@mbauman](https://discourse.julialang.org/u/mbauman)\ **Post date:** [April 9, 2025, 2:28pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/23 "2025-04-09T14:28:05Z")

Hey @uwestoehr, I get that you’re frustrated. If I may intervene here, I’m quite certain that @goerz is not saying that distributing binaries and GUIs is an uncommon use-case. It is, however, _not yet_ a common use-case _for Julia_. It’s not arrogance about the state of the world at large, it’s setting expectations for what _Julia_ can do. IMO, even when Julia can easily and robustly generate small binaries, it _still_ will probably be easiest to use C#/.NET/WPF or Javascript/HTML/Electron to create the GUI front-ends that can talk to a Julia dll/so/dylib — especially because LLMs are quite good at generating bog-standard GUIs with bog-standard tooling. GUIs are _all about_ library APIs. And it will always be easiest to generate them using the most common native language(s) for the target platform(s). ---

**Author:** ![goerz](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/goerz/32/3269_2.png) [@goerz](https://discourse.julialang.org/u/goerz)\ **Post date:** [April 9, 2025, 2:29pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/24 "2025-04-09T14:29:33Z")

> [@mbauman](#): > > I’m quite certain that @goerz is not saying that distributing binaries and GUIs is an uncommon use-case. It is, however, _not yet_ a common use-case _for Julia_. It’s not arrogance about the state of the world at large, it’s setting expectations for what _Julia_ can do. Yes, that’s absolutely right 🙂 ---

**Author:** ![uwestoehr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/uwestoehr/32/216201_2.png) [@uwestoehr](https://discourse.julialang.org/u/uwestoehr)\ **Post date:** [April 9, 2025, 3:10pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/26 "2025-04-09T15:10:37Z")

> [@mbauman](#): > > it _still_ will probably be easiest to use C#/.NET/WPF or Javascript/HTML/Electron to create the GUI front-ends that can talk to a Julia dll/so/dylib I fully agree and this is also the way I want to go. We have existing programs, most with Qt some with Lazarus. So a DLL is the right solution for our use case. ---

**Author:** ![adienes](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/adienes/32/37459_2.png) [@adienes](https://discourse.julialang.org/u/adienes)\ **Post date:** [April 9, 2025, 3:48pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/28 "2025-04-09T15:48:41Z")

> [@goerz](#): > > they don’t seem that _fundamentally_ different from a university research lab environment. the snack bar is way better tho ---

**Author:** ![MDSW](https://avatars.discourse-cdn.com/v4/letter/m/94ad74/32.png) [@MDSW](https://discourse.julialang.org/u/MDSW)\ **Post date:** [April 10, 2025, 2:34am UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/36 "2025-04-10T02:34:14Z")

Wanted to jump back in with a few comments on this thread, starting with, I’m really glad we’re having this conversation, given the diversity of perspectives on what Julia is and/or should be here. I’m especially interested in broadening the base of users (as is being discussed in the [parallel thread](https://discourse.julialang.org/t/can-juliac-increase-julia-adoption/127838/)), and the collection of compilation/deployment/GUIs recur in those kinds of discussions. I’m pursuing some nascent work in this general area, so this thread and others like it are enlightening. > [@uwestoehr](#): > > Person class 1 need software that “just works”. These are the people I generally support, so I fully agree here. The use case, as I refer to it, is building internal scientific, engineering, and analysis (SEA) tools for end users. (Note that this is roughly equivalent to [internal tools](https://budibase.com/internal-tools) development, though those tools generally target business/database users and are web-based. My users are technical analysts doing desktop modeling and simulation, but they typically aren’t writing low-level code. I’ve seen efforts to provide solutions in Python, but the bolt-on GUIs and deployment, not to mention performance, are problematic. I can easily see an opportunity for Julia here if we can address the issues that @uwestoehr is encountering. GUIs… the current state of this for cross-platform development isn’t great. There was yet another timely piece today speaking to the [difficult landscape here](https://tomscii.sig7.se/2025/04/The-Barium-Experiment). (BTW, I’m _not_ advocating for X-Windows and Lisp…). In this thread alone, we’ve heard about GTK, IMGUI, QT, and I’ve looked at pretty much everything else on the [list](https://en.wikipedia.org/wiki/List_of_widget_toolkits) at one time or another. My takeaways for Julia and GUIs for SEA are: - There are probably a limited set of higher-level “widgets” needed for this work; providing the whole, raw toolkit isn’t necessary, but of course as illustrated here, they are available if you wanted to go that route. But, I’m not sure Julia is your best language choice in that case. - The complexity of these toolkits, as well as the corresponding complexity of the IDEs (esp. drag and drop interface builders) for working with them isn’t necessary for building UIs for internal SEA tools, and that level of developer investment on the UI isn’t consistent with the workflow and priorities of the users, in my experience. This is why we see the rise of low-code/no-code tools in the business internal tools world (e.g. [ReTool](https://retool.com/), [Outsystems](https://www.outsystems.com/)…) So, frameworks and tooling for developers who support this class of users is where I think there is a sweet spot that Julia can fill. The closest existing solutions are, for example, tools integrated with MATLAB for building apps, and similarly for Mathematica. We’re not far off with Makie and Genie, which would need to be part of this solution due to their broad adoption. However, we don’t want to create another 2- (or 3- or 4-) language problem by requiring UI development to involve HTML+CSS+JS. And it all needs to be integrated with tooling that supports the kind of deployment workflow the OP presents. **I’m very interested in this thread or separately in what kinds of UIs are being built for these types of tools.** Finally, > [@uwestoehr](#): > > Thanks. I gave it a try, and the result is disappointing: One thing I _really_ appreciate about the Julia community is the help offered in going after these kinds of issues, and often getting workarounds and fixes out. Trust me, having come from a development community the suppresses bad news, this is really refreshing! Looking forward to working further with everyone on this challenge. ---

**Author:** ![Janis\_Erdmanis](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/janis_erdmanis/32/10869_2.png) [@Janis\_Erdmanis](https://discourse.julialang.org/u/Janis_Erdmanis)\ **Post date:** [April 10, 2025, 5:11am UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/37 "2025-04-10T05:11:13Z")

> [@MDSW](#): > > **I’m very interested in this thread or separately in what kinds of UIs are being built for these types of tools.** When preparing an answer to the NLNET AppBundler.jl grant application, I collected multiple impressive examples in a Slack thread on the GUI applications made in Julia. Perhaps this list can answer your question: - Makie: [https://makie.org/website/blogposts/showcases/](https://makie.org/website/blogposts/showcases/) - Makie: [GitHub - rakeshksr/ImageColorThresholderApp.jl: GUI tool for thresholding color images](https://github.com/rakeshksr/ImageColorThresholderApp.jl) - Makie: [https://www.youtube.com/watch?v=tv7-nGiik-w&t=66s](https://www.youtube.com/watch?v=tv7-nGiik-w&t=66s) - ClmGui: [https://arxiv.org/pdf/2407.07207](https://arxiv.org/pdf/2407.07207) - QML: [GitHub - PeaceFounder/PeaceFounderClient: A voting client for PeaceFounder system.](https://github.com/PeaceFounder/PeaceFounderClient) - QML: [https://www.youtube.com/watch?v=\_\_VP9cLe2HA](https://www.youtube.com/watch?v=__VP9cLe2HA) - Gtk: [MPIUI.jl/assets/mpilab.png at main · MagneticParticleImaging/MPIUI.jl · GitHub](https://github.com/MagneticParticleImaging/MPIUI.jl/blob/main/assets/mpilab.png) - Mousetrap: [Mousetrap · Mousetrap](https://clemens-cords.com/mousetrap) - Electron: [GitHub - JuliaHealth/KomaMRI.jl: Koma is a Pulseq-compatible framework to efficiently simulate Magnetic Resonance Imaging (MRI) acquisitions. The main focus of this package is to simulate general scenarios that could arise in pulse sequence development.](https://github.com/JuliaHealth/KomaMRI.jl) - Genie: [https://genieframework.com](https://genieframework.com/) - SDL2: [GitHub - NHDaly/PaddleBattle.jl: Example game written in julia using SDL2](https://github.com/NHDaly/PaddleBattle.jl) ---

**Author:** ![Anil\_Beniwal](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/anil_beniwal/32/217938_2.png) [@Anil\_Beniwal](https://discourse.julialang.org/u/Anil_Beniwal)\ **Post date:** [April 10, 2025, 11:15am UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/38 "2025-04-10T11:15:22Z")

> [@MDSW](#): > > We’re not far off with Makie and Genie, which would need to be part of this solution due to their broad adoption. However, we don’t want to create another 2- (or 3- or 4-) language problem by requiring UI development to involve HTML+CSS+JS. This is where webassembly (wasm) comes in. People like me want to make native app which they can also compile for web and get more users on unsupported platforms. e.g. egui.rs and [Rebuilding Prime Video UI with Rust and WebAssembly](https://www.infoq.com/presentations/prime-video-rust/). ---

**Author:** ![MDSW](https://avatars.discourse-cdn.com/v4/letter/m/94ad74/32.png) [@MDSW](https://discourse.julialang.org/u/MDSW)\ **Post date:** [April 10, 2025, 9:26pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/39 "2025-04-10T21:26:14Z")

Thanks – great list! I’ve seen a few of these before, but nice to have many more. I’m also interested in any internal tools anyone has built that may not be shared publicly; screenshots or descriptions of the controls used and functionality, to the extent possible, would be great. ---

**Author:** ![Eben60](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/eben60/32/13475_2.png) [@Eben60](https://discourse.julialang.org/u/Eben60)\ **Post date:** [April 12, 2025, 3:32pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/41 "2025-04-12T15:32:52Z")

On a general note - `juliac` is an _ **experimental** _ development under a _ **beta** _ version of Julia. Windows adds it’s own specific difficulties. Fortunately there are brave people there who are not afraid of all the frustrations to help the community to improve the tools 😉. However with all the effort I wouldn’t really expect to it to get production-ready in the close future. Another solution, which may or may not be acceptable for a use case like yours, would be to instruct the customer to perform a standard Julia installation on their computer, and the let your GUI software execute a Julia script to start a server, talk to the server, and shut it down in the end - all completely transparent. That’s what I have done with my LVServer.jl + LabVIEW0.jl packages ([[ANN] LabVIEW0 - Calling Julia from LabVIEW using ZeroMQ](https://discourse.julialang.org/t/ann-labview0-calling-julia-from-labview-using-zeromq/75033)). The communication is over [ZeroMQ](https://en.wikipedia.org/wiki/ZeroMQ), the data sent over as json (for large data amounts, sending in binary format was also supported). Unfortunately that all happened to become a solution without a problem, at least for me, but it worked nicely If there exists a working ZMQ implementation on the Lazarus side: The LVServer.jl can probably be used as is, otherwise easily adapted. There are also some other packages in the [JuliaInterop](https://juliahub.com/ui/Packages?q=JuliaInterop/). See also (may or not be relevant): - [Running Julia from JAVA? What is crazier?](https://discourse.julialang.org/t/running-julia-from-java-what-is-crazier/31662) , - [Calling Julia from within Java: JuliaCaller](https://discourse.julialang.org/t/calling-julia-from-within-java-juliacaller/48357), - [Using Julia from the JVM (Clojure)](https://discourse.julialang.org/t/using-julia-from-the-jvm-clojure/51052), - [Embedding Julia in Scala](https://discourse.julialang.org/t/embedding-julia-in-scala/97347), - [Jluna: a new Julia \<-\> C++ wrapper](https://discourse.julialang.org/t/jluna-a-new-julia-c-wrapper/77486). ---

**Author:** ![uwestoehr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/uwestoehr/32/216201_2.png) [@uwestoehr](https://discourse.julialang.org/u/uwestoehr)\ **Post date:** [April 12, 2025, 6:45pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/42 "2025-04-12T18:45:40Z")

> [@Eben60](#): > > On a general note - `juliac` is an _ **experimental** _ development I reported about PackageCompiler.jl This is a production-ready component of Julia and I cannot get it to work under Windows. But how is that possible? Only because the developers of PackageCompiler don’t user Windows for their projects. I will open a new discussion thread for this Windows issue. ---

**Author:** ![Palli](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/palli/32/3380_2.png) [@Palli](https://discourse.julialang.org/u/Palli)\ **Post date:** [April 14, 2025, 8:44pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/58 "2025-04-14T20:44:26Z")

> [@uwestoehr](#): > > A. standalone, precompiled application that runs under Windows > B. a UI > > A paid service is acceptable as long as my customers don’t have to pay something for the final program. We will take over the costs.2. Please consider AppBundler.jl: [![](https://global.discourse-cdn.com/julialang/original/3X/6/0/6074be9811b0da86ba58d6ad677769e6c525393d.jpeg "AppBundler.jl - Bundle your Julia GUI Application | Erdmanis | JuliaCon 2024") ](https://www.youtube.com/watch?v=wICPVpDa7aw) Note it bundles into one “installer-file”, it doesn’t precompile, but rather relies on Julia precompiling from the source code you distribute. I haven’t used it but I understand it might be even better on Windows than on Linux I use. For the GUI you can consider [GitHub - Clemapfel/Mousetrap.jl: Finally, a GUI Engine made for Julia](https://github.com/Clemapfel/Mousetrap.jl) though there are also other options. And FYI: > [@SyslabCC: Suzhou-Tongyuan's proprietary Julia AOT compiler is now available for free use (personal & educational license only)](https://discourse.julialang.org/t/syslabcc-suzhou-tongyuans-proprietary-julia-aot-compiler-is-now-available-for-free-use-personal-educational-license-only/114633): > > UPDATE: see examples and ask questions at the official GH repo [github.com/Suzhou-Tongyuan/JuliaCon2024-JuliaAOT](https://github.com/Suzhou-Tongyuan/JuliaCon2024-JuliaAOT/tree/main). This is an unofficial announcement of the Julia AOT compiler (SyslabCC) created by [Suzhou-Tongyuan](https://www.tongyuan.co/), and I am the one who lead the compiler team and designed the architecture. This compiler is now integrated into [MWORKS.Syslab](https://www.tongyuan.cc/Download), and you can find the documentations for the compiler at [SyslabCC](https://www.tongyuan.cc/help/SyslabHelp.html#/Doc/CodeGenerator.html). Unfortunately, it is written in Chinese due to our bandwidth, and I hope our circumstance n… > [@SyslabCC: Suzhou-Tongyuan's proprietary Julia AOT compiler is now available for free use (personal & educational license only)](https://discourse.julialang.org/t/syslabcc-suzhou-tongyuans-proprietary-julia-aot-compiler-is-now-available-for-free-use-personal-educational-license-only/114633/1): > > As an overview, I’d give as follow the features that the community would probably care about: > > 1. SyslabCC converts Julia programs into small binaries (executable or shared libs), **these binaries are small (1~2MB for small projects) and do not depend on libjulia**. > 2. SyslabCC supports **full multiple-dispatch** , but limited to a type-stable subset. > .. ---

**Author:** ![uwestoehr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/uwestoehr/32/216201_2.png) [@uwestoehr](https://discourse.julialang.org/u/uwestoehr)\ **Post date:** [April 14, 2025, 9:13pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/59 "2025-04-14T21:13:36Z")

> [@Palli](#): > > Please consider [AppBundler.jl](https://juliaregistries.github.io/General/packages/redirect_to_repo/AppBundler): I had a look and its author,@Janis_Erdmanis also posted in this thread. i think the way to go is PackageCompiler → lib, then using lib either in a C++ program + Qt or in a Lazarus program. Now that I got PackageCompiler to work I will give the latter a try the next days and report back. (by the way, since PackageCompiler works well with Julia 1.10, I downgraded to Julia 1.10 and noticed that my programs run faster that with 1.11 when executed the first time) Regarding **[Mousetrap.jl](https://github.com/Clemapfel/Mousetrap.jl)**, this is a really nice UI. The point with UIs is that for our programs we spend about 80% on the UI until all knobs behave as they should, are only active when they should etc. Therefore we need a UI that is driven by either a company or an active community. Mousetrap had its last commit more than a year ago. If we encounter bugs, we would have to fix them on our own but we don’t have the manpower and knowledge to dive into UI code. Regarding **[SyslabCC](https://discourse.julialang.org/t/syslabcc-suzhou-tongyuans-proprietary-julia-aot-compiler-is-now-available-for-free-use-personal-educational-license-only/114633)**, I had a look, but its webpage and the linked example leads me to a blank website, with only a menu in Chinese. ---

**Author:** ![Benny](https://avatars.discourse-cdn.com/v4/letter/b/49beb7/32.png) [@Benny](https://discourse.julialang.org/u/Benny)\ **Post date:** [April 14, 2025, 10:24pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/60 "2025-04-14T22:24:39Z")

> [@uwestoehr](#): > > Therefore we need a UI that is driven by either a company or an active community. That’s an entirely reasonable requirement, but that’s generally harder to come by in Julia, a language with relatively smaller user and developer communities. Improving base Julia’s capabilities, like trimmed binaries, could potentially make it feasible for more people to apply or integrate Julia into more things, but that’s not a sufficient condition. There’s plenty of other languages that already have those features yet suffer from ecosystem holes. Julia’s REPL workflow, which is shared by many other languages, works great for many things, and an interactive JIT really helped development and composability of many packages, but that came with a lot of weaknesses that other languages can avoid with different tradeoffs. I think commenters have been comprehensive about what the current ecosystem can do for the stated goal and upfront about the state of the limitations; we are in the same boat after all. To flip the question of Julia’s limitations, what strengths of Julia are you considering for your project? Precompiling a large/untrimmed PackageCompiler library is strong dedication to using Julia when you’re already writing C++, which is at least as performant and more easily so in some ways, on top of smaller binaries and a strong ecosystem. ---

**Author:** ![BambOoxX](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/bambooxx/32/22179_2.png) [@BambOoxX](https://discourse.julialang.org/u/BambOoxX)\ **Post date:** [April 15, 2025, 1:27pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/61 "2025-04-15T13:27:59Z")

Hi, after reading this whole thread I feel like it might help you that I share my own experience, although I believe we come from a very different starting point. I started using julia 4 years ago because I believed in the not Matlab, not python, but efficient to code and to run message. ### My experience of julia development of standalone GUIs. To sum it up, I have almost the same problem as you - I work on windows - I need to be able to share my work with colleagues that are not familiar with julia - I need to build GUIs that use julia as a backend However I guess I come from a purely scientific background with no experience whatsoever in statically compiled languages, just assume I knew matlab only. At first I figured, well a compiled (event though JIT compiled) should be callable at some point (again no experience in statically compiled languages, what is a pointer again ?) by other programs. My use case is basically to connect use julia with .NET GUIs. There again I figured somebody would have done the heavy lifting already. But no, it’s open source ecosystem, so you get what people or companies are willing to share, no more, no less. My cry for help (as well as some other people’s) was summarized in the following posts - [Correct process to use julia code from C# or VB .NET](https://discourse.julialang.org/t/correct-process-to-use-julia-code-from-c-or-vb-net/58018) - [Interoperability with .NET](https://discourse.julialang.org/t/interoperability-with-net/19611) Long story short, I could not find an “easy” solution to my problem. So then I figured how to handle it by myself as best as possible. My solution was, after several iterations to - Code my own scientific stuff - Create a JSON RPC Server based on [GitHub - julia-vscode/JSONRPC.jl: Julia implementation of JSON RPC](https://github.com/julia-vscode/JSONRPC.jl) - Package all of the above with PackageCompiler - Interface that to a JSON RPC Client on the GUI guide - Add the packaged julia to an installer handled in Visual Studio All in all, this was not easy. And saying everything is production ready would be a bold statement. But it is not so bad. Everything works as expected, it “just” required much more work reach that than anticipated. The compiled sysimage is still very big compared to the rest, but it is not dramatic either. So in a sense what you try to do is feasible, I use it regularly and my colleagues as well. Is it completely robust, and easy, or efficient right now, of course not. Will it reach that, I definitely hope so. My most recent sources of hope where [Mousetrap.jl](https://github.com/Clemapfel/Mousetrap.jl#displaying-a-glmakie-plot-in-a-mousetrap-window) and [QML.jl](https://github.com/JuliaGraphics/QML.jl), but there again, that means I have to move from .NET. And since we have several softwares in .NET it is unlikely. And as you pointed out Mousetrap does not feel trustworthy right now given its update history. So while I hope somebody will try and make .NET / Julia interop work, I am stuck with my solution. ### Windows and julia I fully understand your frustration about Windows vs other OS because I can only work with windows due to some of the proprietary software we use solely working on that platform. I surely met some obstacles to work with julia on windows, in particular the fact that some REPL modes do not work completely on windows like the shell mode, but far more important the fact that I cannot use `juliaup` on my professional computer, my company does not allow the microsoft store, it’s as simple as that. On the other hand, I find it much easier to work with julia on windows compared to Python, just because `Pkg` feels amazingly easier to use with regards to environments compared to `conda` or `pip`. Other than that the most problematic thing I had about julia’s way of doing things is that it is very github centric, but in the end that is where the community shined. I wanted to setup CI on local machines, on a Gitlab instance, and while julia itself was not making it easy [a lot of people helped me to reach a production level CI](https://discourse.julialang.org/t/julia-and-gitlab-self-hosted-a-state-of-the-art/86685) This is only my two cents there, I hope you feel somewhat less lonely with your julia/windows/gui issues. . ---

**Author:** ![Eben60](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/eben60/32/13475_2.png) [@Eben60](https://discourse.julialang.org/u/Eben60)\ **Post date:** [April 15, 2025, 1:51pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/62 "2025-04-15T13:51:52Z")

> [@BambOoxX](#): > > the fact that I cannot use `juliaup` on my professional computer, my company does not allow the microsoft store, it’s as simple as that. What about using `MSIX App Installer` for `juliaup`? The institution where I worked previously blocked MS Store, too, but then we could use the MSIX installer. ---

**Author:** ![joa-quim](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/joa-quim/32/227_2.png) [@joa-quim](https://discourse.julialang.org/u/joa-quim)\ **Post date:** [April 15, 2025, 2:15pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/63 "2025-04-15T14:15:05Z")

Don’t get it. What is the problem with the `julia-1.XXX-win64.exe` installer? - It let us easily select an alternative installation directory. One that is not a **hidden directory** , like what the default proposes and don’t know if `juliaup` shows (never used, nor will use, `juliaup` on Windows) - One can easily choose what Julia version to install, instead of automatically install latest and slowest to start/compile. ---

**Author:** ![mbauman](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mbauman/32/31082_2.png) [@mbauman](https://discourse.julialang.org/u/mbauman)\ **Post date:** [April 15, 2025, 3:01pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/64 "2025-04-15T15:01:53Z")

Friendly mod note here — I just detangled the discussion around the PackageCompiler hang as best I could from this more general purpose brainstorming thread around distributing windows UIs built with (or including) Julia. There’s already been quite a bit of discussion around Windows installer methods in the concurrent [About Julia's development policy regarding Windows](https://discourse.julialang.org/t/about-julias-development-policy-regarding-windows/128011/) topic. Let’s try to keep this topic here focused on building and distributing Windows UIs. ---

**Author:** ![Palli](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/palli/32/3380_2.png) [@Palli](https://discourse.julialang.org/u/Palli)\ **Post date:** [April 15, 2025, 3:52pm UTC](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823/65 "2025-04-15T15:52:20Z")

> [@uwestoehr](#): > > For Lazarus you can drop the components you like in the designer and its code is automatically added. You can also set up the different UI features via the UI of the Lazarus IDE. If your expectation is something like Lazarus or Delphi, with a GUI builder (with company support, or like C#/.NET) then I think you’ll find nothing similar for Julia. FYI this thread (you can use Julia with other languages, e.g. Delphi, though likely not many have done so before you): > [@Switch from Delphi/Pascal to Julia](https://discourse.julialang.org/t/switch-from-delphi-pascal-to-julia/66254/7): > > We had an old reactor model in Delphi. Rewrote into Julia. Speed-up 100x and much more maintainable. The only downside is not being able to easily compile to a DLL, but there are workarounds. You can expect (I’ve seen up to 100x claimed, also elsewhere, vs Delphi, despite it compiled, and not a slow language/compiler) speedup in runtime with Julia (maybe the reason you adopted Julia, why did you? Did you read misleading claims about the ecosystem?), but development time for the GUI is likely worse. I don’t know which GUI toolkit is best for Julia (haven’t used any of them). None of the GUI options, or web based options, have company support with Julia (one did, for web, then Julia support made unofficial again). Mousetrap is based on Gtk, but understand made simpler, why I suggested it over Gtk or Qt. Qt/QML is another option, has company support (when used natively, i.e. with C++), and I believe it has a GUI builder. [https://www.chiefdelphi.com/t/coroutines-are-way-better-than-commands/438376/24?page=2](https://www.chiefdelphi.com/t/coroutines-are-way-better-than-commands/438376/24?page=2) > I am continually impressed at what Julia language (pyjulia) can do with making julia calls from within python. If you want to make the GUI with Python, then I suggest PythonCall.jl, not older pyjulia. > **[Embedding Julia](https://julia-users.narkive.com/gHYDDVJT/embedding-julia)** > I think Julia does not like Windows. I don’t think that’s true (only minor issues, and Windows not neglected, despite Julia developed first on Linux only), if anything Windows or (its) virus checkers do not like Julia… slowing down, but such Windows issues affect mostly any language equally. [Previous page](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823.md?page=1) [Next page](https://discourse.julialang.org/t/how-to-create-standalone-applications-for-windows-with-a-g-ui-in-julia-1-11-or-1-12/127823.md?page=3)