
Godot Editor running in a web browser - SquareWheel
https://godotengine.org/article/godot-editor-running-web-browser
======
t0astbread
I'm still amazed how small the Godot editor is (last time I checked it was
~25MB). Just how are they able to pack this much functionality into such
little space?

~~~
gjkood
I guess its all relative.

In the late 80s I was impressed by a full Wordstar compatible text editor for
Turbo Pascal which only occupied 25K (including the compiler). Times have
indeed changed.

~~~
gnulinux
1 order of magnitude in 40 years? Doesn't seem a lot, but if applies
exponentially would mean we will have some IDE in 2060 that's 25GB and someone
will find it impressive. That's a lot of bytes for an editor.

~~~
kencausey
Defining an 'order of magnitude' as 1024 seems a little odd to me. I would
consider this to be closer to 3 orders of magnitued.

~~~
eggy
1024 (2^10) is ~10^3 (I know switching bases!) vs say 10 (10^1), so two orders
of magnitude larger in general. A gig 10^9 would be many orders of magnitude.
An order of magnitude is generally a jump to the next power of 10. So 10
(10^1) is an order of magnitude larger than 1 (10^0) as 100 (10^2) is to 10
(10^1), and so on. People frequently misuse the term when speaking in
technical terms. When the average person uses it to denote a big jump, I let
it go - usually ;) If you stick with base 2 I guess you could say many orders
of magnitude (2^32 = 4,294,967,296 vs 2^8 = 256, or 24 orders of magnitude?).

~~~
jovdg
But you could use Base-1024, in which case the term is used correctly. It's
all relative ;)

~~~
eggy
Why? The common base is 10, and "orders of magnitude" is normally based on 10X
between orders here. Ten fingers, decimal system, etc. Don't bring up metric
vs. Imperial ;)

I work at an engineering firm, and that's how most engineers understand it.

------
rawoke083600
Honest question.. Is this "just" the way modern gamedev is being done. With
these "Editors For Scenes" ?

Like the Unity and Unreal Editors ? Not hating just asking last time I
"checked in" on gamedev was prob one or two decades ago and had a lot of fun
with IrrLicht and Ogre.

Does this "editor approach" not get in the way ? Just looking in as an
outsider with almost zero gamedev experience.. don't you end up fighting the
editor to just get things done ?

Again don't flame me I have no idea what I'm talking about :)

PS. GoDot looks great :)

~~~
pjmlp
That has been the way that AAA game development has worked the last 25 years.

Professional games are like movies, programmers are a tiny percentage of
people on the set.

They are the ones caring for the lights, that all cables are working properly
and special effects go off as they should.

The main role, what dictates what a game is all about, belongs to game
designers, producers, artists, those aren't writing C++ code, rather using
visual tools.

Naturally you can make a game old style, just like on the 8 and 16 bit days,
just like there are people doing movies just with an handy-cam.

The outcome isn't not going to be same though.

~~~
rawoke083600
Gotcha !

------
msie
Godot is such an amazing/polished game engine. I like it a lot more than Unity
(at least for 2D).

~~~
turova
One thing that I think would hugely shift godot's market share is a
standardized asset format, similar to what Unity and Unreal have, so asset
developers could offer assets in Godot-compatible format. It would be even
more amazing if there was an easy way to import Unity resources. Maybe I just
needed to do more research, but last time I tried, I had to pull out
individual files, mess around with them in Blender, then import the model and
the mesh into Godot separately, where I needed to arrange them together
afterward. I think if the asset management was as simple as Unity's, Godot
would be a no-brainer in many projects, especially smaller ones.

~~~
georgeecollins
Maybe, but let me question that. What standardized asset bundles also do is
create a market for asset bundles, which is good for the company they support.
They also let new people buy a package of assets. Those aren't big issues for
me, but I have never tried to make a commercial scale game in Godot.

Versioning is the nightmare of Unity. So many assets and plug ins only work
with certain versions.

~~~
aidenn0
A friend of mine is developing a commercial game with unity, and that's been a
big issue. It's either don't get big fixes or rework parts to upgrade unity

------
oknoorap
Godot is truly real competitor to unity in OSS world, good job, I'll waiting
this feature until it's not buggy.

------
andai
I get a black screen and the JS error "Atomics is not defined." Did we
overload it?

~~~
shortercode
Atomics is part of the threading APIs, I'm guessing your browser doesn't
support it. Although I feel like you should get a better error message...

~~~
john4532452
That's strange, this project is funded by mozilla and does not run on latest
firefox

~~~
rewq4321
It says in the blog post you need to use Firefox Nightly

------
joeberon
Kinda strange but Godot kinda feels like a game dev oriented smalltalk to me

------
anderspitman
This is awesome. Question: everything I've read[0] about WebDAV indicates tons
of compatibility problems between implementations, even those built into
operating systems. I wonder what the plan is to deal with that?

Also, are there any off-the-shelf WebDAV client libraries for browsers?

