SpritePilot Backgrounds Pack: 6 pixel art parallax scenes
https://spritepilot.com/free-game-assets/backgrounds

Layered backgrounds for 2D platformers and side scrollers. Every scene is
four layers of 384 x 216 pixels (a 16:9 pixel art screen) that you scroll
at different speeds to get depth.

LICENSE
CC0 1.0 (public domain): use these in any project, commercial or not,
change them and share them. No credit needed (a link to spritepilot.com is
always appreciated). See LICENSE.txt.

THE SCENES
  Forest          forest/         Pine and broadleaf woods under misty lavender mountains, big trunks in front.
  Desert          desert/         Red rock country at golden hour: mesas, a natural arch, dunes and cacti.
  Cave            cave/           A crystal cavern: fog lit columns, glowing crystals and mushrooms, stalactites in front.
  Night City      night-city/     A moonlit city: starry sky, hazy skyline, lit windows, a rooftop with lamps in front.
  Snow Mountains  snow-mountains/ High country in winter: snowy peaks, a snow laden pine forest, deep drifts in front.
  Ocean Beach     beach/          A tropical morning: open sea with islands, rolling waves, palms and sand in front.

WHAT'S INSIDE EACH FOLDER
  <scene>-1-sky.png      the back: opaque, fills the screen
  <scene>-2-far.png      distant shapes, transparent around them
  <scene>-3-middle.png   the middle distance, transparent
  <scene>-4-near.png     the foreground, transparent
  <scene>.png            the four layers stacked, at 1x
  <scene>-4x.png         the same at 4x (1536 x 864), for a quick look

Stack them in that order (1 at the back). Every layer repeats sideways
without a seam: put copies side by side, or let the engine repeat them.
They don't repeat vertically. Pixels are either fully opaque or fully
transparent, so edges stay crisp and never pick up dark fringes.

SPEEDS THAT LOOK RIGHT
Multiply the camera's movement by these factors (1.0 moves with the
camera, 0 stays put):
  sky 0   far 0.2   middle 0.5   near 1.0
For a softer foreground, try near 0.8. The page at the link above shows
every scene moving at these speeds, with its layers pulled apart.

SHARP PIXELS
Use nearest neighbor ("point") filtering and scale by whole numbers:
384 x 216 fills 1920 x 1080 at exactly 5x and 3840 x 2160 at 10x.

GODOT 4
  Godot 4.3 or newer: add a Parallax2D node per layer, each with a Sprite2D
  child (Centered off). Set the node's Scroll Scale x to the speed above
  and Repeat Size to (384, 0); set Repeat Times to 3 if you zoom out.
  Older Godot 4: ParallaxBackground > one ParallaxLayer per layer, each
  with a Sprite2D child (Centered off). Motion Scale = (speed, 1) and
  Motion Mirroring = (384, 0).
  Either way: Project Settings > Rendering > Textures > Default Texture
  Filter = Nearest.

UNITY
  Import each PNG with Texture Type Sprite, Filter Mode Point (no filter),
  Compression None, Wrap Mode Repeat, Mesh Type Full Rect, and the same
  Pixels Per Unit as your game's art (16 is common).
  Give each layer a SpriteRenderer with Draw Mode Tiled and a width of three
  copies (3 x 384 / Pixels Per Unit), pivot Center, and order them 1 to 4
  with Order in Layer. This script scrolls a layer at its speed and hops it
  by one width so it always covers the view:
    public class ParallaxLayer : MonoBehaviour {
      public float speed = 0.5f;          // sky 0, far 0.2, middle 0.5, near 1
      public float pixelsPerUnit = 16f;
      Transform cam; float startX;
      void Start() { cam = Camera.main.transform; startX = transform.position.x; }
      void LateUpdate() {
        float w = 384f / pixelsPerUnit;
        float x = startX + cam.position.x * (1f - speed);
        x += Mathf.Round((cam.position.x - x) / w) * w;
        transform.position = new Vector3(x, transform.position.y, transform.position.z);
      }
    }

PHASER 3
  new Phaser.Game({ pixelArt: true, width: 384, height: 216, ... })
  this.load.image('far', 'forest/forest-2-far.png')
  // two copies side by side, fixed to the screen
  const far = [0, 384].map(x => this.add.image(x, 0, 'far')
    .setOrigin(0, 0).setScrollFactor(0))
  // in update(): the camera position times the factor, wrapped every 384
  const x = -Phaser.Math.Wrap(this.cameras.main.scrollX * 0.2, 0, 384)
  far[0].x = x
  far[1].x = x + 384
  Do the same for each layer with its own factor; add the sky first.
  Avoid tileSprite for these layers: in WebGL, Phaser 3 resizes its
  texture to a power of two (384 becomes 512), which softens the edges.
