Image resize interpolation option!

This is also a waste of GPU RAM, which is limited to a few MBs on integrated chips, there’s also not much reason to waste all that file size in useless pixels


This is also a waste of GPU RAM, which is limited to a few MBs on integrated chips, there’s also not much reason to waste all that file size in useless pixels[/quote]

Plus it takes years to download the image in the first place on some connections. I hate staring at my invisible, non-usable Gui while every other player jumps around laughing and overall having a great time without me :frowning:

For whatever reason it takes the Roblox client a lot more time to load a decal than it does my browser for the same decal :uhhh:


[quote] This is also a waste of GPU RAM, which is limited to a few MBs on integrated chips, there’s also not much reason to waste all that file size in useless pixels [/quote]If you want to display a larger image, you use a larger image. GPU RAM is irrelevant since the image is being scaled regardless given the context.

[quote] Scaling highres images gives u a blurry small image aswell. [/quote]If you are scaling uniformly then this shouldn't be an issue.
1 Like

@Woot: Larger image dimensions = larger file size = longer download time. Lots of big images = noticeable download time. Better to upload as a small image.


There should be an ImageInterpolationStyle Enum. It will contain:

None – i.e. when you make the image larger, each ‘pixel’ scales with the image. It will produce results similar to Minecraft (where you make a small 16x16 texture, and it ends up something like 128x128 in-game keeping the same ratio)
Linear/Bilinear – Normal scaling (current)

This way, the option is there in the future to add more interpolation types which improve the quality of the image more, at the cost of CPU cycles. For example, Lanczos3 interpolation could be added in the future.

1 Like

I’m currently working on a project which has a pixelized style, and I would like to render these at 2-5x in both dimensions.

It would be really nice if we could have constant / nearest-neighbor interpolation as a feature for textures, at the very least for the 2D image objects (ImageLabel and ImageButton).

Right now, if I don’t want the image to look smoothed due to interpolation like in OP, with N the scale factor:

  • I would have to upload about O(N^2) times the amount of spritesheets :frowning:

  • Clients would have to download ~O(N^2) times the size in textures :frowning:

  • Devices would need to use/swap/free/whatever O(N^2) times as much texture memory as well :frowning:

This all seems really inefficient especially for large pixel-art backgrounds. More interpolation methods for textures would make this kind of art style a lot easier to pull off.


I’m also working on a game whose art style would benefit from nearest neighbor interpolation. Since I doubt we’d use anything beyond NN or bilinear interpolation, a boolean “Smooth” parameter could be added to textures etc. Alternatively there could be an Enum “Interpolation” that could be either “Smooth” or “None” to keep names simple.



It looks bad. Please consider adding at least NN for pixel art games.


Been making my game entirely around a pixelated style. It’s pretty annoying having to deal with blurry images, even in non-pixelated games. Even if the image looks off, I want it to look crisp – we should at least have the option to choose blurry or crisp.


I say Roblox implement some level of MipMaps to images. Sure, it would increase load times (which is minuscule 99% of the time. If your connection is too poor to handle a few images, you shouldn’t be on an Online platform in the first place in my opinion) but it would definitely increase the range of the type of games people could create.

The only problem I can see with choosing what texture-filter an image uses is I think filtering like Bilinear and Trilinear might have some level of performance impact, or that might just be Anisotropic Filtering x2 and above. But something like Nearest Neighbor, aka pretty much no filtering at all, should definitely be an option.

In the mean time, you can increase an image’s size to 512 x 512 in Gimp or PaintDOTNet and set the rescaling system to Nearest Neighbor. Of course, you’ll have to reupload your assets, but it’ll give you the effect you want.

1 Like

As a Roblox developer, it is currently too hard to have pixelated textures look smooth when upscaled, so please just add a toggle or something to make this not happen.

If Roblox is able to address this issue, it would improve my development experience because things like this wouldn’t look cut-off and blurry

This is what the texture used looks like:



Currently on Roblox it’s almost impossible or too hard to disable texture filtering.

I came with the idea to make a game on Roblox that uses semi-low-poly models with a low resolution/pixelated texture style to make it look more retro/classic/old.

But stumbled upon this problem.

Image of my texture getting blurry/stretched out due the “texture quality filter”.

