Pixel Eras

Quick start

From an ordinary URP or HDRP scene to a retro game in under a minute:

1. Open Window → 4ssets → Retro Studio.
2. Press Make it Retro. It sets up the pipeline (URP: the Pixel Eras renderer feature on your renderers; HDRP: its two shaders in Always Included Shaders), adds a Pixel Eras Camera to the Main Camera and sets the 16-bit Console era. One Undo reverts it.
3. Pick another era in the Eras tab. Retro ON / OFF in the header compares before and after. To make it yours, press New style, name it, and tune every detail in the Look tab.
4. For a picture whose pixels never shimmer, make the camera orthographic and turn on Smooth Pixel Camera (see Pixel stability).
5. Optional: in Retro Studio's Assets tab press Convert scene materials (or select materials → Assets → 4ssets → Pixel Eras → Convert to Retro Shaders) for vertex wobble and affine textures, then check the Doctor tab for settings that fight the look.

Requirements

• Unity 6.0 LTS (6000.0.85f1) or newer.
• Universal Render Pipeline 17 or newer, with the Universal Renderer (Forward, Forward+, Deferred) or the 2D Renderer.
• Render Graph on every Unity 6 version. URP Compatibility Mode (Render Graph disabled) on Unity 6.0–6.3, where it exists. Unity 6.4 removed the mode, so Pixel Eras compiles its Compatibility code only on versions that have it.
• Or the High Definition Render Pipeline 17 or newer: see HDRP for what differs there.
• Demo only: Unity UI (com.unity.ugui). It uses the Input System when installed and the Input Manager otherwise.
• Built-in modules (Package Manager → Built-in): Animation, Particle System and UI, which every project has unless switched off. Physics and Terrain are optional: without Physics the Smooth Pixel Camera's automatic Focus Distance stays at 10 m, without Terrain the material converter skips terrains. The demo also needs Physics and Audio; without them it is left out of the compile instead of breaking the project.
• Enter Play Mode Options work with domain and scene reload switched off.
• Linear or Gamma colour space. Palettes and colour steps are matched in sRGB in both; only Unity's own lighting differs between them.

One package serves both pipelines: on import it detects which are installed and compiles only their code and shader passes, so nothing has to be removed or switched by hand.

Setup

Automatic

Window → 4ssets → Retro Studio → Make it Retro does the following:

• URP: adds the Pixel Eras renderer feature to every renderer of every URP asset in use (each quality level and the default);
• HDRP: adds the Uber and Present shaders to Project Settings → Graphics → Always Included Shaders, so player builds keep them;
• adds a Pixel Eras Camera to the Main Camera, or to any camera that renders to the screen when no camera is tagged MainCamera;
• sets the 16-bit Console era.

All of it is one Undo step. The Doctor tab then runs and lists anything left to fix.

Manual

1. URP: select your Universal Renderer Data (or 2D Renderer Data) → Add Renderer Feature → Pixel Eras. Repeat for every renderer your quality levels use. HDRP: add Hidden/4ssets/PixelEras/Uber and Hidden/4ssets/PixelEras/Present to Always Included Shaders.
2. Select the camera → Add Component → Pixel Eras → Pixel Eras Camera.
3. Assign an era from Pixel Eras/Eras/, or leave the era empty and add a Pixel Eras Look override to a Volume.

How it works

1. The Pixel Eras Camera lowers the camera's render scale, so the scene itself renders at the game resolution — about 320×224 for the 16-bit Console era. Nothing renders at full resolution and is then shrunk, so a retro look usually costs less than none.
2. The Uber pass runs at the game resolution, before post-processing: saturation and contrast, pixel edges, colour depth, dithering and the palette.
3. The pipeline's own post-processing then runs on the retro picture, still at the game resolution: Chromatic Aberration, Bloom, Vignette, Film Grain or Lens Distortion land on the palette, the dithering and the edges like on any other image. See Post-processing.
4. The Present pass scales the picture up to the screen (whole-number or Sharp Fill), with the sub-pixel shift of the Smooth Pixel Camera. Then it draws CRT and VHS at full resolution.
5. Screen Space Overlay UI is drawn after Present, sharp and at full resolution.

That is URP. HDRP has no per-camera render scale, so there the scene renders at the screen's resolution and the Uber pass takes the game picture from it — see below.

Post-processing

Pixel Eras works together with the pipeline's post-processing and never turns any of it off. Its picture is made first; your Volume effects are applied on top of it.

• Effects on top of the pixels: Chromatic Aberration, Bloom, Vignette, Film Grain, Lens Distortion, Panini, Motion Blur and Depth of Field all work as usual. In URP they run at the game resolution, so they come out in game pixels too.
• Tonemapping and Color Adjustments also apply after the palette and change its colours. For a palette shown exactly as defined, set Tonemapping to None (or Neutral, which changes least) and leave colour grading neutral; use the look's own Saturation and Contrast instead, which run before the palette.
• Pixel Eras works on displayable colours: anything brighter than white is clipped to white before the palette. Bloom still catches the brightest palette colours; lower its Threshold below 1 to make them glow.
• CRT and VHS are drawn last, over the post-processed picture, at full resolution.

HDRP

Everything in this guide works in HDRP unless noted here. Pixel Eras runs as one global Custom Pass before post-processing, registered by the package itself: no scene needs a Custom Pass Volume, and nothing is added to your scenes.

1. HDRP renders the scene at the screen's full resolution.
2. The Uber pass takes the game picture from it: the texel under the centre of every game pixel, or the average of a 2×2 block with 2×2 Sampling. The picture is therefore exactly as sharp and as aliased as URP's low-resolution render.
3. Present writes it back over the camera colour at its whole-number scale, with CRT and VHS. HDRP's post-processing then runs on it at full resolution, and its final pass copies the result to the screen.

What differs from URP

• Cost. The scene is not rendered at the game resolution, so the look costs a little (Uber at the game resolution, one full-resolution Present) instead of saving time.
• HDRP_RETRO/Lit and HDRP_RETRO/Terrain light from HDRP's own lights: the sun (the directional light that casts shadows) per vertex with HDRP's shadow per pixel, other directional, point and spot lights per vertex, and the sky's ambient probe. Area, box and pyramid lights, cookies, light layers, lightmaps and light probes are not read. Lighting is multiplied by the camera's exposure, as HDRP Lit does; HDRP_RETRO/Unlit colours and emission are written as they are, as HDRP Unlit does.
• Fog on Retro materials comes from HDRP's Fog override: HDRP fogs opaque surfaces, and transparent Retro materials fog themselves, as HDRP Lit does.
• Not supported in HDRP: Dynamic Resolution and upscalers (DLSS, FSR) — Pixel Eras sets the resolution itself, and Pixel Edges and Stable Dither would read the wrong pixels; MSAA turns Pixel Edges and Stable Dither off; XR. Camera anti-aliasing (TAA, SMAA, FXAA) works on the full-resolution scene and makes game pixels shimmer: turn it off.
• Custom Passes must be enabled in the camera's Frame Settings (they are by default).
• The Shader Graph sub graphs work in HDRP graphs. URP_RETRO/Sprite is a URP 2D Renderer graph; in HDRP, sprites convert to HDRP_RETRO/Unlit.

