badsectoracula

People are still figuring out how to use LLMs/AI and considering how feelings based and hard is to reproduce many of the results people get, a lot of the improved approaches are basically at "trust me bro" reliability.

TBH i expect it'll take several years before people largely settle on what works good and what works bad (or doesn't work) and that's assuming things wont chance in a massive way during that time.

And this isn't really anything new, people rarely come up with some new way of programming and have everyone learn and understand best uses from the start - it takes years (and that is assuming everyone will agree that'd be something worth bothering about).

Personally i'm only using local LLMs that i can run on my 7 year old PC (that also has a GPU with 24GB VRAM because reasons :-P) so i'm not sure how much that experience matches what others are doing (though roughly speaking what i see people complain about Claude doing doesn't feel that different from what i see the local stuff doing, so i guess the drawbacks aren't scaled down as model sizes increase).

I'm not sure about 1x, 2x or 10x increase as these metrics are about code written but that isn't a productivity metric (something pretty much every half-decent programmer would agree with before LLMs - remember stories about Bill Gates saying that more LoCs being good for software is like more weight is good for airplanes or Bill Atkinson's story about adding -2000 LoCs to improve QuickDraw?).

But they can certainly help "get you going" faster in that if you're stuck on something (for whatever reason - including "that feels too much drudgery") or have issues starting something, you can have an LLM take a stab at it and it'll produce "something". Sometimes it is enough by itself, but more often than not it'll need tweaks (either directly or having the LLM do it). I got to make a bunch of things i couldn't convince myself to do - e.g. an image viewer that doesn't suck (based on my arbitrary judgement), a game database, a script to convert a git repository into static html pages that kinda look like GitHub, etc.

They can also help find (and sometimes fix) bugs or other "code smell" issues. They're not that great for exact results (without tool calling -and knowledge on how to use them effectively- at least) but when it comes to fuzzy / vague stuff like "check out this code <code dump here> can you spot any issues?" they always tend to find some stuff (even if it is hallucinations :-P but sometimes they find actual issues too or whatever hallucination they come up with reveals some actual issues with the code that you didn't spot by yourself). I've been dabbling with Rust recently and asked Qwen 3.6 35B-A3B to judge my code and it wrote "6.5/10, will compile but looks like C in Rust" :-P.

The article says:

> Never write READMEs, docstrings, or comments. I will write those myself later. And yes, I really mean this.

And sure, LLMs aren't that great about those (i do let them leave whatever comments they want though and remove them later myself - i think those comments help during the generation/prediction - basically how they "think", kinda like the reasoning phase), but they can be very good at things like "here is the code, here is the documentation for it, spot discrepancies" (i had Devstral Small 2 do this and it hallucinated a few discrepancies but also found real stuff i missed in the docs).

I've tried to use Devstral Small 2 for some API docs but found it'd sometimes make assumptions about what function do or how. One approach that might work, but i haven't tried yet, is to write the "guide" myself, then have the LLM write the function docs using both the guide and the code as reference. The reason i think this will work is because it got things 95% correct just having access to the function code alone (and without the rest of the codebase), so the "guide" would help it reach 99%. I do not expect it to get to 100% so a manual edit pass will need to be done anyway (and i have an idea for a tool to assist in the manual edit pass for that - a tool that i'll probably get an LLM to write - BTW good luck coming up if all that stuff would increase or decrease productivity for an actual product and not some random stuff i'm toying with :-P).

One other thing i've also found LLMs useful recently is to have them use the stuff you make and see how they try to use it. I have an old project, a GUI toolkit i've been hacking on every now and then since 2011 or so, though it was never a priority. Yesterday i decided to dump all the header files to Qwen 35B-A3B (i use 4bit quantization that gives me a 256k context - it isn't particularly smart but it is neat to not have to micromanage context size like i have to do with Devstral Small 2 or Qwen 27B where both of them aren't very usable speedwise at anything above 32k context sizes).

Then i asked it to just make a few small programs and it did[0] (the shot shows a paint app, a calendar, a todo list and a unit converter). Pretty much every program found bugs in the library :-P and gave me ideas on how to improve things.

In general i get the impression that LLMs aren't great at architecting things but if you do the architecture yourself and write them a framework to use, they should do a fine job at it.

[0] http://runtimeterror.com/pages/iv/images/d50c436990db203a07f...

Well, they could use GLM or K3... :-P

> I'm watching a friend, claiming he wants to make a game company, burn through all of this money instead making a game engine. If he succeeds, great! But I suspect he'll just run out of money before he's even started working on a game. If it was fun to make, great too. But I think he'll look back on it as throwing away an oppotunity.