So to test this out, I uploaded a cube that I UV mapped and that uses a 400x400 texture (I use only about 1/20th of the whole image to go down to even lower resolutions), the issue is, when a texture is stretched over a surface, the render engine begins to filter and blur it, which is going to be a big problem.

I have found a band-aid solution to this which is to downscale my textures and then rescale them to full resolution with nearest-neighbor on, that way it still looks pixely, sort of, it still tends to get blurry at some edges or when you stretch the texture over a part, it’s impossible to get 100% sharp/hard pixels without a filter applied to it.

I’d greatly appreciate if Roblox (or the engineers) were to implement a feature where this blurry texture filter can be disabled on textures that have to be intentionally low-resolution/pixelated for the style and feel of certain games.

Because of this issue I have to seek band-aid solutions and makes it fairly difficult to make my game, forcing me almost to come up with a new graphics design.

Just a simple feature to set texture quality filtering mode or at least be able to exclude some textures/decals from it would be amazing so said graphic styles can be made more easily without this obnoxious blurring and stretching.

Edit: It so appears to be 2021 and somehow this is still a feature request despite a ton of game engines already having this as a literal primitive/default option for textures ever since the beginning of the first 3D games that supported rendering with textures.


This is especially true for sprite sheets. The new video frame feature isn’t a good alternative for this use case, but stuffing 10 or more frames into a single pitiful 1024x1024, only to have them upscaled with the worst possible algorithm isn’t much better.


Five years later and this is still an issue:
My use case is also spritesheets. If I had a series of 16x16 sprites I’d be able to fit 4096 of them onto one 1024x1024 image (the maximum image size), but if I have to scale them up to 128x128, I’d only be able to fit 64 into one image. A property to select scaling quality on a Decal/ImageLabel/ImageButton would help us out immensely.


Bumping again. This would be incredibly valuable for Islands. We currently are using 128x128 texture files to try to get the same visual effect as Nearest Neighbor on 16x16 game textures. Another pixel game that has a better visual effect said their solution is 1024x1024 texture files for 16x16 game textures. This is horribly inefficient and causes the client to download way more data than should be necessary. If we were to follow that same approach, we would force clients to download 4096x more data for block textures than is required.

To summarize our issue quickly: we are forced to decide between sharp graphics and performance. This feature would allow us to have both.


This is still a major issue. Roblox is a web-based platform, meaning download sizes are everything. Having to upload 1024x1024 images to represent 16x16 pixels is unacceptable.


Pardon the bump, but this was filed Jan '19, albeit in a different topic, though there does not appear to have been a situation update by @RoughSphereBlox since. See:

EDIT: Here’s a useful addition to this request I would appreciate:

BlendIgnoreAlpha option. In a LOT of video games you get this appearance, albedo separates full alpha transparent from blend. Performant, quick to make, an interesting organic smoothing effect as well.
As a dropdown also including a sharp or inorganic corners option to alphaSeperate would improve the case for metal bars, tbh HL1 weird here:



Roblox really should take action fixing this issue as soon as possible. As days pass, there will be more and more images uploaded that are upscaled to 1024 pixels, further deteriorating player experience. This is also a comparably minor change (compared to Luau and everything else on the roadmap) that would have a high impact on network performance and visual presentation in the long run.


It would be awesome if nearest neighbor for images was added. Roblox has done a great job expanding into more realistic art styles, but I think they should also focus on making other styles possible. Adding nearest neighbor interpolation for images would enable developers to create pixel art games, which would diversify the appearance of games experiences on Roblox.

Also, many games that aren’t necessarily pixel art games would be able to make use of this. Things like pixelated weapon skins, vehicle wraps, signs, etc. could be added much easier.

If an Enum for image interpolation is added, it should be added to all instances with an image property. That includes:

  • ImageLabel
  • ImageButton
  • Decal
  • Texture
  • SurfaceAppearance
  • Sky
  • ImageHandleAdornment
  • ParticleEmitter
  • MeshPart
  • SpecialMesh
  • There’s probably others that I forgot

Most pixel art games are 2D, but Roblox doesn’t really have 2D. While they are rarer, there are some good examples of 3D pixel art games. These types of games could exist on Roblox if nearest neighbor was added.


Looks like they’re rolling this out for UI objects:

Unfortunately doesn’t include anything other than ImageObjects in UI by the looks of it, but that’s still a lot of use cases related to this fulfilled already.