Doctor checks the HDRP side too: Always Included Shaders, Dynamic Resolution and camera anti-aliasing.

Workflows

Step-by-step recipes for the most common kinds of game. Each starts from a scene with Make it Retro done (Quick start), and each step links to where the setting is explained.

A 32-bit console game (first 3D consoles)

1. Retro Studio → Eras → 32-bit Console → Use. 240 game pixels tall, dithered 15-bit colour.
2. Assets → Convert scene materials, then Eras → Apply to Retro materials in this scene: vertex wobble, affine textures and point filtering from the era (Retro materials).
3. On the Pixel Eras Camera set Draw Distance (for example 40) and, in the look, turn on Retro Fog with Hide Draw Distance: far polygons drop out inside the fog (Fog).
4. On every lamp add Pixel Eras Light (a pattern for torches and neon); in the era's Lighting section set Light Rings to 3–4 (Pixel Eras Light).
5. In your style's Animation section set Frame Rate to 15, and on every character's root add Pixel Eras Animation and Pixel Eras Stepped Motion: they move in 15 steps a second (Stepped animation and motion).
6. Doctor → Fix all, then Play. Fine-tune with New style → Look.

3D pixel art (orthographic)

1. Set the camera's Projection to Orthographic and turn on Smooth Pixel Camera: the scenery keeps the same pixels while the camera glides (Pixel stability).
2. Use HD Pixel Art, or a style of your own, and set Resolution to Fixed Resolution at 360 (or 180): every player sees the same picture with no border on 720p, 1080p, 1440p and 4K (The same picture for every player).
3. In Pixel Edges use Outline 1, Position Outside, and a Highlight of about 0.5.
4. On objects that move across the screen add Pixel Eras Stepped Motion with Snap to Pixels (with a Frame Rate of 0 they still move smoothly, but always on whole pixels).
5. Select the art folder → Retro Studio → Assets → Import Rules → Add rules: point filtering, no mipmaps, no compression.
6. HUD: a Screen Space Overlay canvas with Pixel Eras Canvas Scaler, so a UI pixel is a game pixel (UI).

A 2D sprite game (URP 2D Renderer)

1. Make it Retro adds the Pixel Eras feature to your 2D Renderer Data.
2. Remove URP's Pixel Perfect Camera if the camera has one: the Pixel Eras Camera replaces it (Doctor offers the fix).
3. Set Resolution to Fixed Resolution at the height your art is drawn for, with Pixel Perfect scaling.
4. Give every sprite the same Pixels Per Unit, point filtering (Import Rules set both) and whole-number scales.
5. Optional: Convert to Retro Shaders turns sprite materials into URP_RETRO/Sprite — hit flash and dithered (screen-door) transparency.
6. Palette, dithering, colour depth, fog-free looks, CRT, VHS, composite and LCD all work; Pixel Edges and Stable Dither need the Universal Renderer and are skipped.

Looks that change in play

• From code: retro.TransitionTo(era, 1.5f) crossfades; setting retro.Era switches at once (see Scripting API).
• By place: clear the camera's era and drive the look from Volumes — a global Volume with your base look, and local Volumes (with a Blend Distance) holding a Pixel Eras Look for a cave, a dream or a flashback. They blend as the camera moves.
• As an effect: change a value of the look for a moment — a VHS tear on a hit, a palette for a power-up. Change a copy of the era, not the asset (code under Changing a look at runtime); the demo's DemoEffects.cs does it this way.

A graphics menu for players

Everything a player may want to choose is a plain field, safe to change at any time:

Saving the choices (PlayerPrefs or your own save) is up to your game. The demo's pause menu (Demo/Scripts/DemoSettings.cs) is a complete example.

Stepped animation and motion

1. Set the rate once, in your style: Animation → Frame Rate. Every built-in era ships smooth (0), so nothing steps until you ask for it; rates true to the hardware are about 8 for 8-bit and handheld eras, 12 for 16-bit, 15 for 32-bit and 20 for 64-bit.
2. Characters: Pixel Eras Animation and Pixel Eras Stepped Motion on the root. Animation steps the pose, Stepped Motion the walk; both follow the era and step on the same frames.
3. Props that move (pickups, doors, platforms, projectiles): Pixel Eras Stepped Motion.
4. Particles: one Pixel Eras Stepped Motion on the root that holds them — an effect prefab, or the level's root for fire and leaves (it never moves the root itself). UI or anything else under that root that must stay smooth goes into its Ignore list.
5. Your own scripts: PixelErasStep (Scripting API).

Rules for Stepped Motion — what keeps it smooth underneath and stepped on screen:

• A camera and what it follows hold the same. With a Stepped Motion on a follow camera, give the target the same Hold Position and Rotation and the same rate; otherwise the target slides across the held view and the view catches up with a jerk. For the whole picture held at a rate, the camera's View Frame Rate is simpler and cheaper.
• Teleports and respawns: call Refresh() afterwards, or the object shows its old place until the next step.
• Rigidbodies with interpolation: put the component on the model under the body, not on the body.
• Children added later (a weapon, a costume), or a changed Ignore list: call Refresh(). Particle Systems added later are found by themselves.
• Reading the transform in Update, LateUpdate, physics and coroutines gives the true pose. Only code that runs after rendering (OnGUI, WaitForEndOfFrame) sees the held step.
• Particle speed: the component multiplies each system's Simulation Speed; set your own speed before the component finds the system, not every frame.
• Snap to Pixels moves the object only within one game pixel, on screen, for rendering; physics never sees it.

Your own palette

1. Drop a .hex, .gpl or .pal file into the project (from Lospec, GIMP or Aseprite) and press Make Editable Copy in its inspector — or make one with Create → 4ssets → Pixel Eras → Palette.
2. Put it in your style's Palette and set Color Bits to 8, so the palette alone decides the colours.
3. Raise Contrast and Brightness until the scene uses the palette's whole range; add dithering for the in-between shades.

Pixel Eras Camera