Been there, done that, didn't regret a thing since i'm certain i'd have given up way earlier (assuming i'd ever bother starting) if i had to use an existing engine :-P.

(ok, i never had money to "make a game company", the most money i ever had was to be able to spend ~2 years living frugally while making my own stuff, but it is close enough since i think someone could say i should have used some existing engine instead - which is true, except i'd hate doing that)

There are people who want to make games, people who want to make engines and, perhaps a minority, people who want to make games and engines :-P.

(though FWIW in my case i never felt the tech side was much of a limitation, it is art/content that ends up being the bottleneck and makes everything crawl down and the stuff i like to do aren't the kind of stuff you could do with procgen, minimalistic styles or other similar approaches for saving on the art/content side)

The first time i tried to make a game engine i didn't knew how to make a game engine and failed. The second time, same thing. But eventually i did manage to make a game engine. I even got to work professionally into making game engines for years. Nowadays i can make a game engine just fine.

Sure, trying to make a thing you don't know how to make will most likely end up with you not making it, but that is the case for pretty much everything.

(Considering the linked section) that is more or less how Petra Engine[0] came to be - making a gamejam game[1] for MSDOS over a few weeks. Though while i did make it for that specific game, i always had in mind that i may want to use it for other games in the future too so i tried to make it more "generic" and keep the engine and game bits separate while avoiding too many game-specific stuff (didn't fully manage it though - in the end i've been removing PAP-specific things and a bunch of hardcoded stuff over the years whenever i feel like using it).

That said, despite making a bunch of demos[2][3][4][5] since 2021 when i made the game, i never made any game using it after that as i always lose interest - perhaps i do need to be making an engine from scratch to keep myself interested :-P.

[0] http://runtimeterror.com/tech/petra/ (note the version is very old and i've made a lot of improvements since then - this includes the Codeberg repository which i'll move somewhere else at some point)

[1] https://bad-sector.itch.io/post-apocalyptic-petra

[2] http://runtimeterror.com/pages/iv/images/44d7537fb719e00fdcd...

[3] http://runtimeterror.com/pages/iv/images/d22ff83dd5e5109e02e...

[4] http://runtimeterror.com/pages/iv/images/1da6a4bce430a8d8507...

[5] https://www.youtube.com/watch?v=zx9KmkTLcB0

Looks neat (and despite trying to simulate a WinXP-like UI it relies enough on the native web stuff that Firefox can translate the Chinese to English without breaking much) but some more information would be great: how was it made? E.g. was it just some one-shot "make me a website that looks and functions like WinXP?" or was there more to it?

The link at the bottom right does mention that it was "user edited" but that could be some generic message and clicking on the "Kimi Agent" seems to just put me in an empty chatbot.

Can't you respond to a message without barely relevant comparisons? :-P

> If you are worried it's too much, "the wrong kind", whatever, you simply ask them.

If you have to ask them, then having terms of use is pointless. The entire point of ToU is to explain how one can use the service, if you have to "ask" then the terms are not doing their job properly.

Of course people aren't perfect and can write vague or misleading ToU - and considering i've seen the same questions about that "mostly" part here, on Reddit, on Mastodon, on Twitter, on Discord, on blogposts and even their bugtracker[0] where they claimed their blog post on the matter will clarify things, which it didn't, there is no question that the terms are inadequate here - but the response to that isn't to try and guess what they possibly could mean, the response is for the terms to be clarified.

If Codeberg wanted to tell people who use LLMs in their projects that those projects are not welcome there, then they should have put that in their terms of use in clear and unambiguous wording.

[0] https://codeberg.org/Codeberg/org/pulls/1253

It is also the simplest and most widely available one[0], working from decades old PCs to whatever is latest one, not only from the official drivers but also 3rd party implementations[1] that target other lower level APIs for environments where there isn't an official implementation.

[0] on open platforms at least

[1] it most likely wont be a 100% compliant one (even SGI had trouble on that front :-P) but in practice it'd be usable

That is only your own interpretation. It is one that does conform to the rule but only because it takes one extreme side of the potential "amount" of allowed genAI use.

However this isn't what the terms update state. If that was the meaning then they would have explicitly written "zero" - or something along these lines. The fact they didn't do that (despite the update being there for weeks and people were able to vote on them for a long time - so it wasn't just some mistake) means they do allow "some" use of genAI - so at that point the question becomes "how much".

> Before Codeberg has to ask that, the person who would upload has to ask it themselves. People know what they did, or didn't.

This is going in circles. For someone to "ask it themselves", first they need to know what to ask. But the term is vague: what does "mostly" mean? You can't ask yourself if your code is "mostly consist of code written by" generative AI if you don't know what whoever is going to judge the rules means by it.

Is it to be taken literally? I.e. a 2000-line project where 1000-lines are written by AI is fine but if there are 1001-lines your project is out (in which case, if the human-written lines get refactored to become shorter and more efficient, does that suddenly mean the project is out?).

IMO that sounds either like a bug in Nvidia's drivers (IIRC OpenGL doesn't require that sort of alignment) or -more likely- your code having some other memory related-bug (e.g. accessing data out of bounds) that the extra bytes you got from alignment masked it.

Well, IMO there is a bit of a difference between a "dictator" and a "democracy" :-P.

archive.org probably, just search for "archive msdn" and you'll find a bunch of stuff

You're mistaken, Codeberg isn't ran by some guy, it is a non-profit organization with ~1200 members (not to be confused with users - there are ~200k users), ~780 members of which have voting rights.

Codeberg isn't one person, it is a non-profit organization with ~1200 members (not to be confused with users - there are ~200k users), ~780 members of which have voting rights. The decisions aren't taken arbitrarily but they are proposed and voted for in an internal forum.

> the spirit behind this update is clear: to carve out a space for human-written projects.

It is not that clear though.

I use the Lazarus IDE for Free Pascal. Free Pascal is kinda verbose and the LCL framework Lazarus uses has a bunch of boilerplate and its design is biased towards tool-assisted development. As such, Lazarus itself writes a lot of code for you and you fill in the "blanks" that provide what you want to do. It also provides a lot of functionality for code completion where you provide something basic like a magic word or a very partial/incomplete declaration and it automatically fills in the rest, often adding functions and such.

To me, despite Lazarus writing a bunch of code itself, the projects i made using it are "human-written".

And to me many uses LLM also fall under the same category - e.g. i often use some small local LLM as "awk that can think" to transform text/code in ways that would be either cumbersome or sometimes impossible with actual awk (or similar). If i give an LLM a few C function prototypes and ask it to write the boilerplate C code for exposing them as a native module i do not see as any less "human-written" than if i used a script that parsed the C prototypes and generated the code or some similar tool: in both cases i had a few functions i wrote myself and had my computer generate code for exposing them as a native Python module.

So from my perspective, projects doing any of the above would still be a fit for "human-written" spaces.

Even at the time Java had some great tools and IDEs (NetBeans, Eclipse) and both computers and the JVM were fast enough for any performance issues compared to fine tuned C++ to not matter much, especially for a game like Minecraft that didn't (at the time anyway) push the CPU much.

Java allowed Minecraft to run pretty much everywhere, including as an applet (very important in its early time) and it relied (and still relies) on LWJGL which provides access to the most common stuff you'd need to make a game (OpenGL, windowing, input events, etc) - and at the time it also worked for applets too (you needed to download the LWJGL applet code but it was signed by the devs so you didn't get too many scary messages).

I used the same tech (Java+LWJGL) at the time to make a few simple demos/games and it was quite easy to make stuff - e.g. i made this[0] in a few hours using Java, LWJGL and Eclipse on the iMac i had at the time.

[0] https://www.youtube.com/watch?v=xXn8VhH6GFs

That name is a blast from the past! I remember Tribal Trouble's devs mentioning they chose Java because they wanted to use "weird/unusual" languages for gamedev :-P

The Microsoft API docs are a special case where i'd say you pretty much need LLMs nowadays because after a bunch of document format conversions over the years they degraded massively.

If you can find some MSDN CDs/DVDs from the early 2000s, the content is much better (and you can clearly see that the current docs are often missing descriptions and names for method arguments or even entire paragraphs).

Yeah i thought about it and you can sync the GPU and CPU (basically wait until the GPU stops doing anything) and even bruteforcing a sync before and after every register change it didn't solve things :-/.

It might still be something i'm doing wrong GPU-wise, but these flickers happen with static geometry (the memory for which is allocated at init) -seemingly- because of "damaged" transformation matrices (modelview and projection) passed to the vertex shader. The matrices are inlined in the push buffer (i.e. become part of it) that contains the commands to setup the render state before the command that draws primitives using them, so basically it is impossible for the GPU to "miss" them :-P.

FWIW Blender 5.1.2 (i.e. the latest one) can import and export DirectX .x files using an addon you can download from[0] (from inside Blender itself).

Though i'd stick with Blender 2.79b for such projects because Blender 2.8 (i think) switched to a PBR pipeline that looks "wrong" when targeting non-PBR renderers (in theory you can recreate the original shading using material nodes or whatever they're called, but setting up materials in modern Blender is already more involved than Blender 2.79b without taking nodes into account). Most of the tools you'd need for making game assets (mesh editing and UV editing primarily) haven't changed much anyway to the point where you can follow most Blender mesh editing tutorials with it :-P. I'm in a few retro gamedev Discord channels and apparently i'm not the only one using 2.79b because of the changes in 2.8+.