[0]:
[https://news.ycombinator.com/item?id=10213657](https://news.ycombinator.com/item?id=10213657)

------
skybrian
I'm not a game developer but it seems like syncing with a standard git repo
would be ideal. Is that possible with games or do the assets prevent it?

~~~
gfxgirl
Smallish indie projects get by with git and or git lfs. git isn't really
designed for binary assets and large games with terabytes of source assets
usually don't use git. git's distributed nature is also an issue for non-
mergable binary assets. The most common tool version control for bigger teams
is perforce. It's significantly faster than git for binary files and it helps
manage 2 or more people trying it edit the same binary file. There maybe be
other bolt on solutions for that for git that I'm unaware of to help with
that.

~~~
lima
SVN is also quite popular, it's okay at dealing with large repos.

------
antoineMoPa
I wonder when firefox will re enable SharedArrayBuffer.

~~~
jszymborski
Seeing as it's available in Firefox Nightly, it'd imagine it'd be in the next
release provided it doesn't present any problems from then and now.

~~~
zamadatix
A feature introduced in e.g. Nightly 78 might stay out of stable until say
version 86. That is features make it to stable by becoming stable not because
it first landed in a certain nightly and so everything was held up until all
features in that nightly became stable. Releases happen on a fixed 4 week
calendar cycle instead.

Based on
[https://bugzilla.mozilla.org/show_bug.cgi?id=1563480](https://bugzilla.mozilla.org/show_bug.cgi?id=1563480)
I'd say it's probably a good number of releases away.

~~~
hoten
Here's some context you didn't ask for, but hope you find it helpful.

There's standardization work being done to enable SAB behind a new security
context. Mozilla has a good summary: [https://developer.mozilla.org/en-
US/docs/Web/JavaScript/Refe...](https://developer.mozilla.org/en-
US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/Planned_changes)

At the moment, I think only Chromium enables SAB by default for devices that
have "Site Isolation" enabled (avoids spectre attacks by using process
isolation). That's a browser feature specific to Chromium, and is disable for
some low-memory devices, so it's not universal.

I'm not familiar with how far along Chromium or Firefox are. If you're
interested in using SAB, start reading up on COOP and COEP.

Source: I work on web tooling at Chrome.

------
gentleman11
How is Godots performance these days? I heard they are adding a ton of c#
support after a lot of people have struggled with frame rates in gdscript
(source: various youtubers who use Godot)

I just switched from unity to unreal because of sketchy retroactive licensing
changes from unity and the performance in unreal is really making me happy so
far

~~~
GaryNumanVevo
I wrote a large scale fluid sim (like Cities Skylines' water sim) with Godot
and Rust. I think the biggest bottle neck is the gdscript honestly. I had a
prototype working in GDScript and after I ported it to rust I had like a 20x
speed up

------
msla
Is the wait nearly over?

BTW, how do they pronounce the name?

~~~
maxeonyx
"goh-doh" or "goh-doht" The 'o's are pronounced the same.

------
stakkur
I've been waiting for this.

------
z3t4
It's amazing that a native Windows/Mac app can be compiled to run in a web
browser. However Web-assembly does not mean better performance. A native
browser app would most likely be faster.

~~~
nightowl_games
What do you mean by native browser app? Like JS + WebGL?

~~~
z3t4
JS is usually not the bottleneck in web apps. The bottleneck is most of the
time rendering. Rewriting the app in JS would make it faster then the
Webassembly version. It's a common misconception that Webassembly is faster
then JS. Although theoretically possible, the compiler wouldn't be able to
beat a skilled JS developer's hand written JS specific for the web platform. A
turtle is faster then a rabbit - in water.

~~~
andai
Is this true? I was under the impression that webassembly was capable of
faster performance than JS, and thinking about learning a compiled languages
to make my web applications faster. Would that be a waste of time?

~~~
z3t4
It would not be a waste of time if you learned something. Here's a quick
exercise: Write an "hello world" app and compile it to WebAssembly. Then open
browser dev tools to inspect the app. You will see that a middle layer is
needed to put that "hello world" on the screen. Just like JS, WebAssembly
can't talk directly to the hardware and need to use the same browser API's as
JS.

Besides obfuscating and being able to compile desktop apps to the web
platform, one use-case for WebAssembly that might bring an performance
improvement is to use it for something you currently use a Web Worker for. For
example sending a bit buffer to the worker, have it do some work on it, and
send it back. There is however a penalty to sending the data back and forth,
although there are work being done that allows shared memory, which will make
both JS and Web-assembly faster.

JavaScript is compiled to optimized native code. So you will get away with
really stupid code - the optimizer will make it fast. But the more you learn,
you will be able to write even faster apps. It really doesn't matter what
programming language you use, it's more important to have experience and
tribal knowledge of the platform you are targeting.

A funny thing about performance is that the more you know, the slower your app
could become. If you for example use highly sophisticated abstractions, make
use of frameworks and preprocessors, together with an orchestra of cloud
functions and services with IPC message across oceans - then it will be slow.
If you want performance - just keep it simple.