Add Component → Pixel Eras → Pixel Eras Camera. The inspector groups the settings in foldable sections — Style, Picture, Motion, Distance — in the same order and with the same names as Retro Studio's Look tab and the demo menu, and shows the game resolution and Doctor's verdict. Untick the component to compare with the plain picture — every Pixel Eras effect switches off at once.

Each camera with a Pixel Eras Camera gets its own look. Doctor reports cameras that render into a Render Texture or cover only part of the screen.

The same picture for every player

Players have different screens. Pick what must stay the same:

• The picture — every player sees as many game pixels, so pixel art, level design and what is on screen are the same for all: Fixed Resolution. The scale changes with the screen, and should: a 640×360 picture is ×3 on 1080p, ×4 on 1440p, ×6 on 4K, and fills each of them. The game looks the same; only the screen is sharper.
• The size of a game pixel on the screen — Pixel Scale. A larger screen then shows more of the scene in more game pixels: ×3 is 640×360 on 1080p and 1280×720 on 4K. Good for a player-facing setting, or a game made for one screen.
• About the same, never a border — Target Height. The nearest whole scale is used, so the height varies a little: 360 is 360 rows on 1080p but 400 on 1920×1200 and on Steam Deck.

Fixed Resolution renders exactly the target height. When the screen's height is not a multiple of it, the rest is a choice every pixel game makes:

• Pixel Perfect (and Pixel Perfect Fill, which would have to crop the picture): the largest whole scale that fits, with a Border Color frame around the picture. Every pixel is square and even. 360 on 1920×1200 is ×3, with 60 px top and bottom and 96 px at the sides.
• Sharp Fill: the same picture stretched to fill the screen at a fractional scale. No border; pixels differ by a screen pixel.