[0] https://extensions.blender.org/add-ons/io-directx-x/?utm_sou...

> Dive and read the official documentations for that hardware (pure RTFM kid), at this case the SDK/API docuements. And red through the samples that comes with the SDK, compile them, and learn even more tricks from them.

Unfortunately nxdk does not have (any) great docs and it is much lower level than what you'd (probably) get with the official SDK - you basically have to write your own GPU driver for example (though i think nowadays there is a partial implementation of OpenGL that has enough functionality to port a modern-ish Quake engine).

I made a simple engine[0] some time ago for OG xbox using nxdk and i basically had to figure out what registers do what using old versions of Nouveau from when it had GeForce3 support - and whenever that wasn't enough, i was just trying random stuff :-P. And unfortunately xemu (currently the most complete OG xbox emulator) is not very accurate when it comes to failures, so very often you get stuff that work on it not actually working on the real hardware.

On the other hand, in case anyone cares, nxdk is basically the only "legal" way to make stuff for OG xbox and various communities (like on Discord) do not allow posting binaries/ISOs made with the original XDK. And from a more practical perspective, at least personally i prefer to use a Unix/Linux-based development environment :-P.

(unfortunately i'm also having some weird issue with my engine in that i get weird flickering on the real hardware that i do not get on the emulator that seem to be based on wrong values ending up to the renderer - but only with optimizations enabled and only on the xbox hardware - if i compile the engine for Linux, be it 32bit or 64bit, it works fine and no matter which tool i tried - valgrind, sanitizers, etc - and good old "pouring through the code" i cannot find what the issue is -- which makes me think it a compiler bug as nxdk relies on Clang and i'm not sure the Clang devs test Pentium 3 much - and unfortunately, unlike GCC, you can't enable only individual optimizations, you can only use the -O<n> optimization levels, so i can't even figure out what exactly breaks things that could have been a hint in case it is something in my code)

