From my experience, a tiny alarm sounds, a voice says cyclist approaching and the door clicks to locked. At least I believe it did, I heard a sound. I didn't check the handle.
I don't believe the car was specifically in a bike lane at this time but I'm new to the city and may have missed the markings.
Elektrek went from insufferably pro Tesla to insufferably anti Tesla. If you liked it before and not now, your quarrel is with the direction of the propaganda.
We support thread-pausing via instrumentation. This can cause threads to observe different interleavings, which can help uncover bugs in concurrent algorithms. At this time, we don't perform specific memory model fault injection or fuzzing.
I wrote a library called Temper, which simulates the Rust/C++ memory model with atomics in a similar way to Loom. But it goes much deeper on that narrow domain, and to my knowledge it's the most accurate library of its kind with the largest set of test cases.
If you simulate using mock CPU instructions like memfence or LL/CS there's no guarantee your model fits your ultimately executed program.
Unless of course, you do something like antithesis and directly test what compiled. It's an interesting alternative world.
I've taken the liberty of adding you to LinkedIn - would love to grab a drink next time you're in the SF Bay area.
There's not a lot of churn in Unity, but that's more because they mostly fail to ship anything of significance than due to excellence in backwards compatibility.
I was in the audience when DOTS was announced, and a decade later Cities Skylines II showed how ill equipped for prime time it remains (not that the developers were blameless).
Deprecating entire languages (probably the right call long term, oddly enough Godot is keeping GDScript around).
Render pipelines (URP and HDRP to be merged, built in likewise being deprecated).
Most of the things around DOTS.
Most of the things around networking.
The whole package management system (I mean, it’s a nice idea, still counts as churn).
Also multiple approaches to UI and input.
I would say that a lot of the new stuff is built on good ideas but I sometimes wish they’d slow down a bit and ship actually thought out and finished features.
And most of the above already had alternatives previously, this isn’t even getting into wholly new things like Sentis, if you are working on an old project thankfully it will mostly keep working, but if you need to keep up to date with the current mechanisms and practices, there’s a lot of churn.
Maybe not as much as in Godot, but to be honest that other engine is going through a lot of evolution so instability and a feature explosion is to be expected (despite terrain still being a plugin, while Unity’s own terrain implementation is oddly dated and abandoned, while their water system felt like a tech demo and more often than not the asset store is expected to do the heavy lifting), while Unity tries to appeal to everyone and capture headlines it seems. Just look at the marketing around DOTS (and how long it took for it to be usable).
A lot of the things you mention there have been in development for the better part of 10 years already, and still haven't reach a stable, mature and production-ready state yet. Unity have also kept deprecated stuff around for much longer than they should have, which sounds great on paper for backward compatibility, but it just means they're lugging years of technical debt with them and it's slowed them down immensely.
Looking at the past year of Unity updates, since 6.1 or so, it seems that most of the focus is now going to refactoring major parts of the engine to facilitate backporting HDRP's feature set to URP. It's all good work and high time they did some cleanup and committed to a single standardized render pipeline, but it's not exactly moving the needle forward very much yet.
> (probably the right call long term, oddly enough Godot is keeping GDScript around).
Even in Unity 4, it was like "You can write scripts in C#, or you can also write them in Unityscript or Boo, I suppose..."
In comparison for Godot, GDScript is very often the happy path. Things like web publishing work more seamlessly with GDScript than with C# (and miles more than GDNative/GDExtension). So I don't think it's nearly as likely to get deprecated as Unity's scripting languages.
The obvious additional good from this approach is that you no longer couple everything so tightly with just one scripting language, so in some ways it's a bit easier to introduce bindings for other languages. The downside, however, is that it leads to fragmentation in the community, duplication of effort (suddenly you need the double amount of docs), more difficulty and friction in development with new mechanisms demanding that you take the limitations of both languages in mind, oh and if you dare to write your own language then suddenly you have to support both it, as well as any dev tools for it. For what was and still is a communtiy project without strong financial backing (just look at how much money Unity burns on useless stuff, and how much more the people behind Godot could do with that money), that's quite the gamble.
Maybe if they focused on the core engine more, then deltaV: Rings of Saturn wouldn't have odd performance issues for a 2D game and wouldn't get confused with multi-monitor setups. Maybe Road To Vostok wouldn't crash when loading into the Village map on an Intel Arc GPU, and also start on the wrong monitor same as deltaV. Maybe even demos like "Realistic Jungle Demo" on itch.io wouldn't have all white textures on said Intel Arc GPU. Maybe we'd be two or three whole releases of features ahead by now, if all of the hours spent on GDScript to date would have been spent elsewhere.
On the other hand, there's no guarantee that any of those devs would fix the other issues if their efforts were to be redirected. Similarly, if they didn't try with GDScript, the community would be smaller, due to its ease of prototyping, and being simpler and more approachable for the folks who don't know C# yet, even if it's also unnecessary to the folks who like tools like Rider/Visual Studio or are coming from Unity or engines with scripting in C# or just C++. I'm pretty split on it overall.
> Or maybe without GDScript the engine would not get the traction it has and would not have the resources to do anything at all.
Or the developers might not find C# to be as interesting to work on and some people that stick around in part due to getting to iterate on GDScript wouldn’t contribute at all! All of those are possibilities, that’s for sure, Godot definitely has a lot of appeal due to fast prototyping too!
> Intel Arc GPU rendering issues have nothing to do with Godot’s choice of high-level scripting language.
The GitHub repo for Godot has 83'164 commits. Let me pull an arbitrary unimportant number out of my ass, which is 6 hours of work per commit on average (lots of small ones, some that take weeks, doesn't matter) and we get 498'984 hours which we can round to 500k for our napkin maths.
There's around 52k LoC for the gdscript module, about 1'380 files. Around 5% of the overall commits in the repo are in that module, we can up that to like 7% to account for docs and editor and other parts, but we don't have to assume higher. That gives us about 35k hours spent on GDScript.
Remove GDScript and you get 35k hours to put elsewhere, including Intel Arc support. It's the exact same principle of Linux distros having like a dozen desktop environments and the efforts being so fragmented that it's impossible to make a single really good one (though there are different goals for the projects, for example KDE vs something lightweight like LXQt).
Of course, I addressed the possibility that people working on GDScript just wouldn't be able to work on the other stuff, so one should argue that redistributing work would be quite complex and since it's a lot of volunteer work, people might just not care to work on X instead of Y, that was addressed here:
> On the other hand, there's no guarantee that any of those devs would fix the other issues if their efforts were to be redirected.
That said, the above is more or less why Unity benefitted in regards to development velocity from saying goodbye to ECMAScript and Boo (or maybe they shot themselves in the foot, cause prototyping is slower compared to GDScript).
Compile times are my biggest struggle, too. I'm vibecoding Bevy with parallel agents, and the bottleneck is often compiling the changes on my 7950X, not getting Codex to write them.
As far as file sizes go, I'd be really interested in how a Rust compiler that didn't monomorphize so much would perform. Right now you have to modify the source code to write polymorphic generic functions, but it doesn't strictly have to be that way (at least as far as I can see).
I wouldn't use Bevy for a web only game either, especially while it's still single threaded on WASM.
This site is excellent. I emailed the author to thank them after reading it cover to cover, and they replied and asked if anything was unclear or if there was anything I wanted to see explored more.
There are reasons it might not work, not least of all political. But a link to a paper picking a bone with LCoE is talking past GP.
reply