arcadegnt

Make good-looking games without asset generators

You don't need an art tool to make a game that looks released. Most of what makes a game look good isn't the models or the sprites. It's the light, the colour, the sky, the water and the way things move. Your assistant can write all of that in code, in the same chat where it writes the game. There are no keys, no credits to buy and no files to upload, and the game stays small enough to load fast on a phone.

This guide covers the tricks that make the biggest difference, what to ask for, and a few short snippets if you want to see how they work. Everything here runs on the Compatibility renderer that arcadegnt uses for the web.

Why code-built art works

Put a plain grey box under a warm sunset, with soft fog behind it and a glowing edge, and it looks like a design choice. Put a detailed model under flat white light on an empty background and it looks like a prototype. Players notice four things first:

All four come from code. Simple shapes lit well beat detailed shapes lit badly.

1. Pick a look and a palette first

Before any code, give the game a style in one sentence and four or five colours. "Low-poly island at golden hour, warm oranges and teal water." "Neon racer at night, magenta and cyan on near-black." "Storybook forest, soft greens with cream highlights."

Low poly, neon, toy-like, papercraft and silhouette styles all suit code-built art. Photoreal does not. Name the style in your first prompt and your assistant can keep every material, light and particle to the same palette.

2. Light the scene before you add detail

In a 3D game, lighting does more than anything else. Ask for:

var env := Environment.new()
env.background_mode = Environment.BG_SKY
env.sky = Sky.new()
env.sky.sky_material = ProceduralSkyMaterial.new()
env.tonemap_mode = Environment.TONE_MAPPER_ACES
env.glow_enabled = true
env.fog_enabled = true
env.fog_light_color = Color("f2b880")
env.fog_density = 0.01

Fog is the cheapest depth you will ever get: distant things fade into the sky colour and the world looks bigger than it is. Match the fog colour to the horizon.

If you see bold diagonal stripes across lit walls, that's shadow acne. Ask your assistant to raise the light's shadow_bias and shadow_normal_bias. The build guide has the numbers.

3. Procedural textures instead of flat colours

A flat colour is what makes a code-built model look like a placeholder. Godot can make textures from noise while the game loads, and they cost nothing to download.

var noise := FastNoiseLite.new()
noise.frequency = 0.03
var ramp := Gradient.new()
ramp.set_color(0, Color("4a3b2a"))
ramp.set_color(1, Color("9c8463"))
var tex := NoiseTexture2D.new()
tex.noise = noise
tex.seamless = true
tex.color_ramp = ramp

var mat := StandardMaterial3D.new()
mat.albedo_texture = tex
mat.uv1_triplanar = true
mat.roughness = 0.9

Change the two colours and the frequency and the same ten lines give you sand, moss, lava rock or snow.

4. Water that looks like water

Water is where code-built games most often look cheap, and where a small shader makes the biggest jump. Good game water is almost never one effect. It's several cheap ones stacked together.

3D water

Ask for a water shader with these layers:

  1. Waves in the vertex shader. Move the surface up and down with a few overlapping sine waves. Use a PlaneMesh with enough subdivisions to bend.
  2. Two scrolling normal maps. The same noise texture scrolled in two directions at two scales. The ripples never repeat, and the sun glints off them.
  3. Fresnel colour. Deep colour when you look straight down, bright sky colour at a low angle. This one line is what makes it read as water and not blue plastic.
  4. Low roughness so the sun leaves a sharp highlight.
  5. A little transparency so the shore shows through the shallows.
shader_type spatial;

uniform vec4 deep : source_color = vec4(0.02, 0.18, 0.28, 1.0);
uniform vec4 sky : source_color = vec4(0.55, 0.8, 0.9, 1.0);
uniform sampler2D ripples : hint_normal, repeat_enable;

void vertex() {
	VERTEX.y += sin(VERTEX.x * 0.5 + TIME) * 0.12 + sin(VERTEX.z * 0.35 + TIME * 1.4) * 0.08;
}

void fragment() {
	vec2 uv = UV * 6.0;
	vec3 a = texture(ripples, uv + TIME * vec2(0.03, 0.01)).rgb;
	vec3 b = texture(ripples, uv * 1.6 - TIME * vec2(0.02, 0.035)).rgb;
	NORMAL_MAP = mix(a, b, 0.5);
	float fresnel = pow(1.0 - clamp(dot(NORMAL, VIEW), 0.0, 1.0), 3.0);
	ALBEDO = mix(deep.rgb, sky.rgb, fresnel);
	ROUGHNESS = 0.05;
	ALPHA = 0.85;
}

Then add the cheap extras that sell it:

2D water

In 2D, the same ideas get simpler:

shader_type canvas_item;

uniform sampler2D noise : repeat_enable;

void fragment() {
	vec2 wobble = (texture(noise, UV * 2.0 + TIME * 0.05).rg - 0.5) * 0.02;
	COLOR = texture(TEXTURE, UV + wobble) * vec4(0.6, 0.85, 1.0, 1.0);
}

5. Skies and backgrounds

An empty background is the clearest prototype giveaway. Fill it.

6. Models from shapes

Your assistant can model convincingly in code from boxes, spheres, cylinders, prisms and tori. The trick is many parts, each with its own material:

Low poly with good materials is a style in its own right. Bevel the edges with a slightly smaller copy of the shape in a lighter colour, add an emissive strip, and a plain box becomes a sci-fi crate.

7. Motion and feedback

A still screenshot can look great while the game still feels flat. These are cheap and make a big difference:

8. Sound, also from code

Sound is half of how a game feels. Your assistant can make it from scratch: short square and noise waves with a fade for jumps, coins and explosions, and a looping music track built from a chord progression, a bass line and drums. It won't sound like a studio soundtrack, but it fits a game with a code-built look far better than silence.

Faking what the web can't do

The web renderer leaves out some high-end effects. Each one has a classic fake:

EffectThe fake
Bloom on bright thingsEmission plus glow in the WorldEnvironment
Ambient occlusion in cornersDarker colours or a dark gradient where surfaces meet
Volumetric fog and light shaftsRegular fog, plus a few soft additive cones or planes
Real reflectionsFresnel colour plus a sharp sun highlight
Global illuminationA coloured ambient light and coloured accent lights that bounce the scene's colours

Your first game with code-built art

Paste a prompt like this one:

Make a 3D boat game with arcadegnt, with no asset generators: build all the art in
code. Low-poly islands at golden hour, warm oranges and teal water. Light the scene
first: a low warm sun with shadows, ACES tonemapping, glow and soft fog. Give every
surface a procedural noise texture. Write a water shader with vertex waves, two
scrolling normal maps, fresnel colour and foam around the islands and behind the boat.
Add a title screen and sounds made in code. Build it and check it on desktop and phone.

Your assistant will:

  1. Write the scene, the materials and the shaders in GDScript.
  2. Build the game, fixing any errors arcadegnt reports with file and line.
  3. Play it with check_game on a desktop and a phone, look at the screenshots, and fix what looks flat or wrong.

You get a link like https://golden-harbor.arcadegnt-play.com/ that anyone can open on a computer or phone.

Tips for better results

When to reach for an asset generator

Code-built art is great for environments, water, skies, effects, props and stylised vehicles. A few things are hard to get from shapes in code, and that's when a generator helps:

When the game is ready, ask your assistant to submit it to the arcadegnt gallery so other people can play it.