Hacker News Reader

Comment by jjaredsimpson | Hacker News Reader

Watching him occasionally stream his sessions shows me that what he is doing is just funzies.

His tooling is so far behind anything all other languages have that I would never bother to learn this language, because it was "for games."

If I wanted to make a game I would learn any engine using any number of language bindings.

View on HN

He's been working on this project mostly alone for only a few months, how can you possibly expect the tooling to be on par with anything else.

There's a reason it's not released.

And it's great that you can just pick up an engine, but someone's gotta write that engine, and there's a reason triple a studios aren't using unity for major releases; you'll never get quite as good performance out of a general purpose engine as you would from a custom one.

> there's a reason triple a studios aren't using unity for major releases

They are, however, using Unreal Engine for tons of major releases.

But most of those major releases require some amount of custom work on the engine. They still need C++ programmers who can understand what's going on under the hood.

Hearthstone (by Blizzard) is a Unity game, not that performance is a huge concern for card games. It's a pretty thin client mainly for displaying the animations/artwork while most of the logic runs serverside.

Still, it's a very profitable game by a triple A company.

Hearthstone isn't what anyone would normally call a AAA game though. Until the end of the beta they only had 15 employees working on it.

They basically had to use an established engine because they didn't have the budget to build their own.

>Hearthstone (by Blizzard) is a Unity game,

And I asked myself why Hearthstone stresses my system so much. Now it's clear.

Endless Legend, Endless Space by Amplitude Games are all made in Unity. While not AAA FPS, they are certainly not trivial games.

JAI is for games in the sense that reflects the experience of a well known game developer that writes game engines and games.

And also in the sense that it allows you to easily remove the safety checks when you need higher performance while Rust doesn't necessarily allow it (array access for example). So I'd say that Rust seems more suited to write an OS, a webbrowser as in both cases safety is critical and Jai for games as performance is critical. For other applications which needs low latency (so no GC) but are neither safety critical nor performance critical? Jai's 'look and feel' seems to me much more seducing than Rust (assuming/hoping Jai becomes real).

Rust does let you do unsafe array indexing and other unsafe stuff. But it doesn't support switching the semantics of safe code to unsafe with a build flag, you need to explicitly use "unsafe" in code.

> But it doesn't support switching the semantics of safe code to unsafe with a build flag

Jai allow this for array indexing AND it also allow the reverse: reinserting array checks even when there is an 'unsafe access' operation: this way even if you made a mistake in adding an 'unsafe access' operation it's easy to find where the error is (assuming the error is reproducible of course).

I haven't seen any cases in which adding a global build flag to turn off bounds checks would actually improve performance. People overfocus on bounds checks because they're an easy thing to understand, but they're just one of many performance issues when creating a new language, and not a particularly interesting one at that since APIs, compiler optimizations, and branch predictors all conspire to drive their overhead down to near-zero (in my experience).

Sure, but I think that having one global flag to remove bound checks is useful as it allows you to measure this bounds checks performance impact easily. And then when you know how long it takes to find an index out-of-bound error and you see that the removal performance improve is small.. Well, you remove the flag.

Reply on news.ycombinator.com