One short prompt, one sprawling neon skyline #
Analyst Matthew Berman recently challenged Google’s Gemini 4 Argon with a single prompt: "build the most incredible hyper-realistic 3D animation of a cyberpunk 3D city using 3JS. The more detailed, the better. make sure it runs at least 30 frames per second, preferably 60, lots of neon colors, car flying through tall building." Thirty minutes later, Argon delivered.
Despite the brevity of Berman's input, the model generated a sprawling, interactive cyberpunk cityscape rendered directly in the browser. Viewers could explore a dense urban scene complete with towering skyscrapers, intricate lighting, and animated flying vehicles. The result maintained a consistent 60 frames per second (FPS), proving its ability to handle complex WebGL graphics.
Berman noted the model "may have gone a little bit overboard on the neon colors," but called the overall output "fantastic." This test showcased Argon's advanced code synthesis and long-horizon generation capabilities, producing a substantial browser-based 3D environment from minimal instruction.
Crucially, this was a focused creative coding demonstration, not a full production application. The experiment highlighted Argon’s capacity for autonomous performance tuning and interpreting creative intent to deliver complex, high-fidelity graphical results. It underscores the model's impressive ability to translate simple text into rich, interactive 3D experiences.
The hard part wasn’t making it glow #
Generating a static image of a futuristic city is one thing; building a dynamic, interactive Three.js scene is another entirely. That requires the AI to synthesize a complete 3D environment, including:
- Precise geometric models for buildings and objects
- A virtual camera with a defined perspective
- Complex lighting shaders to create realistic illumination
- A render loop to continuously update the scene
- Coordinated animation for moving elements
Berman’s prompt produced a detailed urban landscape, running at a smooth 60 frames per second in the browser. Towering skyscrapers dominated the view, bathed in the glow of ubiquitous neon. A flying vehicle animated through the scene, seamlessly integrated into the bustling cityscape.
This wasn’t just a pretty picture; it was a fully functional, real-time 3D experience. The model managed to interpret the creative intent of “cyberpunk city” and translate it into performant WebGL code in about 30 minutes.
The only noted drawback was a slight over-saturation of neon colors, a creative choice by the AI rather than a technical flaw. Gemini 4 Argon clearly understood the assignment, delivering a vibrant, animated world from a remarkably simple prompt.
Thirty minutes to code; 60 FPS to watch #
Berman reports the code generation took about 30 minutes from initial prompt to a fully rendered 3D scene. The resulting Three.js animation ran smoothly, achieving a consistent 60 frames per second (FPS) in the browser. This high frame rate suggests a truly dynamic, animated scene, not just a static image or pre-rendered video.
High FPS is crucial for real-time interactivity and responsiveness in a 3D environment. While 60 FPS is excellent, remember that performance can vary significantly. Factors like your device's hardware, browser, screen size, and other active applications can all impact how smoothly a complex scene renders.
One demo, however impressive, doesn't establish consistent performance across all possible scenarios. This experiment doesn't provide a repeatable benchmark to compare Gemini 4 Argon's speed or efficiency across different projects or hardware configurations. It simply showcases a single impressive, if unscientific, demonstration.
Still, the ability to build a detailed, animated 3D city and achieve a high frame rate with minimal prompting is remarkable. For more on Google's AI models, you can check out Google DeepMind - Gemini. The speed and complexity of the output hint at Gemini 4 Argon's advanced spatial reasoning and long-horizon generation capabilities.
Enjoying this? Get one like it in your inbox each morning.
one email a day · unsubscribe in two clicks · no third-party tracking
A striking demo, not a production verdict #
Berman’s quick test certainly shows off Argon’s ability to turn a simple creative brief into a detailed, animated Three.js prototype. The model generated a complex 3D scene with geometry, lighting, and flying cars from a very short prompt, requiring little visible prompt scaffolding. That’s impressive.
But a demo isn't a finished product. We still don’t know if this generated code is maintainable for a team, or easy to modify and debug. Will it run robustly on various devices, or can it handle precise revisions and much larger, more complex scenes? The video doesn’t answer these practical questions.
For developers and creators, this means treating AI-generated code as a powerful starting point, not a final solution. Always inspect and thoroughly test the output. Judge AI coding tools by their iteration speed and overall reliability, not just by a spectacular first impression. The real value of Gemini 4 Argon will come from how well it supports the entire development lifecycle, allowing for easy refinement and consistent performance. A stunning demo is one thing; consistent, production-ready code is another.
Frequently Asked Questions #
What did Gemini 4 Argon create in the video?
It generated a browser-based cyberpunk city scene using Three.js, with neon-lit buildings and a flying vehicle.
How long did the generation take?
Matthew Berman says the process took about 30 minutes.
Did the demo run at 60 frames per second?
Berman reports that the scene ran at 60 FPS in the browser during his demonstration.
Does the demo prove Gemini 4 Argon can build production-ready 3D apps?
No. It shows a promising single scene, but does not establish reliability, maintainability, or performance across devices and projects.