1) Don't manually scale things with OpenGL , just use the reference resolution (adjust for the aspect ratio if you don't want to squash/stretch things when going from 4:3 to 16:9 for example) when you create your orthographic projection matrix.

2) Use texture filtering and mipmaps to reduce scaling artifacts.

3) possibly use multiple sprite sets for different resolutions (it might be a good idea to remove small details at lower resolutions)

1) Don't manually scale things with OpenGL , just use the reference resolution (adjust for the aspect ratio if you don't want to squash/stretch things when going from 4:3 to 16:9 for example) when you create your orthographic projection matrix.

Fixed this, now it looks much nicer (but could still do with antialiasing).

However, this is kind of a hack I came up with to zoom in on all aspect ratios less narrow than 16:9. My reference resolution is 16:9, but I don't want black bars on 5:4, so I basically just zoom in until there are no bars anymore (that's at 2250x1800 for 5:4) Without the glScale hack, everything gets stretched. Any idea how to better solve this?

>2) Use texture filtering and mipmaps to reduce scaling artifacts.

If you got 3200x1800 at 16:9 and switch to a 5:4 resolution and want to cut off the sides rather than stretch or add black borders you can set glOrtho to use:

top: 1800

bottom: 0 (or swap them depending on which way you want your y axis to go)

and then since we only want a 2250 region we need to cut off 950 pixels on the sides (475px per side), thus:

left: 475

right: 2725

so glOrtho(475.0, 2725.0, 0.0, 1800.0, 0.0, 1.0) should do the trick.

or more generic:

if we have:

referenceResolution.x = 3200

referenceResolution.y = 1800

referenceResolution.aspect = referenceResolution.x / referenceResolution.y // 1.7777777777778 in this case

and:

resolution_x = 1280

resolution_y = 1024

aspect = resolution_x / resolution_y // 1.25 in this case

horizontalFactor = aspect / referenceResolution.aspect //0.703125 in this case

then in order to not get any borders we do:

width = referenceResolution.x * horizontalFactor // 2250 in this case

diff = referenceResolution.x - width // 950

left = diff/2

right = left+width

glOrtho(left,right,0.0, 1800.0,0.0,1.0)

if you switch to a aspect ratio that is wider than the reference you will see objects rendered at a negative x position (if nothing is rendered at a negative horizontal position you get a border)

to get the border on the side(Which you want if nothing is really rendered there anyway) at ultra wide resolutions(horizontalFactor > 1.0) you can just render one black (or textured if you want fancy borders) quad from 0.0,bottom(0 or 1800) to left, top(1800 or 0) and one from right,bottom to referenceResolution.x, top

As for the fonts, if scaling with mipmaps and filtering doesn't give clear enough results you could try to generate textures based on the vertical resolution, or look at the freetype-gl library and its distance field examples (that method requires OpenGL 2.0 but the results are really great)