[0] http://runtimeterror.com/pages/iv/images/8a37dc59c6f6adbbb98...

Codeberg has some extra "anti-scraping" measures than just Anubis which, judging from the community issues[0] sometimes ends up with false positives that cause people to get garbage (example issue[1], potential page with the garbage i found from Google[2]).

Interestingly, someone mentioned that you may get the garbage when searching Codeberg using Google's `site:codeberg.org`

[0] https://codeberg.org/Codeberg/Community/issues

[1] https://codeberg.org/Codeberg/Community/issues/2603

[2] https://codeberg.org/Codeberg-e.V./requests/!~codeberger~!.g...

Same here, i've been on Codeberg since 2022 but if this passes, i'll most likely move my stuff elsewhere (my projects do not even have any AI code, i just dislike the idea of telling people what tools to use to make their own stuff).

I dislike GitHub and i'm using a shared host for my website which wouldn't let me install something like Forgejo (this is by choice as i don't want to bother with sysadmin stuff, my site is almost all static HTML with only a couple PHP scripts for some minor tasks). So i guess i'll be migrating to GitLab, even though i do not really like its UX. Or maybe i'll use some other Forgejo instance like CodeFloe. URLs aside, migrating between Forgejo instances should be easy.

Spinning up a docker image with GitLab is easy indeed, but the installation is huge and you can feel it doing weird stuff (and it keeps doing "stuff" all the time even if nobody does anything - before you even bother to create extra users or repositories or whatever). The whole setup seems to be designed to be opaque.

Forgejo is a single self-contained ~110MB binary (it contains all assets) you can drop anywhere and it'll just work - depending on your needs you most likely wont even need to bother with a DB server as it can use SQLite (my local install is doing that).

Also FWIW personally i find Forgejo's UX much better compared to GitLab.

> I have no idea why they didn’t realize that earlier

14 layers of management :-P

If your game wasn't approved or they didn't respond back there are better avenues than writing these pointless messages on HN.

> ancient forefathers are ODE

I remember trying this back in 2004 or so when i was making my first real 3D game engine, but i ended up abandoning it because i was trying to use it on 64bit Linux and the source code had typecasts between pointers and (32bit) ints all over the place :-P.

That was fixed later and apparently the engine was used in a few commercial games during the 2000s and early 2010s.

They just released four games yesterday and looking at the news reel it seems they release a bunch of games every day. They're also running a summer sale right now. I doubt they're anywhere close to being dead.

They are known to take their time when it comes to developer submissions (and that time can be quite long) but that was the case since pretty much forever, not something that happened with the new/original owner.