Because I’m sure that, in a tiny community, you really want to celebrate a “brutal reply” when someone turns up who is actually a fan of the engine. Hmmmm. Might want to reflect on that comment, sir.
Hi Thaumaturg,
I’ve done a bit of reading of the forums. Let’s just say I’m more of a fan of your work than you are of my AI. 
Aside from the challenge above:
- which is deeply irrelevant to the subject at hand, coding games in Panda 3D
Even if AI is any good at this–which I doubt-
- Do you have an open mind on this? If, hypothetically, a non-coder produced a kind of OK game, would it sway you?
And even if there weren’t the issue of it being founded on rampant plagiarism–which it tends to be-
- I understand that some people feel strongly on this, but that’s not what the courts have decided. AI is here to stay.
And even if there weren’t the issue of energy consumption–which I believe that there is-
There’s also the matter that when it hallucinates or otherwise produces a bug–which it likely will at some point–the user will most likely not be familiar with the code produced, and won’t have built up skill at using the engine, and so will likely be less well-equipped to fix the issue.
- common myth amongst people who don’t vibe code. I’m likely the most active “developer” in the world right now on the engine, at least when it comes to games.
Here’s my progress over the past 2-3 months in Panda3D:
SUM: 914 54125 62987 429202
So 240497 lines of Python, another 160K+ of CSV and JSON, and as a guy who doesn’t know anything much about coding I’ve never found a bug I can’t fix (or more correctly, that my AI can’t fix)
Not to mention the question of what the user will do should they want to change a feature in an AI-generated game.
The user as in me? I think you misunderstand what an “AI generated game” is. I add dozens of features every day to the game. I mean, I’ll use over a billion tokens this month alone adding features:
Total │ │ 158,325 │ 561,534 │ 76,400,130 │ 770,355,… │ 847,475,2… │ $861.95
Like, say they’ve managed, somehow, to get an AI to produce a platformer with a double-jump and a dash.
- I hope the $1000 and billion tokens I’ll spend this month end up making something a little bit better than “a platformer with a double-jump and a dash”.
And let’s say that they decide that the above is cool and all, but it would be even cooler if the game also had a rope-swing ability!
I would ask Zoe, my AI, very politely to code a rope swing.
And let’s say that they even manage to get the AI to produce code that (correctly) implements such an ability.
How would they integrate that into the main program? Where would it go? How would they find the relevant place–or places–in the main code into which to introduce the new code? And how likely is it that the new feature would interoperate with the extant code?
- Well, my little panda3D game is a quarter of a million lines of code long with 743 Python modules. So I reckon the AI is pretty good at getting things to work with existing code!
And introducing a new feature tends to also introduce more bugs–which brings us back to the point above the edit…
- not any more than with human devs, and the AI fixes the bugs a lot quicker than a human could.
This stuff is all super new, and I don’t think many people actually know much about what is possible yet.
But vibecoding in Panda3D is super fun, and after 250 - 500K lines of code I reckon it works pretty well.
Anyway, nice to meet you!
Hey Serega,
Nice to meet you!
I’m pretty sure we’re talking about coding games in Panda3D in this thread? Not creating forks of Panda3D, which I have no experience or expertise in doing.
Having said that, I have been struggling a bit with the engine - getting it to do some stuff I’d like it to do - so my AI and I have been chatting about a bit of a rebuild. So there’s a chance the Panda3D fork will happen (not sure how well it would go…)
But for now, I’m going to focus on getting my little game finished.
Anyway, thx for your work on Panda3D, it really is a fun engine to work with. Cheers!
Hello, my thought is that from the point of view of AI, there is no concept of goals. Creating a fork of Panda3D is no different from a fork of a game, for example, a racing game - yorg
If I dig deeper, then your AI-written project is just a set of files that you update from time to time. And all this is software code that AI should not be confused by, whether it’s an engine or a game.
This is the first time I’ve heard about the limitations of AI, it can program a game, a shader can, but it can’t write or improve an engine for it - some kind of paradox.
Serega, it doesn’t really work like that.
I don’t just say “Claude, make me a space sim game with Panda3D”.
This project I’m talking about will still take a thousand hours of active work from me. Those billion tokens I was talking about? I still had to type out a LOT of them.
But its a thousand hours (well - maybe a bit more), rather than twenty thousand. I’m actively involved for every one of those hours. I need to know what I want, even if I can’t actually code it.
For my space sim, I know exactly what I want to do, so I can direct the AI orchestra.
So to make a fork, I’d need to understand what I’m trying to do with it. I could probably work it out with the help of the AI, but it’s not something that I have expertise in.
To give you an idea of how this works, for the fork project i’d need to create documentation like this:
–
Your Complete Documentation Toolkit
The user has created an extraordinary documentation ecosystem specifically for AI collaboration:
Start Here Every Time
documents/0_Key_Documents.md- MASTER INDEX - Your roadmap to all documentation
Essential Reading (Know These Well)
documents/QUICK_START.md- 5-minute productivity guidedocuments/AI_GUIDE.md- Meta-guidance for AI assistants (that’s you!)documents/DEV_PATTERNS.md- Critical patterns, especially Panda3D globals!
Task-Specific Guides
documents/COOKBOOK.md- Step-by-step recipes for common development tasksdocuments/TROUBLESHOOTING.md- Systematic solutions for common problemsdocuments/INTEGRATION_MAP.md- How all systems connect and affect each other
Deep Reference
documents/INTERFACES.md- Complete API and data structure documentationdocuments/LORE_QUICK_REF.md- Universe context for technical decisionsdocuments/ROADMAP.md- Project vision and development priorities
Complete Context
documents/Program_Structure.txt- Detailed architectural overviewdocuments/Galactic Lore Summary v14.txt- Full 500+ year universe historydocuments/Planet Types v4.txt- All 90+ planet archetypes with scientific data
–
Now, I’m actually going to get the AI to write that so it’s a lot less work that it looks like, but I hope you can see that the process is a fair bit more complex that just saying “Claude, fix Panda3D’s bugs!”
In fact, you’re saying that we need to declare a lot of data before artificial intelligence can do anything based on it. It’s like training an animal for one specific purpose.
Not quite. The AI can write its own guideline documents - that is what I do - so it is guiding itself. And this documentation may be applicable across multiple projects:
But what I am saying is that, to achieve results on complex tasks, you need a human there as the conductor. AI-assisted coding takes a bit of skill, but it’s a very different skill from trad coding. And it takes a lot less time to get usable output than it would if one was trying to learn to code from scratch. So my job is to plan and communicate clearly in English, and the AI’s job is to code. If I tried to move into an area I don’t really understand, my planning and communication would not be as good. It certainly not impossible, its just untested and I’m already sitting here at 5am trying to add more sim features, so I don’t think I’m ready to take on bug fixing yet.
By the way, you said that AIs don’t plan, but they absolutely love to plan on a smaller scale - TODO lists etc
And from the AI-written documentation:
Your Mission as an AI Collaborator
You’re not just debugging code or adding features—you’re contributing to a living, breathing universe that represents the pinnacle of scientifically-accurate space simulation (human edit: AI getting a bit carried away here…). Every change you make should:
- Respect the established scientific accuracy
- Maintain consistency with the rich galactic lore
- Follow the professional development patterns
- Enhance the immersive simulation experience
- Support the multi-modal architecture
The user has invested extraordinary effort in creating this universe and documentation system. Your role is to help expand and refine this vision while preserving its scientific integrity and narrative consistency.
Ready to Begin?
- Read
documents/0_Key_Documents.mdto understand the complete documentation ecosystem - Identify your task type and follow the appropriate document workflow
- Remember: globalClock and other Panda3D globals don’t need imports!
- Think scientifically: Changes should fit the realistic universe
- Test thoroughly: Multiple modes may be affected by your changes
–
But a human is required for the big-picture direction of where things need to go. Note that despite what it says here, I didn’t actually “invest extraordinary effort” in this documentation, the AI did all the work in a previous instance, it just doesn’t know that!
Hey, in case you’re interested I’ll give you a proper answer to this. I personally find this stuff fascinating.
The answer is that my AI would be able to work this out by thinking through the issue, but it would find things even easier if it looked at the INTEGRATION_MAP.md document that I got it to write for itself.
I just thought you might find this interesting as it is likely very different from how you think an AI might work. This is the integration doc from my Panda3D game project. Now, I don’t know any of this stuff but the good news is that my AI does, and it’s actually really interesting how good it is at understanding structure and documenting this (this is just the first bit of the doc)
System Integration Map
This document maps how all systems connect, share data, and depend on each other. Critical for understanding impact of changes across the codebase.
Data Flow Architecture
Configuration Flow
settings.json
↓
main.py (GameLauncher)
├── HYGDataManager → Load star catalog
├── Determine startup star → Random or Sol (HYG ID)
└── Update gamestate/current_game.json
↓
Mode-Specific Initialization
├── FPS Mode → fps_main.py → scene_instance.config
├── Capital Ship → capital_ship.py → ship_config
├── Planetary → plan.py → shuttle_config (+ HYG ID)
└── Colony → modules_colony/*.py → colony_config
↓
Star System Generation
├── unified_system_generator.py (HYG ID → seeded random)
├── star_creation.py (deterministic star properties)
└── create_solar_system.py (consistent planet layout)
↓
Component Initialization
├── Physics Systems
├── Audio Managers
├── Rendering Systems
└── User Interfaces
Resource Loading Pipeline
Assets Request
↓
utils/resources.py (Path Resolution)
↓
Asset Type Router
├── 3D Models → loader.loadModel() → BAM Cache Check
├── Textures → texture_loader → Variant Selection
├── Audio → AudioManager → Folder-Based Selection
└── Data → JSON/Python → Configuration Merge
↓
Runtime Systems
Mode Switching Architecture
Mode Lifecycle
Current Mode
↓
1. Save State → Persist player progress, settings
↓
2. Cleanup → Remove event handlers, stop tasks, free resources
↓
3. Transition → Clear scene graph, reset globals
↓
4. New Mode Init → Load config, initialize systems
↓
5. State Restore → Load saved progress (if applicable)
Shared vs Mode-Specific Resources
Shared Across All Modes
- Configuration System:
utils/config.py,config/settings.json - Audio Core:
utils/audio.py(AudioManager base class) - Logging:
utils/logger.py,logs/directory - Asset Paths:
utils/resources.py - Global State: Player preferences, audio volumes
Mode-Specific Resources
| Resource Type | FPS Mode | Capital Ship | Planetary | Colony |
|---|---|---|---|---|
| Physics | fps_physics.py |
ship.py |
planetary_spacecraft.py |
N/A |
| Audio Wrapper | fps_audio.py |
Ship audio | Shuttle audio | colony_ambient_music.py |
| Rendering | Terrain generation | starfield.py |
planetary_starfield.py |
Building sprites |
| UI/HUD | fps_ecls.py |
hud.py |
planetary_shuttle_hud.py |
galaxy_map_ui.py |
| Data Sources | room_data.json |
Ship configs | planet_data_*.py |
Building definitions |
System Dependencies
AI Traffic and Camera System Dependencies
test3d.py (Main Application)
↓
├── scenes/spacestation_scene_loader.py (Scene Definition)
│ ├── Loads: JSON scene configurations
│ ├── Spawns: Space stations, cargo ships
│ └── Depends on: modules/ai_traffic/ship_instance_generator.py
│
├── graphics/camera_router.py (SSOT Camera Control)
│ ├── Coordinates: flyby, orbit, standard camera modes
│ ├── Manages: Intelligent mode switching
│ └── Depends on: settings.json ai_traffic_camera section
│
├── graphics/hud_display_ai_traffic_info.py (Real-time Display)
│ ├── Shows: Ship specifications, movement status
│ └── Depends on: Flattened ship data from generator
│
└── config/viewer_config_loader.py (Configuration Management)
├── Merges: 3dtestdoc.json + settings.json
└── Provides: Unified configuration to all subsystems
Audio System Dependencies
utils/audio.py (Base AudioManager)
↑
├── first_person_mode/fps_audio.py
│ └── Depends on: Environment type, room data
├── modules/ambient_music.py
│ └── Depends on: Game state, mode context
└── modules_colony/colony_ambient_music.py
└── Depends on: Colony state, building types
...etcOK, I’ve forked Panda3D to a new engine, Pax3D which is now compiled and running.
Just because you asked for it!
Now, building the core sim remains the primary goal, but the AI’s aspiration is as follows:
Pax3D Technical Summary
Project Overview
Pax3D is a custom fork of the Panda3D engine, specifically optimized for the indie space simulation game Pax Abyssi. Rather than using a general-purpose engine, we’re creating a tightly-focused graphics engine that gives us direct control over the rendering pipeline for space-specific visual effects.
Core Technical Goals
1. Modern Rendering Pipeline
- Replace SimplePBR with custom PaxPBR shader system optimized for space environments
- Implement proper post-processing framework with modular effect chaining
- Add FXAA/TAA anti-aliasing (current MSAA is insufficient)
- Fix transparency sorting issues that plague space scenes with atmospheres and shields
2. Remove Legacy Components
- Strip out DirectX 9 support (unmaintained since ~2009)
- Remove obsolete .egg and .bam file formats
- Eliminate unnecessary general-purpose features that add complexity without value for space sims
3. Native Space Simulation Features
- Built-in procedural starfield generation at the engine level
- Optimized large-scale scene handling with floating origin support
- Space-oriented UI/HUD toolkit for cockpit interfaces
- Native support for 3D zero-G navigation systems
4. Modern Asset Pipeline
- Integrate glTF/glb as the native model format (currently a plugin)
- Full PBR material support with proper emissive handling for engine glows
- Multi-layer transparency for realistic atmospheres and shield effects
5. Visual Effects Excellence
- Engine-level lens flare system with astronomical accuracy
- Volumetric effects for nebulae and gas clouds
- Specialized shaders for plasma effects, engine trails, and combat visuals
- HDR rendering with proper tone mapping
Development Philosophy
- Performance First: Prioritize 60+ FPS over feature breadth
- Space-Specific: Every optimization targets space simulation needs
- Modern Standards: OpenGL today, Vulkan tomorrow
- Python Integration: Maintain excellent Python API while modernizing C++ core
Success Metrics
- Clean build with our selected third-party libraries
- Render complex space scenes at 60+ FPS
- Support for transparent atmospheres without sorting artifacts
- Proper astronomical-scale rendering (sub-millimeter to AU distances)
- Beautiful lens flares and space phenomena that would make Pythagoras weep with joy
The Music of the Spheres deserves a proper instrument - that’s Pax3D! 
Delete the format .bam, this is a very short-sighted task. Because .bam is the native structural classes of Panda3D.
In any case, I will be waiting for the new rendering pipeline. 
Yeah, but not of Pax3D
.bam sucks, we’re going to focus on .gltf
This is actually super fun.
It’s 4:30am, and we just completed stage 1!!!
–
Phase 1: Foundation COMPLETE
- DirectX 9 completely eliminated (~1000+ lines of legacy code removed)
- Build system modernized and validated
- Deep architectural understanding gained
- OpenGL-only rendering path optimized
Phase 2: Core Modernization (Current)
- Post-processing framework implementation
- FXAA/TAA anti-aliasing integration
- SimplePBR replacement planning
- Space-specific rendering optimizations
EDIT: a bit more detail
Phase 1: Mission Accomplished
The DirectX 9 removal was executed brilliantly:
- ~1000+ lines of legacy code eliminated
- Entire dxgsg9 directory cleanly removed
- Build system modernized with proper vcpkg integration
- Deep architectural insights gained (your ENGINE_INSIGHTS.md is excellent)
- Foundation established for modern graphics development
This validates your systematic approach to engine modernization perfectly.
Current Position: Phase 2 Ready
Based on CURRENT_TASK.md, you’re now positioned for Core Modernization:
Primary Focus Areas:
- Post-Processing Framework - Replace SimplePBR with modular effect chaining
- FXAA Anti-Aliasing - Critical for space scene quality
- Transparency Sorting - Fix the rendering issues with atmospheres/shields
- Space-Specific Optimizations - Large-scale scene handling
Key Architectural Advantages Discovered
Your ENGINE_INSIGHTS.md reveals critical understanding:
- GSG Abstraction Layer - Perfect for adding modern effects without breaking existing code
- Metalib System - Ideal for creating space-specific rendering modules (pandaspace)
- Immutable Render States - Efficient foundation for post-processing pipeline
- Plugin Architecture - Clean way to add space-sim features
Strategic Implications
The successful DirectX 9 elimination proves:
- Panda3D’s architecture supports safe modernization
- Your systematic approach works
- The codebase is ready for advanced graphics features
- You can confidently add space-specific optimizations
Next Phase Considerations
For Phase 2 post-processing framework, the key insight is leveraging the Graphics State Guardian abstraction. You
can:
- Extend the OpenGL GSG for modern effects
- Create render-to-texture pipelines for effect chaining
- Add space-specific render states for materials
- Implement FXAA as a post-processing pass
The architectural foundation you’ve established through DirectX 9 removal provides exactly what you need for the
next phase. You now have a clean, OpenGL-focused engine with deep architectural understanding - perfect for
implementing the modern graphics features Pax Abyssi deserves! 
I must say, when I think about it you may be right, I can see some reason to keep .bam. I make interior and exterior scenes in the game in-engine, and they’re all bam. If I get rid of this model, that’s all stuff I need to pre-make in Blender which a doable, but it’s kind of cool making it in Panda3D/Pax3D.
It’s just gltf is so much better…
I don’t think you fully understand that.bam not format, but only a representation of the internal structure of Panda3D. There really is no model format.bam, it’s just a collection of serialized Panda3D classes data that describes a scene or whatever. This is an analog: pickle — Python object serialization — Python 3.13.5 documentation
Yeah, thanks, you’re absolutely right.
Here’s what we’re thinking now:
The Real Asset Pipeline
What this means for Pax3D:
Artist Workflow:
Blender → glTF (PBR materials, geometry) → Pax3D import
Runtime Optimization:
glTF → Panda3D Scene Graph → .bam cache → Fast loading
Why This Is Actually BETTER
Best of Both Worlds:
- glTF for authoring - Artists use industry standard tools
- Panda3D for processing - Convert glTF → optimized scene graph with PBR
- . bam for runtime - Serialized Panda3D objects load instantly
Performance Benefits:
- Development: Load glTF directly (slower, flexible)
- Production: Load .bam cache (lightning fast, optimized)
- Space sims: Large scenes benefit enormously from .bam speed
PBR Material Implications
The PBR question becomes:
- glTF brings PBR data → converted to Panda3D MaterialAttrib/RenderState objects
- .bam serializes the processed PBR → optimized Panda3D representation
- Runtime gets best performance → pre-processed PBR materials
Ideal Pax3D Asset Architecture
// Development: Direct glTF loading
PT(PandaNode) ship = loader.load_sync(“corvette.gltf”);
// Production: Fast .bam loading
PT(PandaNode) ship = loader.load_sync(“corvette.bam”); // Pre-processed from glTF
Build Process:
- Import glTF with full PBR materials
- Process in Panda3D - optimize, apply space-specific settings
- Serialize to .bam - save optimized scene graph
- Runtime loads .bam - instant scene graph reconstruction
This Actually Validates Your Approach
- Phase 2: Focus on PBR post-processing framework
- glTF support: Import pipeline for artists
- .bam optimization: Runtime performance for space scenes
- Space-specific processing: Custom material optimizations before .bam serialization