How to make a PS1 (PSX) look in Godot 4
Pack for this guide: Crisp PSX Cozy Cabin (free sampler on itch.io).
Short answer: Render the 3D scene into a small SubViewport (a quarter of the window, for example) shown through a SubViewportContainer with nearest filtering, and give the models a spatial shader that snaps each vertex to a coarse screen grid (the PS1 wobble) and interpolates UVs without perspective correction (the affine texture warp). Sample textures with nearest filtering and no mipmaps, and finish with a canvas shader that cuts the colour to 15-bit with an ordered dither.
1. Know what makes the PS1 look
- Low resolution: most games ran at 320 x 240 or close to it.
- Vertex wobble: positions were snapped to whole pixels, so geometry jitters as the camera moves.
- Affine textures: textures were mapped without perspective correction, so they swim and bend on big polygons.
- No texture filtering and no mipmaps: crisp, blocky texels.
- 15-bit colour with dithering: 32 levels per channel, with a fine pattern hiding the bands.
- Small textures (64 to 128 px), low polygon counts, vertex lighting and fog to hide the draw distance.
2. Render at a low resolution
Scene tree
Main (Node)
+- View (SubViewportContainer) stretch: on, stretch_shrink: 4, texture_filter: Nearest, anchors: Full Rect
+- SubViewport
+- World (Node3D) psx_apply.gd
+- Camera3D
+- DirectionalLight3D
+- your level
With stretch on, the SubViewport always matches the container's size divided by stretch_shrink: a 1280 x 720 window renders the world at 320 x 180 with 4, or 640 x 360 with 2. Setting the container's texture_filter to Nearest scales that image up with hard pixel edges. Draw your HUD outside the SubViewport if you want sharp text over the chunky world.
3. Write the PSX surface shader
psx_surface.gdshader
shader_type spatial;
render_mode diffuse_lambert, specular_disabled, vertex_lighting;
uniform sampler2D albedo_tex : source_color, filter_nearest;
uniform float snap_resolution = 120.0; // rows of the grid vertices snap to (0 = off)
uniform float affine_amount = 1.0; // 0 = correct textures, 1 = full PS1 warp
varying vec3 affine_uv;
void vertex() {
vec4 clip = PROJECTION_MATRIX * (MODELVIEW_MATRIX * vec4(VERTEX, 1.0));
if (snap_resolution > 0.0 && clip.w > 0.0) {
vec2 grid = vec2(snap_resolution * VIEWPORT_SIZE.x / VIEWPORT_SIZE.y, snap_resolution) * 0.5;
clip.xy = round(clip.xy / clip.w * grid) / grid * clip.w;
}
POSITION = clip;
affine_uv = vec3(UV * clip.w, clip.w);
}
void fragment() {
vec2 uv = mix(UV, affine_uv.xy / affine_uv.z, affine_amount);
vec4 tex = texture(albedo_tex, uv);
if (tex.a < 0.5) {
discard;
}
ALBEDO = tex.rgb * COLOR.rgb;
ROUGHNESS = 1.0;
}
- Vertex snapping: the position is divided by
w(giving screen space), rounded to a gridsnap_resolutionrows tall, and multiplied back. Lower numbers wobble more. - Affine warp: Godot's shading language has no
noperspectivequalifier, so the shader multiplies the UV bywin the vertex stage and divides it back in the fragment stage, which cancels the GPU's perspective correction.affine_amountblends between the two. filter_nearestsamples the texture with no filtering and no mipmaps.COLORmultiplies in baked vertex-colour shading; meshes without vertex colours read white, so nothing changes.vertex_lightinglights each vertex instead of each pixel, like the PS1 (Godot 4.3 and newer).
4. Apply it to your models
psx_apply.gd
extends Node3D
## Gives every mesh under this node the PSX shader, keeping each surface's own texture.
const PSX_SHADER := preload("res://psx_surface.gdshader")
func _ready() -> void:
for mi: MeshInstance3D in find_children("*", "MeshInstance3D", true, false):
for i in mi.mesh.get_surface_count():
var old := mi.get_active_material(i)
var mat := ShaderMaterial.new()
mat.shader = PSX_SHADER
if old is BaseMaterial3D:
mat.set_shader_parameter("albedo_tex", old.albedo_texture)
mi.set_surface_override_material(i, mat)
find_children() is called with owned = false so it also finds the meshes inside imported .glb and .fbx scenes. Each surface keeps the albedo texture of its imported material. If all your models share one texture atlas, one ShaderMaterial saved as a .tres and set as material_override does the same job.
5. Add 15-bit colour and dithering
psx_dither.gdshader
shader_type canvas_item;
uniform float levels = 32.0; // colour steps per channel: 32 = the PS1's 15-bit colour
uniform bool dither = true;
const float BAYER[16] = float[16](0.0, 8.0, 2.0, 10.0, 12.0, 4.0, 14.0, 6.0,
3.0, 11.0, 1.0, 9.0, 15.0, 7.0, 13.0, 5.0);
void fragment() {
vec4 c = texture(TEXTURE, UV);
ivec2 p = ivec2(UV * vec2(textureSize(TEXTURE, 0)));
float b = dither ? BAYER[(p.y % 4) * 4 + (p.x % 4)] / 16.0 - 0.5 : 0.0;
c.rgb = floor(c.rgb * (levels - 1.0) + 0.5 + b) / (levels - 1.0);
COLOR = vec4(clamp(c.rgb, 0.0, 1.0), 1.0);
}
Give the View container a ShaderMaterial with this shader. Its TEXTURE is the SubViewport's image, so the dither pattern lands on the low-res pixels and is scaled up with them. levels = 32 is the PS1's 5 bits per channel; try 16 for a harsher look.
6. Finish the look
- Keep textures at 64 to 128 px per object, or share one small atlas, and keep models in the hundreds of triangles.
- Turn on fog in the
WorldEnvironmentso distant objects fade instead of popping in. - Tune
snap_resolutionto taste: 120 rows is clearly PS1, 240 is subtle. Set it to 0 on objects that should stay still, such as UI models. - Large floor polygons warp the most; split them into a grid of smaller quads if the swimming is too strong.
How this was tested
Run headless in Godot 4.7.2: both shaders compile, the SubViewport renders at exactly a quarter of the window, and psx_apply.gd gave the chair.glb prop from the Crisp PSX Cozy Cabin free sampler the shader with its own texture.
Free assets to try
Crisp PSX Cozy Cabin Free: 8 cozy low-poly props (chair, mug, bread loaf, jam jar, crate, barrel, pumpkin, lantern) as .glb, .fbx and .obj sharing one 512 px pixel-texture atlas, with soft shading baked into the vertex colours that the shader above multiplies in. Download Crisp PSX Cozy Cabin Free.
The full Crisp PSX Cozy Cabin ($4.99) has 63 props (furniture, kitchen, clutter, an autumn yard and a modular log cabin) and a Godot 4 demo project with its own PSX shader: vertex snapping, affine warp, low-res render with 15-bit colour and dither. Claude (an AI assistant) designed everything in this pack: every prop is modelled and textured by code. All 19 Crisp packs are also in the Crisp Everything Bundle for $17.99.