Heights that fill 720p, 1080p, 1440p and 4K with no border: 360, 180, 120, 90. 240 (the PlayStation's) fills 720p, 1440p and 4K, with a border on 1080p. The camera inspector's On players' screens list shows what each common screen gets.

The vertical field of view is fixed, so the picture is as tall in the world on every screen; the width follows the screen's aspect, so a wider screen sees more at the sides, as in most 3D games. Screen-space UI covers the whole screen, the border included.

Pixel stability

A low-resolution 3D picture shimmers when the camera moves, because every frame samples the scene at slightly different points. Smooth Pixel Camera removes that:

• Orthographic camera — every pixel is held still. The view snaps to the game-pixel grid and the leftover fraction of a pixel becomes a smooth shift of the whole picture on the screen. Scenery never crawls; the camera still glides. Recommended for 3D pixel art.
• Perspective camera — turning is held still, and moving holds the scenery at the Focus Distance still (measured automatically from the centre of the view). The view is redrawn only when the camera has moved a whole pixel, and the picture glides in between. Scenery nearer or farther than the Focus Distance still shimmers a little, because perspective moves it at a different speed. A floor seen at a steep angle shimmers while the camera moves forward or back: its near and far rows move at different speeds, and no shift can hold them all. That is a limit of perspective itself.

Camera stacks

With URP Base + Overlay cameras, put the Pixel Eras Camera on the Base camera. Every overlay camera (a first-person weapon, for example) draws into the same low-resolution picture, and the look is applied once, after the last camera. A Pixel Eras Camera on an overlay camera is ignored (Doctor says so). View Frame Rate is off for stacked cameras, as the overlays would draw over a held frame.

In the Scene view

Press Pixel Eras in the Scene view's toolbar (an overlay) to see the main Pixel Eras Camera's look while you build: the same era, as many game pixels as the Game view shows at the Scene view's size, the palette, dither, edges, fog, halos and screens. Gizmos, the grid and handles stay sharp on top. Press it again for the plain Scene view; the choice is remembered.

• The Scene view's camera gets a hidden copy of the Pixel Eras Camera, kept in step with it. The copy keeps its own pictures, so the Game view never changes, and nothing is saved in the scene.
• Fog is measured from the Scene view's camera: zoomed far out, the whole scene may sit in it.
• View Frame Rate and the Smooth Pixel Camera's glide play in the Game view only, so the view you work in never stutters or shifts.
• URP's Compatibility Mode (Render Graph off) shows the look in the Game view only.

Eras

An era (Create → 4ssets → Pixel Eras → Era) bundles a target height, a Volume Profile holding one Pixel Eras Look, and suggested settings for Retro Lit materials (vertex snap, affine mapping, texture filter). Twenty ship with Pixel Eras:

1-bit Classic · 342Black and white: ordered dithering for the greys, outlines for the shapes.

4-Shade Handheld · 180Pocket handheld: four shades of green, light dithering, outlines.

8-bit Console · 240Living-room 8-bit: 55 colours, outlined sprites, light CRT.

16-bit Console · 224Vivid 15-bit colour, soft outlines, gentle CRT.

32-bit Console · 240First 3D consoles: dithered 15-bit colour, wobbling vertices, affine textures.

64-bit Console · 240Three-point texture filtering, soft 16-bit colour.

Arcade CRT · 224Saturated colour on a bright, curved arcade tube.

CGA PC · 240CGA palette 0: black, green, red and brown, with outlines.

VGA PC · 200256 colours, sharp DOS-monitor pixels.

HD Pixel Art · 360Modern pixel art with one-pixel outlines and edge highlights.

Lo-Fi Mobile · 2704-bit colour: maximum savings on weak devices.

Haunted Tape · 240Faded 32-bit horror off a worn VHS tape.

Pocket Handheld · 144Four greys on a slow LCD: a pixel grid and trails behind everything that moves.

Backlit Handheld · 144Colour handheld, 4096 colours, a light LCD grid and short trails.

Wide Handheld · 160The 32-bit handheld: 15-bit colour, a fine LCD grid, no dithering.

Red Visor · 224Four reds on black, as in the 90s stereo visor.

16-bit Composite · 224512 colours over a TV cable: dither stripes melt into new shades.

8-bit Home Computer · 19215 bright colours, composite fringes, a curved TV.

8-bit Micro · 200The 16 muted colours of the best-selling 8-bit computer, composite, CRT.

128-bit Console · 480The turn of the millennium: 640x480, smooth 3D, soft video.

Pick one in Retro Studio → Eras (press Apply to Retro materials in this scene for its material suggestions), choose one from the arrow beside the camera's Era field, or switch from code with Era / TransitionTo.

Your own styles

The built-in eras are templates: Retro Studio never changes them, so a package update can never overwrite your work. To make a look of your own:

1. In Retro Studio → Eras, press New style on the era closest to what you want (or New style from the current look).
2. Give it a name, a short description (one line, shown on its card) and a full description, then press Create and use. The style goes on the camera and the Look tab opens.
3. Tune everything in the Look tab. Your style saves itself a moment after each change: the look, the picture settings (Resolution mode and Pixel Scale, scaling, sampling, Smooth Pixel Camera, View Frame Rate, Draw Distance — projection stays with the camera) and the material shapes.

Your styles are listed first in the Eras tab and live in Assets/Pixel Eras Styles/ as project assets. Use one in any scene with Use: the camera gets the look and the style's picture settings. Tick Default for new scenes in the Look tab, and Make it Retro gives every new scene that style; the choice is saved in ProjectSettings/PixelErasStudio.asset, so the whole team shares it. An era reads only the Pixel Eras Look in its profile; other overrides there are ignored.

Each style is one file: the era with its look inside, plus its preview picture. Delete, on its card or in the Look tab, asks first, then moves both to the system trash, where you can restore them. Cameras in the open scenes that showed it switch to the default style. Built-in eras cannot be deleted.

Previews

A PNG named like the era, in the era's folder, is its preview (Eras/ArcadeCrt.png for ArcadeCrt.asset). For your own era press Capture preview from Game view in its inspector: the camera shows the era for one frame and the frame is saved beside the era. Previews are not referenced by anything, so they never enter a build.

Pixel Eras Look (Volume override)

Add Override → 4ssets → Pixel Eras Look on any Volume. It blends like other overrides, so a trigger volume can turn a cave into 1-bit or a dream sequence into VHS. A camera with an era ignores Volume looks; clear the era to use them. Settings of a stage that is switched off (CRT, VHS, Composite Video, LCD) are greyed out.

Every inspector of Pixel Eras — the Volume override, the Pixel Eras Camera, eras and styles, Retro Studio's Look tab — draws the settings the same way:

• Section cards with a chip saying what the section does right now (548×308 ×7, 32 colours, ON). Click a card to fold it.
• The chain at the top: every stage of the look in the order it runs — grade, colour depth, palette, dither and edges at the game's resolution, then the tape, the cable, the LCD and the tube at screen resolution. Lit chips are on.
• Pictures of what the settings do: a ramp through the palette and dither, a box with its outline and highlight, a test picture through the screens, the screen with the game picture and one game pixel close up, the light bands.
• Notes where a setting is edited: blue — worth knowing; gold — it will not do what you expect; red — two settings work against each other; purple — needs Retro materials.

Color

Custom dither patterns

Set Dither Pattern to Custom Texture and give it a Pattern Texture: the dither then draws your pattern instead of Bayer or blue noise. The texture tiles once per game pixel. Its red channel is a threshold: as a colour gets brighter, the darkest texels switch to the next colour first, so the order of the values is the shape the pattern grows in.

• Examples: Pixel Eras/Dither Patterns/ has eight — Lines, Columns, Diagonal, Crosshatch, Grid, Halftone (clustered dots), Diamond and Stipple. The demo menu's Dither Pattern row steps through them after the built-in patterns.
• Your own: draw the shape in any picture (the darker a pixel, the earlier it lights up), select it and choose Assets → 4ssets → Pixel Eras → Create Dither Pattern from Image. It ranks the pixels by brightness and spreads them evenly over the 256 levels, as a Bayer matrix does, and saves name_pattern.png beside the picture. 4×4 to 16×16 reads as a pattern; larger tiles read as texture.
• Import: the shader reads each texel as drawn, so the texture needs sRGB off, Point filtering, no compression and no resize. Textures in a folder named Dither Patterns, or named …_pattern, import that way by themselves; Doctor warns about a pattern that does not.
• No texture set: the dither stays on with Bayer 4×4.

Pixel Edges

Outline and highlight work together: a pixel takes the outline first, and a highlight never crosses a silhouette, so both can be on with any positions without doubling up.

Edges are drawn only where they make a shape: a fragment of fewer than three pixels — a speck from a polygon smaller than a pixel, a sliver of depth or a noisy normal — is left out, while lines and corners keep every pixel, their ends too.

Pixel Edges need the Universal Renderer's depth and normals; on the 2D Renderer they are skipped and the rest of the look applies.

Fog

Retro fog over the scene by depth, drawn after opaque surfaces and before transparent ones, and before the palette: it lands on the era's colours and dithers with them. It works on every material; transparent Retro materials fog themselves the same way, other transparent materials are drawn over the fog unfogged. Edge lines fade into the fog with the surfaces they are on. Turn Unity's own fog (Lighting window) off: it would fog the materials that support it a second time.

Fog is a Volume setting like the rest of the look: fog zones are Volumes with their own Fog, and they blend as the camera moves. A camera showing an era uses the era's fog. Every built-in era has its own fog, made for a night level seen from about ten metres: retune Start and End for your scene's scale.

CRT

Switch CRT on, then: Curvature, Scanlines (the beam widens on bright areas, so brightness is kept), Phosphor Mask (Aperture Grille, Shadow Mask, Slot Mask) and Mask Strength, Softness (horizontal beam smear), Glow (computed at half the game resolution), Corner Radius, Vignette.

VHS

Switch VHS on, then: Jitter (sideways line shake, in game pixels), Noise, Color Bleed, Tracking (a band of torn lines rolling down).

Composite Video

The picture as a family TV received it over a composite cable: brightness and colour share one signal along each line, so neighbouring pixels run together. One-pixel dither stripes melt into the extra shades and see-through effects 8- and 16-bit games were drawn for. Blend: how far brightness runs into the neighbours (1 melts stripes completely). Color Bleed: how much further colour spreads. Lines never mix. Pair it with dithering (Bayer 2×2) and CRT.

LCD

The picture on an early handheld's screen. Pixel Grid: the dark gaps between the pixels, drawn from ×2 scale up. Ghosting: the slow response of early panels; moving things leave a fading trail. It is measured per 1/60 s, so it lasts as long at any frame rate, and runs in Play Mode only (Edit Mode draws too rarely for a trail to mean anything). Keeps two small textures at the game resolution while on.

When settings meet

Some settings change what others do, or override them. The inspectors say so where the setting is edited; in short:

Retro materials

The look itself — grade, palette, dither, Stable Dither, edges, CRT, VHS, composite video, LCD, the resolution, Smooth Pixel Camera and View Frame Rate — is post-processing and works on every material. A few things happen inside the surface shader and need Retro materials (URP_RETRO / HDRP_RETRO, or Shader Graphs built with the Retro sub graphs); the inspectors mark them with a purple R and count the scene's Retro materials beside them:

• Vertex Snap — the wobble of 32-bit consoles.
• Affine Mapping — textures warping across large polygons.
• Texture Filter — Point, Bilinear or the N64's Three Point.
• Light Bands — light in flat steps (Retro Lit and Terrain).
• Draw Distance — polygons popping out whole instead of being cut by the far plane.
• Light Rings — point and spot lights falling off in flat rings (Pixel Eras Light).

They also look best with Point-filtered textures: Retro Studio → Assets → Import Rules sets that up for a folder.

Pixel Eras Light

Lights in old games did not glow smoothly: lamps flickered in steps, light fell off in flat rings, early hardware had no real-time shadows, and a lamp often wore a pixel halo. Add Component → Pixel Eras → Pixel Eras Light on any Light gives it those manners. The light's own intensity, colour and shadows are kept: edit them on the Light as usual, and they come back as they were when the component is removed. With Pixel Eras off — no Pixel Eras Camera enabled, as Retro ON/OFF in Retro Studio does — the lights are plain too: no pattern, no halo, their own colour and shadows, so the comparison shows the whole retro style against none of it.

Lighting in an era

Each era has a Lighting section (era inspector, or Retro Studio → Look → LIGHTS): the Shadows and Palette Colour that lights following the era take, and Light Rings with Ring Dither. Light Rings are drawn by Retro materials (Retro Lit and Terrain) on every point and spot light, with a Pixel Eras Light or without: the falloff is read at the middle of its ring, so a light pool becomes flat rings, and the dither blends one ring into the next in game pixels. With rings on, those lights are lit per pixel instead of per vertex, so the rings run round the light instead of smearing across polygons. The lights follow the era of the main camera's Pixel Eras Camera; switching eras changes them at once.

Pixel Eras Animation

Sprites and early 3D characters moved in whole frames, a few times a second. Add Component → Pixel Eras → Pixel Eras Animation on a character's root steps its Animators (and its children's) the same way: in Play Mode they are switched off and moved by whole frames, so their parameters, transitions and events work as before; only the motion holds each pose and jumps.

