So, of late there’s been discussion in one place or another about the presence of genAI code in open-source software.
Now, I doubt that it’s feasible to keep out all genAI-produced code. However, it may be possible to reduce the amount thereof.
And this is, I think, desirable: code produced by genAI tends to be of lower quality, is plagiarised, and makes mockery of the licenses and IP rights of the developers on whose code it was trained without consent.
Not to mention that the back-end requirements of genAI have resulted in massive energy requirements and a steep increase in the price of hardware.
(I’ve kept this fairly short, but this page has a variety of templates for such requests that go into a lot more detail on issues and potential issues. It might be worth a read, I feel!)
To that end, I’d like to suggest that we enact a policy and set in place measures to reject genAI-based contributions to the engine.
And, well, I’d like to see Panda on the former of the two lists linked in the following BlueSky post!
IMHO we are entering phase where models are getting very good and accepting some of gen code makes sense; this is here to stay in one form or the other, it’s too late for pushback. Instead, I suggest there should be a “policy” for removing slop/low effort “contributions”* etc without having to provide much more than a link to the policy/guidelines.
Thanks for raising this discussion, it is very relevant given that have been increasingly dealing with LLM-authored contributions over the past year. There has been some similar discussion in the Discord server of late, and there is a working policy on this which I’ll get into in a moment; I want to address these concerns one at a time.
Firstly, quality: a worthy concern, but I think this is actually more of a mixed bag than it might seem. We’ve had low-quality contributions before LLMs, and a couple of months ago we had a whole bunch of trash-quality submissions that I strongly suspected were LLM-generated, but more recently I would say that the average PR quality has actually improved, which I think is partly due to rapid advancements in the technology. From personal experiments, the latest models are able to catch edge cases a human reviewer missed, even ones that would require a human to reason quite abstractly about codebase concepts. When it gets down to it, however, having an LLM produce quality changes (especially larger ones) still requires good prompting, human feedback loops, and adequate review. This is where the risk lies: contributions by well-meaning people who were not capable of writing quality code, using LLM to develop a useful feature for Panda3D, and being unable to verify the resulting code. This ends up mostly being a strain on the maintainer, who has to expend a disproportionate amount of effort reviewing the resulting code, which then doesn’t get fixed after feedback.
On plagiarism: blatant plagiarism has never been acceptable, and users who submit a PR have to tick a box saying that the code they submit is legally unencumbered. The broader question of whether training constitutes plagiarism is still actively being litigated; I don’t think the contribution policy is the right place to settle this debate.
When it comes to making a policy, we further have to consider enforceability. The thing is that, while it’s easy to suspect that an LLM was used, there’s no way to know for sure, and rejecting based on suspicions will inevitably cause false accusations being thrown around, reject otherwise high-quality contributions, and waste maintainer energy on speculating how the code was produced. The bar has to be: we accept high-quality, unencumbered code, and quality can only be ascertained by review; and as before, declaring the code is unencumbered is the submitter’s responsibility.
Finally, I should also be transparent about my own use: while I would never trust an LLM to do wholesale unattended work on the engine (besides the fact that it takes the whole fun out of it; I like coding, I hate reviewing), I have used an LLM on occasion to assist with my work on the Panda3D codebase; primarily with review (using Claude to review my changes has caught real, subtle bugs that would have slipped into the engine), or an occasional mechanical conversion that would have been too error-prone and time-costly for a human to do. In practice, I believe the cost of such use is dwarfed by the energy costs from running the CI pipeline. I personally believe that there is a useful place for LLMs in open-source development, and I hope that their energy use continues to trend downward as the technology develops.
That said, I want to stress that we are a community of humans, working on an engine built by humans, and whatever policy we settle on has to keep valuing human contributions (very much including your own) above anything a tool produces.
So, that leaves us with the working policy, which has been part of CONTRIBUTING.md for the past 5 months, and is similar to the policy across many open-source projects: no strict ban on LLM code, but code is judged on its merits (like it always has), and notably human-owned. A human has to be able to explain exactly what every line of the code does. Consider the existing text a first draft, though; I expect that we will continue to refine it going forward, and suggestions would be welcome, particularly around how we define ownership and handle low-quality contributions. Similarly, @frainfreeze’s point about low-quality forum submissions falls under the same principle, and it would help to have a coherent moderation policy to address this.
I agree, code should be maintainable and understandable by humans, especially if is open source.
As someone who has been programming since the Turbo Pascal , llms give me mixed feelings, they fascinate me, but at the same time they worry me.
I’ve always been enthusiastic about technological progress, and that’s still true in this case, but I think we need to be careful.
During the development of my personal project, which is both a hobby and antidepressant, I experimented with llms quite a bit and very often I received completely incorrect answers or surprisingly strong hallucinations. And if you have to explain every detail of the problem in the prompt, you might as well write the code yourself, which is the most enjoyable and rewarding part of our hobby (or profession).
Panda3D is a compact and elegant framework, once you understand it well, you don’t really need a neural network to write new classes.
So, in my opinion, llms are perfectly fine as a support tool, but only after you’ve exhausted your own ideas, when you’re stuck, have doubts, or simply need someone to brainstorm with.
What we shouldn’t do is blindly trust an llm with everything, that approach devalues the knowledge and experience of the people who took the time to learn and understand.
I think it’s also worth acknowledging how ai can affect the engine’s reputation, if we accept too much generated code.
Ai is immensely unpopular right now, and this might stick. The average consumer has plenty of reasons to dislike the technology itself:
As mentioned above, ai is trained on existing works, and this is often without permission. Many people boycott ai products because of how the industry profited from so many publicly posted works without giving anything in return.
Many people have already lost their jobs to ai, or know someone who lost their jobs because of ai. Obviously, these people will reject products made with ai, in hopes of making the hiring of humans more profitable than ai.
Also as mentioned before, ai has a huge energy and water cost. Accepting ai generated code too readily could leave the panda3d developers and comunity a reputation of not caring about the environmental impacts.
Tl;dr: i think we should be mindful not to accept ai contributions to the point they influnce public perception of the engine, and by extension projects made with panda3d.
Hmm, your “immensely unpopular” claim stood out to me since it didn’t quite match my own observations, so I investigated.
Regarding developer perception: according to the 2025 StackOverflow survey “84% of respondents are using or planning to use AI tools in their development process”, and 60% has an overall positive sentiment. According to a Sonar study from this year, “Developers also report that 42% of their code is currently AI-generated or assisted”. What is notable is the distrust in the output, which ties back into the need for proper review.
As for public sentiment, it should be noted that Godot is on the list of engines that accepts AI contributions, yet consumers aren’t wholesale boycotting games made with Godot—not even games made with Unreal and Unity, both of which even openly advertise “AI assistant” features as part of the engine! I have seen resistance to games using AI-generated assets, but of course it’s up to developers to choose what to put in their games.
The broader societal and environmental concerns are fair to raise, of course; but as said, I am not convinced that a contributor policy is the right place to litigate them.
Well, it’s true that consumers are not likely to care as much about whether ai is used in the development of an engine. We can probably afford to accept some ai code. But panda3d is much smaller than godot; we wouldn’t want ai to become our “hat”.
For what it’s worth, we know a bit on consumer opinions on ai. This study here shows that games on steam that disclose usage of ai revieve around ~53% fewer reviews than games that don’t. Assuming that’s due to players buying games at a smaller rate, that’s a fairly stark penalty. Admittedly, i do wish this study captured certanty in ways i am more familiar with (p-value, anyone?) and ill have to do more research than just google to look for studies reproducing this effect.
I’m glad that this topic is being discussed openly. It’s clearly divisive and potentially polarizing, so yeah, I think we need to be careful here.
Part of the reason I’m an active member of this forum and not any other game engine forum is because this engine and its community provide two things I highly value at once – small numbers of high-quality independent contributions. That’s rare. And it would be disappointing to see this forum become another receptacle of large numbers of low-quality, low-impact, low-imagination contributions.
One thing I have noticed in the last year is increasing “interest” in the engine by vague entities who want to “train AI” on Panda3D source code and programs. When I’ve inquired further to any of them, they don’t seem to be comprised of actual people, and if they are, they express zero actual project ideas and moreso a vague sense of wanting to capitalize on our collective intellectual capital. This is sad, and doesn’t inspire good feelings in me.
Naturally the aforementioned “new interest” is not the fault of the preexisting community or the engine. Rather, it’s the outcome of our unique intellectual bounty suddenly becoming accessible to those who share none of our predilections.
One last thing I’d like to comment on is that LLMs are great at a few things, and one of those things is making convincing amalgams of already existing technology (like Minecraft). Personally speaking I don’t think the market needs the 587th iteration of a voxel-based sandbox game, particularly if it’s at great environmental cost.
I don’t mean this to discourage anybody from using the engine as hobbyist or to study how existing games work in principle. No, that is a great use of Panda3D. But when I see people/entities openly expressing their desire to basically effortlessly crank out derivative projects in order to enrich themselves, I have to say that’s not a great look.
Nobody here has an irrational hatred of ai, but it’s a huge leap to claim that you can develop and maintain software without knowing how to code.
You wouldn’t need to know how to fly a plane just because autopilot exists.
Skills aren’t just a bureaucratic requirement, they’re what ensure quality, accountability, and long term maintainability; without them, you risk producing little more than disposable code, wasting resources.
From what I’ve seen, honestly, I don’t find the result particularly impressive, I really don’t think it takes years to render a few shaded cubes
Meh, it’s kind of impressive from a technical standpoint. Maybe you didn’t look very closely.
But this thread is supposed to be about the engine and the role of AI in engine dev, so I’m going to leave my game for discussion elsewhere so as not to derail this thread.
On the engine side of things, I use a heavily modified version of Panda3D and I find AI invaluable for engine dev work.
I’d encourage everyone here who is an AI sceptic to try Fable, it’s seriously great at this sort of thing.
I am glad that you are getting better quality than expected!
As you point out, however, those well-meaning but inexperienced contributions remain a potential issue.
I do appreciate the transparency!
Do you mind if I ask when you started with this?
Well, that’s another point, actually: it’s not clear who owns the output of a genAI.
It doesn’t seem likely to be the prompter: they didn’t make any of the output, and the output was founded on the work of others, who (presumably) haven’t transferred any rights to them.
The genAI of course can’t own anything: it’s just a program.
The company that owns the genAI, perhaps?
Or the people on whose work the genAI was trained, collectively…?
So who does own the code being submitted…?
(The process of prompting is essentially analogous to commissioning a third-party to do the work for one; that third party has to give one the result with either the understanding or a contract for transfer of ownership. But if the third-party itself doesn’t own the work (since it presumably can’t own things)…)
I have seen pushback on games that disclose genAI-usage, as I recall.
Of course, the general public likely doesn’t know whether a given engine uses genAI behind the scenes, and so may be less likely to respond to that.
And indeed, I do think that the public is likely to be more forgiving of a developer using an engine that has genAI contributions than of a developer who uses genAI themselves.
And the examples given on the list for their usage of genAI are relatively slight.
I think that I’ve seen the same study posted elsewhere, indeed.
(I know that I don’t buy anything that was “made” with genAI.)
Oof, yeah, I was approached on BlueSky by someone wanting to work on something that sounded similar to what you report. :/
So it isn’t trained on code and text regardless of whether the IP-owners of that code and text are willing to have it be so, and doesn’t produce output based on that without credit to those owners?
Because I’m pretty sure that it is, and that it does.
We can argue about specific legal definitions, but the fact is that it’s trained on copyrighted material without consent, and outputs results based on that material.
That is, I feel, sometimes a way of dissuading what might be effective resistance: make it seem doomed, so that people don’t try. I’m not particularly bothered by such doom-and-gloom pronouncements!
Let’s skip the sarcasm and keep the discussion constructive. Regardless of what was in the post – or how intellectually superior the author might feel – it was flagged by the community for a reason.
If there are actual technical, legal, or practical arguments regarding a GenAI policy left to discuss, let’s focus on those.
Not at all, though I might struggle to produce a precise answer. I would say that when Claude Fable 5 was publicly released, which I found was the first model with the ability to understand the complexities of the Panda3D codebase well enough; I used it to find bugs in core Panda code that I felt uncertain about that I then fixed myself, and I later used it to review changes before landing them, in absence of another maintainer with time to closely review core changes (it would consistently find things I had missed), and occasionally as an aid in debugging. (It’s possible I have used Opus as a debugging aid before the release of Fable as well, though I am not certain.)
The only time I used it to produce substantial novel code was a few days ago and sits contained on the spirv-shader-generator branch, which contains a mechanical conversion of the shader generator from Cg to a SPIR-V generator layer I created, a genuinely useful change that I fully stand behind. I had sought feedback on that change on Discord and I intend to merge it onto the shaderpipeline branch soon.
I think you misunderstood what I meant by “human-owned”; I didn’t mean ownership as in copyright, but ownership in the sense of accountability; every bit of code must have a human to stand behind it, understand it, answer for it, endorse the design decision, and be embarrassed if the code is faulty. This also means that whatever tool they choose to use or whatever reference code they choose to adapt is their responsibility.
To address the point directly, though, as far as Anthropic is concerned, they explicitly transfer ownership of any claims they may have to the user. As for whether their training was performed lawfully is another question; a judge ruled in favour of Anthropic last year (Bartz v. Anthropic) saying that AI training (on books, in that case) was “quintessentially transformative”, likening it to a reader learning to write, and fair use if the works were acquired legally. (They ended up paying a hefty settlement for the works that they had pirated). That said, litigation is ongoing and the final word has not been said on this; but that legal risk lands mostly with Anthropic, not with us.
As for the issue of plagiarism, this is a more specific wrong (reproducing the expression of another author without their consent), and could remain a residual legal risk, and it goes without saying that this is not tolerated in any form, whether produced by an LLM or by a human.
If I may be so bold, I might extract another aspect from your point, which is that you might perhaps feel it is also a matter of fairness, whether building systems trained on others’ work without their consent is fair to those authors, and/or ontologically different from humans learning from others’ work; I think the opinions are divided on this (as evident from this thread), so perhaps it would be best if our contribution policy would leave room for conflicting views on this.
Thank you for sharing, I didn’t know this. They make some genuinely good points in there, some of which I might seriously consider taking inspiration from. (In the context of the point, though, note that the stated goal of this is to protect maintainers’ time from being drained, not protect the image of the engine.)
A lot of what I’d want to say has already been said. I definitely think it’s important to be mindful of and put in place some clear definitions of what, if any, is an acceptable use of LLMs.
A lot of critique of LLMs I see seems based on fear of the unknown, like farmers believing the very first trains would made the cow’s milk sour. It’s very interesting technology (like N-grams and markov-chains), and I’ve learned a ton by talking to it (about stuff like C compilers and whatever). It’s certainly a very powerful and valuable tool, and it would be crazy not to wield it to improve Panda3D. But that’s me and my personal belief.
But, I can see how it might exclude some people from its use in development. Open-source software can be tools of empowerment. Panda3D could be used as a tool for resistance. “The system” is increasingly occupied by the companies that build these LLMs and I could see how it could lead to people reconsidering an engine’s use. People that know me know I don’t use software that does not align with my personal beliefs and I doubt I’m the only one. That’s politics I guess, but definitely worth to consider. How inclusive do we want Panda3D to be?
There’s also the matter of maintainability. Using LLMs is practically free now. The industry is also losing vasts amount of money on it. Once they close the faucet, some projects will have grown to depend on approaching them with LLMs. It’s going to be terrible for some projects to clean up that slop and get their projects in a more manually-maintainable state. You’re already seeing this with some projects staying on Github, consequently bombarded with low-quality LLM-generated issues and pull requests, incentivizing the maintainers to approach that volume of slop with LLMs (whereas the solution in my opinion is to get off of Github entirely).
All in all, I personally have confidence that rdb could keep any use of LLMs acceptable, tasteful and careful. With great power comes great responsibility.
Given this, I think that for my purposes the thing to do is likely to freeze the version of the engine that I use. I’m currently on 1.10.16, and so for now will probably remain on that version as things stand.
Aaah, I see! Yes, that does make sense: there is at least a clear human who is accountable for the code being submitted.
(Even if they were getting their code from a human third-party, by submitting it themselves they’re implicitly taking responsibility for the code, I’d say.)
Hmm, fair enough. It is good to read that the legal fallout is more likely to fall on the owners of the genAI. (I presume that the owners of other models have similar statements in place.)
We’ll see how things play out on that side, I suppose!
I can understand that point of view, I do feel.
That is good to read–and I’m glad that I posted it, then!
That’s a fair point!
Although it occurs to me that a policy enacted for one reason may still have positive effects for other reasons. For one thing, it may encourage developers to use that engine over others.
Thinking of which, I was reminded last night of a similar case with the visual novel engine RenPy: If I recall correctly, the maintainer noted that they were using genAI for the purposes of checking their code. This then led to some of the developers who were using the engine considering a switch to a visual novel engine whose maintainer takes a stance against genAI.
So the use of genAI in an engine may be relatively-invisible to the end-user–but may nevertheless put off some developers.
