Thanks, but that’s not what I’ve wanted the help for.

The standard answer is C/C++.

The nonstandard answers are:

• D. It’s fairly close to Java, but with garbage collection you’ll still at like 50MB depending on your usecase (it just doesn’t immediately give the memory back to the OS for speed reasons), or you have to use some of the alt runtimes without a GC and many of the standard libraries.
• Rust, if you can deal with immutability by default, a borrow checker, and many other quirks.
• There’s also languages like Zig, Nim, etc.

But then came smartphones, and instead they grew up with that…

XML has its strengths as a markdown format. My own formatted text format ETML is based on XML, as I could recycle old HTML conventions (still has stylesheet as an option), and I can store multiple text blocks in an XML file. It’s not something my main choice of human readable format SDL excels at, which itself has its own issues (I’m writing my own extensions/refinements for it by the name XDL, with hexadecimal numbers, ISO dates, etc.).

Case sensitivity is so much of a problem, that in college, people were always told to keep all their filenames all lowercase, to avoid issues with them.

Yes, I’ve meant declarations, which makes stuff much harder. There are tools that automatically writes you the header files, but it was a major PIA when I learned C++.

Okay, I likely have mixed it up with another language, which sounded similar…

One issue is, many open source AI also tries to ape whatever the big ones are doing at the moment, with the most outrageous example is one that generates a timelapse for AI art.

There’s also tools that especially were created with artists in mind, but they’re less popular due to the average person cannot use it as easily as the prompter machines, nor promise the end of “people with fake jobs” (boomers like generative AI for this reason).

You’re no no longer using the term Luddite on us! Character development!

I’d agree, but here’s one issue with that: we live in reality, not in a post-capitalist dreamworld.

Creativity takes up a lot of time from the individual, while a lot of us are already working two or even three jobs, all on top of art. A lot of us have to heavily compromise on a lot of things, or even give up our dreams because we don’t have the time for that. Sure, you get the occasional “legendary metal guitarist practiced so much he even went to the toilet with a guitar”, but many are so tired from their main job, they instead just give up.

Developing game while having a full-time job feels like crunching 24/7, while only around 4 is going towards that goal, which includes work done on my smartphone at my job. Others just outright give up. This shouldn’t be the normal for up and coming artists.

I don’t think that’s a feasible dream in our current system. They’ll just lobby for it, some senators will say something akin to “art should have been always a hobby, not a profession”, then make adjustments for the current copyright laws so that they can be copyrighted.

Even worse is, in order to further humanize machine learning systems, they often give them human-like names.

Don’t forget that the pirates usually don’t say “art should have been just a weekend hobby, not a profession”.

They need to rename themselves “Intelligent Archive” then claim they’re an AI service that can just happen to regenerate whole books.

Issue with C# is, that it’s quite far away from a system language, and I would have to write the engine’s main core in some more system-level language, and I don’t consider it good practice to write every component that doesn’t directly interfacing with the OS in a trendy scripting language.

I have talked to people about Rust gamedev (including those who left Rust for D due to gamedev), and it’s not a very good one, due to the functional aspects. Outsiders often joke about how Rust has more game engines than games.

Zig has the header file problem. Header files were originally created to get around memory limitations of old workstations, that no longer exist. They also complicate coding, since you now often have to implement things at two places at once. However, Zig not only copied C++'s multi-inheritance, but also its header files, without understanding the actual reason why it existed in the first place.

Classes can be useful for abstraction. Just because they often overused doesn’t mean they’re bad.

Without an explicit class, I would either:

• had to reimplement them in a language without them (which looks extremely ugly and can be unsafe),
• create an “omnistruct” that keeps track of all posssible field (only looks a bit ugly),
• use uglier virtual functions for cases when I would need local states (doStuff(cast(void*)&localstate, values) vs localstate.doStuff(values)).

While structured programming was a godsend to the chaos preceding it, newer programming paradigms should have been instead seen as tools rather than the next dogma. OOP got its bad name from languages that disallowed its users to develop without classes, and enterprise settings making its devs to implement things that could have been simple functions as classes, sometimes complete with factories.

Same is with functional programming. There’s clearly a usecase for it, but isn’t a Swiss-army knife solution for all problems of programming.

It’s too high level for my usecase, so unless I either use a preexisting game engine, or develop mine using a system language, so C# is only good as a scripting language in my usecase, and sometimes you want “hard-code” new features, not script them.

I only had a bug once from unintended data mutation. In a GUI setting nonetheless, where state mutability is a must. The fix and tracking down the bug took 2-3 hours at max. No thanks, I’ll be staying with datastruct.nextState() rather than const nextState = prevState.nextState() (which is even harder to from the inside), or even worse, passing around global states in a function argument at an attempt of having a program state, which is essential for gaming. You know, games are famous for having interactibility, and not just about walking around in a static world (which is allegedly a thing for the few Rust games).

You forgot immutable by default.