• Frame Rate — the era's (its Animation section; every built-in era ships smooth, set a rate in your style: about 8 fps for 8-bit and handheld eras, 12 for 16-bit, 15 for 32-bit, 20 for 64-bit), or set on the component. 0 = smooth.
• Include Children — step the Animators below the root too.
• Step Scripted Pose — bones that scripts move after the Animator (IK, aiming, a strafe turning the hips in LateUpdate) move in whole frames too: each step's finished pose is held until the next. IK inside the Animator (OnAnimatorIK, Animation Rigging) always steps with it. Off: scripts move the bones every frame, on top of the stepped pose.
• With Pixel Eras off (no Pixel Eras Camera enabled) the Animators run smoothly again.
• A model added at runtime (a new weapon, a costume): call Refresh().

Pixel Eras Stepped Motion

Animation steps a character's pose; Pixel Eras Stepped Motion steps the object itself: Add Component → Pixel Eras → Pixel Eras Stepped Motion on anything that moves — an enemy's root, a pickup, a door, a projectile — and on screen it moves, turns and scales in whole steps. Only the picture steps: the true transform is put back at the start of every frame, before physics and every script, and the held step is shown after every LateUpdate, for rendering. Game code, colliders and raycasts work with the true, smooth position all the time.

• Frame Rate — the era's Animation frame rate, or set on the component. 0 = smooth.
• Hold Position / Rotation / Scale — what steps; the rest moves every frame.
• Include Children — objects below step too, each in its own local space (a spinning propeller, a swinging sign). An Animator's bones are skipped — they belong to Pixel Eras Animation — and so are objects with their own Stepped Motion.
• Ignore — objects below that keep moving smoothly while the rest steps: a health bar over a stepped enemy, its UI, a light or a trail. Each entry stays where it truly is in the world even while the objects above it are held. Without Recursive only that object is left smooth and its children still step, in its own space; with Recursive everything below it is left smooth too. Particle Systems on ignored objects run at their own pace. It works with Include Children off as well: a child follows its stepping parent unless it is listed here. An Animator's bones and objects under another Stepped Motion cannot be listed; the Inspector names any such entry.
• Snap to Pixels — the object sits on whole game pixels of the main Pixel Eras Camera, so it crosses the screen pixel by pixel, as sprites did — at a Frame Rate of 0 too, for smooth motion on whole pixels.
• Step Particles — Particle Systems on the object and anywhere below it simulate in steps: each step they move on by the step's time, between steps they hold still. Play, Stop, Emit, bursts and sub-emitters work as before, and systems added later are found by themselves. One Stepped Motion on a level's root steps every particle in the level (fire, bats, leaves) and costs nothing for the root itself: a transform that does not move is never written. The systems' Simulation Speed is multiplied by the steps — set it before the component finds them.
• After a teleport or a respawn, call Refresh(): the object shows where it is at once instead of at the next step.
• On a Rigidbody with interpolation, put it on the model under the Rigidbody.

With Pixel Eras Animation. Put both on a character's root: Animation steps the pose, Stepped Motion the walk across the ground. They run on one clock, so a step of the legs and a step forward land on the same frame, and never move the same transform.

Your own scripts. PixelErasStep is that clock: IsStepFrame, DeltaTime (the time a step covers, 0 between steps), Time (game time held at the last step), FrameRate and the Stepped event; or IsStep(rate) for a rate of your own. It counts from game time, so pausing (time scale 0) holds every step.

Palettes

40 palettes ship in Pixel Eras/Palettes/: the colour sets of classic consoles, handhelds and home computers (CGA, EGA, 256-colour VGA, the 8-bit console, the 15- and 16-colour home computers, the 27-colour three-level RGB, the late-70s low-res set, four-shade greens, greys, amber and teal, the red visor, teletext, 1-bit monitors) and artistic sets (Synthwave, Muted Earth, Pastel, Neon, Dusk and more). To add your own:

• Import a file: drop a .hex (Lospec), .gpl (GIMP) or .pal (JASC or RIFF) file into the project. It imports as a Pixel Eras Palette; edit the file to change it, or press Make Editable Copy in its inspector.
• From an image: select textures → Assets → 4ssets → Pixel Eras → Create Palette from Image. Every distinct colour, in reading order.
• By hand: Create → 4ssets → Pixel Eras → Palette. The palette inspector can also Import… a file, Export .hex… and Sort by Lightness.

Colours are matched perceptually (OKLab), so dark and saturated colours keep their character.

Shaders

Two families with the same shaders and the same properties: URP_RETRO for URP and HDRP_RETRO for HDRP, both under 4ssets/PixelEras in the shader menu. A Retro material follows the project's pipeline by itself: when it is imported into, or opened in, a project rendering with the other pipeline, it switches to its twin and keeps every value.

Lit and Unlit properties (Terrain has the geometry, filtering and lighting ones):

