# State of Julia Interactive Apps, Executables and WebApps
**URL:** https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200
**Category:** General Usage
**Tags:** webapps, package-compiler, app
**Created:** [November 28, 2025, 8:19pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200 "2025-11-28T20:19:11Z")
**Posts on this page:** 10
**Page:** 1
### Author:  [@Maddy](https://discourse.julialang.org/u/Maddy)
#### Post date: [November 28, 2025, 8:19pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/1 "2025-11-28T20:19:11Z")
I want to share my simulation online to users with different machines (Windows, MacBooks, Linux), etc., without them having to download Julia. Is there a clear, simple way to do so right now?
The 2 things that I have in mind are:
- I can create a Web app. Create maybe an embeddable, or some file that I can run through JavaScript on my website, and that people can interact with, play around, and have to install nothing. I don’t know if a browser would natively be able to do this, or I would have to have a server running that hosts my simulation on the website, and only then can this be possible (if it even is)
- On the other hand, I would love to know about a simple way to create an executable file that is complete on its own. I can just download it on any machine, and it will most likely run.
I’ve seen some of these things here, but I would still like the experts to put down their notes here, for I feel it is really hard for beginners who are not proficient in dealing with computer languages and the system for 10 years to get started with Julia and read all the fancy documentation. Even though some of this might be repetitive, I would love to again have this one place where all this information is present in a clear and simple manner.
I apologize if you think this is not a good post, and I should spend more time digging into examples and documentation myself.
Thank you so much.
---
### Author:  [@yolhan\_mannes](https://discourse.julialang.org/u/yolhan_mannes)
#### Post date: [November 28, 2025, 9:55pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/2 "2025-11-28T21:55:30Z")
I think Genie is the most fully featured one, as of my favourite it may be Oxygen.jl or Bonito.jl but they are lower level indeed and some js may be needed. I would still say go to Genie if you want both help from the Devs and a wither family of feature without even talking about the docs and the no code possibilities which are great already in Genie.
Ps : if your project is industry related don’t hesitate to talk to Juliahub I’m sure they are nice and may give you better advice than any of us
---
### Author:  [@sdanisch](https://discourse.julialang.org/u/sdanisch)
#### Post date: [November 28, 2025, 10:00pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/3 "2025-11-28T22:00:41Z")
That the WGLMakie docs are broken is really unfortunate, but this is because of vitepress which we use to build the docs and not because WGLMakie is broken… We should at least add a note about this until we’ve fixed it.
Bonito is not broken on mobile, Bonito itself doesn’t do much styling for you so one needs to use a mobile optimized framework with bonito or do it yourself 😉
Anyways, if your simulations are in Julia it will be very hard to let users interact with it unless you cache all possible combinations (combinatorial explosion) or compile Julia to JavaScript (not yet possible).
I’d say your best bet is to setup a simple Julia server which uses WGLMakie and bonito to create a simple dashboard.
This will require a server, but you won’t need to write any JavaScript. Unless you can easily precompute all your simulation results, a server will be the only way. I can point you to some docs once I’m back at my pc.
---
### Author:  [@sdanisch](https://discourse.julialang.org/u/sdanisch)
#### Post date: [November 28, 2025, 10:04pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/4 "2025-11-28T22:04:08Z")
Using [https://bonitobook.org](https://bonitobook.org) could be a simple way to show your results in a mobile optimized way, and it’s much less low level then bonito.
You can still serve it like any other bonito app though 🙂
---
### Author:  [@sdanisch](https://discourse.julialang.org/u/sdanisch)
#### Post date: [November 28, 2025, 10:05pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/5 "2025-11-28T22:05:46Z")
You should also have a look at:
> [@\[ANN\] AppBundler.jl - Bundle Your Julia GUI Application](https://discourse.julialang.org/t/ann-appbundler-jl-bundle-your-julia-gui-application/106971):
>
> I am excited to announce [AppBundler.jl](https://github.com/PeaceFounder/AppBundler.jl) partying_face The package offers recipes for building Julia GUI applications in modern desktop application installer formats. It uses Snap for Linux, MSIX for Windows, and DMG for MacOS as targets. It bundles full Julia within the app, which, together with artifact caching stored in scratch space, allows the bundling to be done quickly, significantly shortening the feedback loop. The build product of AppBundler.jl is a bundle that can be conveniently fi…
Bonito, Bonitobook and Makie seem to bundle fine, although GLMakie had some fixable problems on windows
---
### Author:  [@Maddy](https://discourse.julialang.org/u/Maddy)
#### Post date: [November 28, 2025, 10:45pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/6 "2025-11-28T22:45:29Z")
@sdanisch
I was able to write
```julia-auto
using WGLMakie, Observables
using GeometryBasics: Point3f, Sphere
import Bonito as D
import Bonito.TailwindDashboard as DOM
WGLMakie.activate!()
Makie.inline!(true)
app = App() do session
# sliders
sx = D.Slider("x", -5.0:0.1:5.0, value=0.0)
sy = D.Slider("y", -5.0:0.1:5.0, value=0.0)
sz = D.Slider("z", -5.0:0.1:5.0, value=0.0)
# --- WRAP Bonito slider values into real Makie Observables ---
ox = Observable(sx.value[])
oy = Observable(sy.value[])
oz = Observable(sz.value[])
# connect Bonito-side events → Makie Observables
on(sx.value) do v
ox[] = v
end
on(sy.value) do v
oy[] = v
end
on(sz.value) do v
oz[] = v
end
# 3D point observable
p = @lift([Point3f($ox, $oy, $oz)])
# scene
scene = Scene(camera=cam3d!, size=(700, 600))
meshscatter!(scene, p;
marker=Sphere(Point3f(0), 1.0),
color=:red,
space=:data,
markersize=1.0
)
# cube outline
cube_vertices = [
Point3f(-5, -5, -5), Point3f(5, -5, -5), Point3f(5, 5, -5), Point3f(-5, 5, -5),
Point3f(-5, -5, 5), Point3f(5, -5, 5), Point3f(5, 5, 5), Point3f(-5, 5, 5)
]
for i in 1:4
lines!(scene, [cube_vertices[i], cube_vertices[mod1(i + 1, 4)]], color=:gray)
lines!(scene, [cube_vertices[i+4], cube_vertices[mod1(i + 1, 4)+4]], color=:gray)
lines!(scene, [cube_vertices[i], cube_vertices[i+4]], color=:gray)
end
## Add ambiently rotating surface
N = 60
function xy_data(x, y)
r = sqrt(x^2 + y^2)
r == 0.0 ? 1f0 : (sin(r) / r)
end
l = range(-10, stop=10, length=N)
z = Float32[xy_data(x, y) for x in l, y in l]
z_rot_angle = Observable(0.0f0)
# Simple rotation matrix around z-axis as an observable
rotation_model = @lift(Makie.rotationmatrix_z($z_rot_angle))
surface!(scene, -5 .. 5, -5 .. 5, z;
colormap=:Spectral,
model=rotation_model,
transparency=true,
alpha=0.7
)
center!(scene)
# Update rotation angle over time
@async begin
while true
z_rot_angle[] += 0.01
sleep(0.03)
end
end
w = WGLMakie.WithConfig(scene; use_html_widget=true)
Bonito.record_states(session, DOM.div(D.FlexRow(
D.FlexCol(sx, sy, sz), # controls
DOM.div(w) # 3D scene
); align_items="center", justify_content="center", height="100vh"))
end
server = Bonito.Server(app, "0.0.0.0", 80)
Bonito.export_static("webgl_demo_3D.html", app)
```
I was able to write this, reading up your documentation on WGLMakie.jl and Bonito.jl. Is there any way possible that I can have the nonstatic objects in Scene, including my custom mesh and surface objects, be saved as web elements that I can embed in a website?
I will surely check out BonitoBook. Does it require users to have Julia installed, though? Can it handle such complex scenes and objects and real time renders and updates?
Also, what do you think about PackageCompiler for creating redistributable .exe files for such Makie interactive Scenes?
---
### Author:  [@Maddy](https://discourse.julialang.org/u/Maddy)
#### Post date: [November 28, 2025, 10:54pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/7 "2025-11-28T22:54:00Z")
This seems really interesting. Although I still don’t see anywhere it says that it can produce a simple .exe file.
Can that not be done in Julia at all? A simple .ext file that contains all the required code in itself that can be clicked on by a non-technical person and used for whatever the usecase of the application is?
---
### Author:  [@Maddy](https://discourse.julialang.org/u/Maddy)
#### Post date: [November 28, 2025, 10:57pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/8 "2025-11-28T22:57:47Z")
I think since @sdanisch has contributed to both the projects, Bonito.jl would be best for my use case, since my simulations are primarily on GLMakie. However, I will certainly check out Genie and Oxygen.jl.
I used to like JuliaHub. But for some reason, I can no longer use it for free, and have to pay them for the web servers running the session. My project is really research-related, not so much the industry. But I would give it a try! Thanks!
---
### Author:  [@MDSW](https://discourse.julialang.org/u/MDSW)
#### Post date: [November 29, 2025, 3:25pm UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/9 "2025-11-29T15:25:07Z")
> [@Maddy](#):
>
> Although I still don’t see anywhere it says that it can produce a simple .exe file.
>
> Can that not be done in Julia at all?
The short answer is, not in a really satisfying way. `PackageCompiler` and `AppBundler` are the best solutions; `juliac` with `--trim` are considered experimental and come with limitations. Here’s my understanding of generally what the issues are:
1. Julia has a large runtime composed of both Julia-specific code that provides much of the dynamicity, as well as a number of external dependencies packaged as dynamic libraries. If you want the whole Julia experience, you pretty much need the whole of these. PackageCompiler+AppBundler take care of collecting all of these. But it’s not going to be a small, simple, single-file exe.
2. You can’t cross-compile. So, if you precompile, it has to be for the same platform. Otherwise, you basically have to ship the code and the compiler (LLVM… it’s one of those not-small dependencies), and build it on first run on the user’s target machine. Again, the excellent AppBundler will help with this when you target for another platform.
3. There are also choices about the dependencies (packages) your code relies on and whether they are bundled (and similarly precompiled) or hydrated on the target machine (if possible, i.e. it’s not “air-gapped”).
4. `juliac` compiles, but again, only to the current platform for the moment. I believe there are currently some other limitations, but this is still considered experimental.
5. The `--trim` option on `juliac`, which will eventually be merged with PackageCompiler in some manner, as best as I can tell looks to see which of the DLL dependencies you don’t need, and drops them. It’s a sort of coarse-grained dead code elimination.
6. Another (still experimental) approach is to ship as an “app” managed by `Pkg`: [6. Apps · Pkg.jl](https://pkgdocs.julialang.org/dev/apps/). Of course, your target user needs to have a full installation of Julia for this, and of course it’s not really a .exe.
[As stated here](https://discourse.julialang.org/t/where-is-julia-heading-lack-of-clarity-about-priorities-long-term-direction-and-governance/133734/45), shipping binaries is not considered a “core Julia idea.” That said, as you can see, there are a number of lines of effort to offer solutions, but these will always have some limitations if you’re thinking about Julia like C or golang in this respect. While it may be possible to generate small binaries, they are only going to be small-to-distribute to the degree they don’t depend on the Julia runtime components.
---
### Author:  [@Maddy](https://discourse.julialang.org/u/Maddy)
#### Post date: [December 1, 2025, 2:50am UTC](https://discourse.julialang.org/t/state-of-julia-interactive-apps-executables-and-webapps/134200/10 "2025-12-01T02:50:43Z")
Sad to hear. But thank you for the details!