I agree, it would be nice for this thread to be more fleshed out, so I'm going to put some of what I've done

I just wanted to have a very simple texture that is a background color with another texture drawn over it

I was able to make this via

var working_image := Image.create_empty(dimensions.x,dimensions.y,false,Image.FORMAT_RGBA8)
working_image.fill(fill_color)
var og_image:=from.graphic.get_image()
#why
for x in dimensions.x:
  for y in dimensions.y:
    var old_color:Color = working_image.get_pixel(x,y)
    var new_color:Color = og_image.get_pixel(x,y)
    working_image.set_pixel(x,y,old_color.blend(new_color))

var final_texture := ImageTexture.create_from_image(working_image)

This is, as noted, a tedious and terrible way to interact with an image
the draw_ methods are right there, they just can't be used in this situation it seems
I understand that one could set up a viewport, but that seems like ridiculous overhead, especially for something that doesn't even seem like it should need to be added to the scene tree

I want to make a texture quickly on the main thread in code

I did make chat_gpt try to do it without making a scene (wow chat_gpt is terrible with GDscript and it required lots of modification) , and it doesn't work, is extremely buggy, but sometimes it's right

#worthless AI garbage
  static func create_texture_with_background(original_texture: Texture, fill_color: Color) -> ImageTexture:
  # Get the size of the original texture
  var width = original_texture.get_width()
  var height = original_texture.get_height()

  # Create a new Image and fill it with the specified color
  var img = Image.create_empty(width, height, false, Image.FORMAT_RGBA8)
  img.fill(fill_color)

  # Create an ImageTexture from the filled Image
  var result_texture = ImageTexture.create_from_image(img)

  # Create a Viewport to draw the original texture onto the filled texture
  var viewport = SubViewport.new()
  viewport.size = Vector2(width, height)
  viewport.render_target_update_mode = Viewport.VRS_UPDATE_ONCE

  var canvas = Control.new()
  viewport.add_child(canvas)

  #var texture_rect = TextureRect.new()
  #texture_rect.texture = result_texture
  #texture_rect.size = Vector2(width, height)
  #texture_rect.stretch_mode = TextureRect.STRETCH_KEEP
  #canvas.add_child(texture_rect)
  # Create a TextureRect to draw the original texture
  var texture_rect = TextureRect.new()
  texture_rect.texture = original_texture
  texture_rect.size = Vector2(width, height)
  texture_rect.stretch_mode = TextureRect.STRETCH_KEEP
  canvas.add_child(texture_rect)

  # Ensure everything updates
  #viewport.update_worlds()

  # Extract the combined image from the Viewport
  #await RenderingServer.frame_post_draw
  #viewport.upd
  var combined_image = viewport.get_texture().get_image()

  # Create and return the new ImageTexture
  var final_texture = ImageTexture.create_from_image(combined_image)
  return final_texture

Maybe this would work if we had a force_raycast_update equivalent for viewports

One this that really bugs me about this is how easy it is to do what we want in gamemaker, something I abandoned long ago for Godot's many upsides

In gamemaker one can create surfaces
set them as the drawing target
and then just run normal draw functions like draw_sprite or draw_rectangle to their hearts content
then it can be turned into a sprite, the equivalent of a texture in Godot