Retro Lit works in Forward, Forward+ and Deferred (it renders forward), with the 2D Renderer, and in lightmap baking. In HDRP it renders forward in both Lit Shader Modes and fills HDRP's normal buffer; see HDRP for the lights it reads. Transparent Retro materials do not write depth, so Pixel Edges and Stable Dither see what is behind them.

Converting materials

Retro Studio → Assets → Convert scene materials converts everything the open scenes draw with. Or select materials, folders or prefabs → Assets → 4ssets → Pixel Eras → Convert to Retro Shaders. Materials become Retro ones for the project's pipeline — URP_RETRO in URP, HDRP_RETRO in HDRP — in one Undo step:

Colour, albedo with tiling, Surface Type and Blend Mode (URP Surface, HDRP Surface Type, Built-in Rendering Mode), alpha clipping and threshold, render face (HDRP double-sided too) and emission carry over. Picking a Retro shader for a material by hand does the same.

Converting the scene also handles what cannot be changed in place: materials inside a model or a package (such as the pipeline's default material on primitives) are replaced on those renderers by Retro copies in Assets/Retro Materials, and a terrain on the pipeline's default terrain material gets a Retro Terrain material there. Converting again reuses them.

Left as they are, with the reason in the report: skyboxes, UI and text, decals, terrain details and grass, SpeedTree, HDRP AxF, and Shader Graphs and other custom shaders — their inputs are their own, so pick a Retro shader for them by hand, or build the look into a graph with the sub graphs.

Shader Graph sub graphs

In any Shader Graph: Create Node → Pixel Eras. They also work as Custom Function nodes (Shaders/ShaderGraph/PixelErasShaderGraph.hlsl).

UI

• Screen Space Overlay canvases draw after Pixel Eras, sharp and at full resolution. Use them for menus and HUDs.
• Pixel Eras Canvas Scaler (Add Component → Pixel Eras → Pixel Eras Canvas Scaler, on the Canvas) scales the canvas by the same factor as the game picture. One UI pixel is then one game pixel: pixel-art UI lines up with the scene, and text stays sharp. UI Pixel Size 2 draws it twice as large, still on the grid. It replaces the Canvas Scaler on the same object.
• Screen Space Camera and World Space canvases render inside the retro picture — pixelated and palettised. Doctor points them out.
• Fonts: three CC0 pixel fonts by Kenney are in Pixel Eras/Fonts/.

Retro Studio

Window → 4ssets → Retro Studio (also Tools → Pixel Eras → Retro Studio). The header shows the camera the window acts on (the selected one, else the Main Camera), its game picture, and a Retro ON / OFF switch for before-and-after comparison. Without a Pixel Eras Camera in the scene it shows Make it Retro instead.

Eras

Two lists, one at a time: Built-in eras, the templates that ship with Pixel Eras and are never changed, and Your styles, the ones you made from them. The tab of each list shows how many it holds; the window opens on Your styles when you have any, and a new style is listed there. Each card shows the era's preview, resolution on the current view, colours, dither and CRT/VHS. Use puts it on the camera; Edit (your styles) opens it in the Look tab, Delete moves it to the system trash; New style (built-in eras) makes your own copy, named and described by you — see Your own styles. Apply to Retro materials applies the era's vertex snap, affine and filter suggestions to the scene's Retro materials. Previews, beside the two lists, hides the era pictures: each card shrinks to its name, facts and description with small buttons in one row, so the whole list fits a short window. The window remembers the choice.

Look

Every setting of the picture in one place, in foldable sections, with Undo, showing in the Game view as you change it: Picture, Motion, Distance, Colour, Pixel Edges, CRT, VHS, Geometry. A style's look is drawn without Volume override toggles: a style sets every value.

• Picture — the camera: target height (the era's, when it sets one), scaling, border, sampling, projection, Smooth Pixel Camera and Focus Distance, View Frame Rate, Draw Distance.
• Look — the era's Pixel Eras Look: saturation, contrast, palette, colour depth, dithering, Pixel Edges, CRT and VHS. With no era on the camera, the scene's Volume that holds a Pixel Eras Look is edited instead.
• Shapes — the era's vertex snap, affine mapping and texture filter, applied to the scene's Retro materials as they change, and Light Bands for every Retro Lit material.

For your own style the tab starts with its name, short and full description, Default for new scenes and Capture preview. A built-in era is read-only here: the tab starts with New style from it instead.

Assets

• Material Converter turns the scene's (or the selected) materials into Retro ones — see Converting materials.
• Cruncher previews one resolution (16–512) and an optional palette on every selected Retro Lit or Unlit material. Select the materials in the Project window, or select objects in the Hierarchy: Cruncher takes the materials on their Mesh and Skinned Mesh renderers, including children. The list shows each material, even when there is only one. With more than one, the slider edits all of them; to edit a single material, select only that material in the Project window. Resolution runs from 16 to 512. Dither is None, Bayer 2×2, 4×4 or 8×8, Blue Noise, or Custom Texture with a pattern texture, with Strength and Fade as on a Pixel Eras Look. Cruncher ON / OFF shows or hides that preview; objects then draw the texture on the material. Bake and Use original turn it off until a setting changes or you turn it on. The preview stays only while Retro Studio is focused on the Assets tab with Cruncher ON; the Scene view shows a bar while that preview is up. Objects that use a listed material update in the scene while it is on; the original texture and the material slot stay as they are until Bake. Bake writes <material>_crunch.png beside each material, assigns it, and remembers the original. The next experiment reads that original again and overwrites the same baked file. Use original puts the original back on every material that is showing its bake. With no baked file, the material shows the original. Selected textures still crunch to <name>_retro.png beside the source. A sprite sheet's copy keeps Sprite Mode Multiple but not the slices: slice it again in the Sprite Editor. Terrain and Retro Sprite are not previewed: terrain paints with layers, and a sprite draws its Sprite asset.
• Import Rules: select a folder and press Add rules. Every texture in it and below then imports with Point filtering, no mipmaps and no compression. The rules live in the PixelErasTextureRules asset (filter, mipmaps, compression, max size, pixels per unit), and existing textures are re-imported.

Doctor

Doctor checks the project and scene, explains each finding, and offers a one-click, undoable fix where it can. Fix all applies every fix for errors and warnings as one Undo step. Errors stop the look from drawing, warnings spoil it, and notes are worth knowing. The checks:

• missing renderer feature or lost shaders (URP); shaders missing from Always Included Shaders, Dynamic Resolution (HDRP);
• an era without a profile or without an active Pixel Eras Look; other overrides in an era profile;
• MSAA, camera anti-aliasing (FXAA/SMAA/TAA), URP dithering;
• a Pixel Perfect Camera on the same camera; a Pixel Eras Camera on an Overlay camera;
• a Pixel Eras Look in the pipeline's default Volume Profile;
• HDR display output;
• cameras that do not cover the screen or render to a texture;
• Pixel Edges on the 2D Renderer; View Frame Rate on a camera stack;
• sprites scaled by non-whole factors; alpha-clipped materials; canvases inside the retro picture.

Doctor's errors are also printed to the console before every player build. A build cannot silently ship without the renderer feature or its shaders. Doctor never touches your post-processing: effects are yours to use on top of the look.

Scripting API

Namespace FourSsets.PixelEras.

using FourSsets.PixelEras;
using UnityEngine;

public class EraSwitcher : MonoBehaviour
{
    public PixelErasCamera retro;
    public PixelEra flashback;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.F))
            retro.TransitionTo(flashback, 1.5f); // crossfade over 1.5 s of unscaled time

        // The game pixel under the mouse, e.g. for a pixel-snapped cursor.
        Vector2 pixel = retro.ScreenToVirtualPixel(Input.mousePosition);
        Vector2Int cell = Vector2Int.FloorToInt(pixel);
    }
}

Every type below is public and documented in the code. Settings that are plain fields are listed with their C# names in the Parameter reference.

PixelErasCamera

PixelEra (era or style asset)

PixelErasLook and changing a look at runtime

PixelErasLook is a VolumeComponent: every setting is a VolumeParameter (look.ditherStrength.value to read, look.ditherStrength.Override(0.3f) to write). IsActive(), UberActive, FogActive, EdgesActive, CrtActive, VhsActive, CompositeActive, LcdActive say which stages run.

// using UnityEngine.Rendering;
// A copy of the era with its own copy of the look: change it freely, the asset never changes.
static PixelEra CopyOf(PixelEra source)
{
    var era = Object.Instantiate(source);
    era.profile = ScriptableObject.CreateInstance<VolumeProfile>();
    if (source.Look != null)
        era.profile.components.Add(Object.Instantiate(source.Look));
    return era;
}

// Usage: a VHS tear for half a second.
var hit = CopyOf(retro.Era);
hit.Look.vhs.Override(true);
hit.Look.vhsTracking.Override(1f);
var before = retro.Era;
retro.Era = hit;
// ...0.5 s later:
retro.Era = before;

Destroy copies you no longer need (the profile's components, the profile, then the era).

PixelErasStep — the step clock

One clock for everything that moves in steps: Pixel Eras Animation, Pixel Eras Stepped Motion and your scripts. It counts game time, so everything at the same rate steps on the same frame, and time scale 0 holds every step.

// A sprite-like enemy that moves only on the era's steps.
void Update()
{
    if (PixelErasStep.IsStepFrame)
        transform.position += velocity * PixelErasStep.DeltaTime;
}

PixelErasAnimation and PixelErasSteppedMotion

PixelErasLight

PixelErasPalette

PixelErasResolution

A read-only struct: the game picture for a screen. Width, Height (game pixels), Factor (whole scale), Scale (exact scale), Multiple (samples per game pixel), Crop, Exact, IsWhole, MaxScale (10). The static Compute, ComputeScale, ComputeCrop, ComputeFill and ComputeFixed work out what a screen size would get in each mode — for a settings menu that lists the choices.

Enums

• PixelErasResolutionMode — TargetHeight, PixelScale, FixedResolution.
• PixelErasScaling — PixelPerfectFill, PixelPerfect, SharpFill.
• PixelErasSampling — Single, Supersample2x.
• DitherPattern — None, Bayer2x2, Bayer4x4, Bayer8x8, BlueNoise, CustomTexture.
• EdgePosition — Inside, Outside. CrtMask — ApertureGrille, ShadowMask, SlotMask. PixelErasFogMode — Linear, Exponential, ExponentialSquared.
• RetroTextureFilter — Point, Bilinear, ThreePoint. PixelErasLightShadows — Unchanged, Off, Pixel, Soft. PixelErasLightPattern — Steady, Flicker, Candle, Torch, Fluorescent, Pulse, Strobe, Custom.

Parameter reference

Every setting of every Pixel Eras component and asset, as the inspectors name it, with its C# field for scripts, its default and its range. The descriptions are the inspectors' tooltips.

Pixel Eras Camera

Component on a camera. The era itself is the Era property (see Scripting API).

Pixel Eras Look

Volume override, and the look inside every era. Each field is a VolumeParameter: read .value, write with .Override(value).

Era / style (PixelEra asset)

Create → 4ssets → Pixel Eras → Era. Built-in eras are read-only in Retro Studio; your styles are edited in its Look tab.

Pixel Eras Light

Component on a Light.

Pixel Eras Animation

Component on a character's root.

Pixel Eras Stepped Motion

Component on anything that moves, or on a root holding Particle Systems.

Palette (PixelErasPalette asset)

Create → 4ssets → Pixel Eras → Palette, or an imported .hex / .gpl / .pal file.

Pixel Eras Canvas Scaler

Component on a Screen Space Overlay Canvas, in place of its Canvas Scaler.

Texture Import Rules

Asset made by Retro Studio → Assets → Import Rules (or Create → 4ssets → Pixel Eras → Texture Import Rules); applies to its folder and below. Editor only.

Material properties (URP_RETRO and HDRP_RETRO)

For scripts that change Retro materials, for example material.SetFloat("_VertexSnap", 0.5f). The same names in both families.

Menus and files

Where everything is

Inside the package, Shaders/PixelErasPipeline.hlsl and Shaders/PixelErasURPKeywords.hlsl are written on import for the pipeline your project uses; do not edit them.

Package contents

Performance

• URP: the scene renders at the game resolution, so with an era Pixel Eras usually costs less than rendering without it. HDRP renders the scene at full resolution: there the look adds its two passes.
• Uber (grade, palette, dither, edges) runs at the game resolution: a few hundred thousand pixels at most.
• CRT and VHS add one full-resolution pass; CRT glow works at half the game resolution.
• Edge Highlight needs URP's depth-normals prepass — an extra geometry pass. Edge Outline only needs depth. HDRP always has both.
• Retro Fog adds one pass at the scene's resolution (URP: the game resolution × Sampling; HDRP: the screen's). Edges hidden under transparent surfaces add one copy of the picture at that size.
• Light Rings light point and spot lights per pixel on Retro materials (per vertex without them): a light loop in the fragment shader, at the game resolution in URP. Halos are one small quad each.
• 2×2 Sampling renders four times the pixels of the game picture.
• View Frame Rate skips scene rendering on held frames.
• Pixel Eras Animation evaluates Animators on step frames only — cheaper than smooth animation. Stepped Motion writes a transform only when its step differs from the truth, and sets one speed per Particle System per frame.
• With the Pixel Eras Camera disabled nothing of Pixel Eras runs: passes are skipped, lights, animation and motion go plain.

Limitations

• XR (VR and AR) is not supported: a camera rendering to a headset draws without Pixel Eras, as if it had no Pixel Eras Camera.
• HDRP: Dynamic Resolution and upscalers (DLSS, FSR), MSAA with Pixel Edges or Stable Dither, and camera anti-aliasing are not supported (see HDRP).
• URP 2D Renderer: Pixel Edges and Stable Dither need depth and normals and are skipped; everything else works.
• URP Compatibility Mode (Unity 6.0–6.3): 2×2 Sampling is not used.
• GPUs without float render targets (some mobile and WebGL devices): Stable Dither needs a 32-bit float target and switches itself off there; LCD Ghosting falls back from 16-bit float to 8 bits, so its trail fades in coarser steps. Everything else is unchanged.
• Cameras: Pixel Eras is made for cameras that render to the whole screen; Doctor reports cameras that render into a Render Texture or to part of the screen. Several Pixel Eras Cameras each get their own look; lights and stepping follow the main camera's era.
• Retro materials only: vertex snap, affine mapping, texture filter, Light Bands, Light Rings and Draw Distance happen inside the surface shader (Retro materials). The rest of the look works on every material.
• URP_RETRO/Lit and URP_RETRO/Terrain light the main light per vertex with its shadow per pixel, and other lights per vertex (per pixel with Light Rings, and always under Forward+). They receive the main light's shadow only; light cookies, light layers, reflection probes, SSAO and LOD Cross-Fade are not read. Lightmaps and the ambient probe are.
• HDRP_RETRO reads directional, point and spot lights, the sun's shadow and the sky's ambient; area lights, cookies, light layers, lightmaps and light probes are not read.
• Terrain: four splat layers.
• Stepped Motion steps transforms and Particle Systems. Anything else that moves on its own — UI animation, scrolling or time-driven shaders, VFX Graph — is not stepped.

Troubleshooting

Demo

Open Assets/4ssets/PixelEras/Demo/Demo.unity and press Play: survive as long as you can while the horde grows. The level is a walled graveyard on a moonlit night: a plaza and two avenues, a grave field under green will-o'-the-wisps, a memorial garden with statues, a row of crypts in purple light, the keeper's yard with its campfire and crates, and a mausoleum at the end of the avenue; bats circle overhead. The zombies climb out of open graves and crypt doors. Cars, crates and statues react to grenades; pumpkins burst, wooden fences splinter and hay bales scatter after a few shots or a blast nearby — harmless, and whole again next round. You start with the blaster, 13 rounds and a grenade. A zombie takes 3 to 5 hits; burning runners explode when they reach you, green spitters keep their distance and throw poison, and now and then a boss with a health bar arrives (a rarer mega boss is larger still). A grenade kills every regular zombie in its blast — you too, if you stand too close. Ammo, grenades, food (heals and clears poison) and shields (armour) lie around the graveyard; crates hold a shotgun or a rifle, and a second crate of a gun you carry makes it stronger. Kills earn experience: each level makes the survivor a little faster and dash more often. Press Esc to pause and change the era, resolution and every setting of the look live. The demo shows each era sharper than the era asset itself (360 or 270 pixels tall, ×3 or ×4 on 1080p), so every era reads well at a glance; Picture → Pixels goes down to the era's own height. The survivor always faces and fires where the camera looks; the mouse (or the right stick) turns both (DemoCamera.lookSpeed). Picture → Projection switches between orthographic and perspective to compare.

In a WebGL build the browser captures the mouse only on a click: the round waits on CLICK TO PLAY until then, and that click does not fire. Esc (or switching tabs) frees the mouse and pauses at once. Demo/Plugins/WebGL/PixelErasDemo.jslib asks the page whether the mouse is captured.

The pause menu's tabs: PICTURE (resolution, scaling, sampling, Smooth Pixel Camera, projection, camera distance, View Frame Rate, Pixel Eras on/off), COLOR, EDGES, FOG, CRT, VHS, SCREEN (composite and LCD) — every setting of the look — GEOMETRY (the era's material settings, Light Bands and Draw Distance), LIGHT (rings, palette colour, halos) and FPS: the era's step rate, a rate for enemies, hero, camera, pickups and particles, and Snap to Pixels for everything at once.

Scripts worth reading: DemoMenu.cs and DemoSettings.cs (a settings menu over the whole look, working on copies of the eras), DemoStepRates.cs (stepping rates per kind of object). Demo/Scripts/DemoEffects.cs shows the look used as a game effect: the VHS tear when a grenade goes off or the survivor is caught is a few lines that change the Pixel Eras Look at runtime. Every effect — muzzle flash, tracers, sparks, hits, explosions — is square particles drawn with Retro Unlit and short-lived point lights the vertex-lit scene reacts to.

The demo plays in URP and in HDRP. The scene carries no pipeline's components; in HDRP, Demo/Scripts/Pipelines/HDRP gives it a fixed exposure, a sky and fog matching its URP lighting, and turns HDRP's default post effects off, while the scene is open.

A build that includes the demo on Unity 6.6 or later logs one warning, “Pre-baked collision is disabled on … mesh(es) referenced by Mesh Collider components”: it concerns the demo's models only and changes nothing in the build.

Removing the demo: delete Assets/4ssets/PixelEras/Demo/. Nothing outside it depends on the demo.

Removing Pixel Eras

1. URP: remove the Pixel Eras feature from your renderer assets. HDRP: remove Hidden/4ssets/PixelEras/Uber and …/Present from Always Included Shaders.
2. Switch Retro materials back to your pipeline's Lit or Unlit shader: they use the package's shaders. Colour, texture and surface settings carry over, as the properties share their names.
3. Remove the Pixel Eras components from your objects (Pixel Eras Camera, Light, Animation, Stepped Motion, Canvas Scaler) and the Pixel Eras Look overrides from your Volumes.
4. Delete Assets/4ssets/PixelEras/.

Support & license

Publisher: 4ssets, part of UnityCraft.org — unitycraft.org/4ssets.

Questions, bug reports and requests: through the publisher page above. Please include the Unity version, the render pipeline and its version, and Doctor's report (Retro Studio → Doctor).

Enjoying Pixel Eras? A short review on the Asset Store helps other developers find it and keeps updates coming. The same link is at the foot of Retro Studio (Rate; × hides the strip for good) and under Tools → Pixel Eras → Leave a Review.

Licensed under the Unity Asset Store EULA; see License.txt. Fonts, demo models and demo sounds are CC0; see Third-Party Notices.txt. Version history: Documentation/Changelog.txt.