Shader

This feature is exclusive to Java Edition.

This page describes content that has been removed from the game.

This feature was present in earlier versions of Bedrock Edition, but has since been removed.

This article is a work in progress.

Please help expand and improve it. The talk page may contain suggestions.
Note:

Add historical Bedrock Edition information. Java Edition History section could be expanded to include more details for changes made around 1.17 to 1.19. The Java Edition "Render process" section would benefit from more information. Java Edition would benefit from more information about post_effects (specifically vertex shaders before and after 25w31a) and vertex attributes for both post and core shaders

Shaders are used to define the game's rendering of certain elements.

Java Edition

in Java Edition, two distinct kinds of shaders are used: core shaders and post-processing shaders. Core shaders are used to render fundamental parts of the game such as entities and terrain, while post-processing shaders are used to apply visual effects to the screen after core shaders have ran.

Examples of post-processing shaders include the menu background blur, certain mob vision types as seen in spectator, the Fabulous! graphics setting's fixed handling of translucent object, and the glowing status effect.

Shaders are written in the OpenGL Shading Language (GLSL). Each shader program^{[note 1]} comes in two parts, the vertex and fragment shader. Vertex shaders define the positions of individual vertices, whereas fragment shaders define the final color of a single render fragment. For example, vertex shaders are often used to create waving foliage and water, and fragment shaders can be used to add effects like bloom, god rays, and blur. In Minecraft, vertex shaders must use the extension .vsh, and fragment shaders .fsh.

Shader programs are stored in the assets/minecraft/shaders directory of client.jar, and can be replaced with a resource pack. Note that if any error occurs when loading the shaders, the resource pack is disabled and fabulous graphics mode is turned off.

Core shaders

Although core shaders can be replaced with a resource pack, this isn't an intended or supported feature and may change at any time.

Core shaders are used to render almost everything in the game, including terrain, entities, gui elements, etc. The shader programs for core shaders are located in the assets/<namespace>/shaders/core directory of a resourcepack.

Some objects are not drawn using shaders, this includes:

The sky in the nether and bottom half of the overworld. These are the opengl clear color which is set to the same value as the FogColor uniform

List of core shaders

A list of all core shaders can be found by expanding the header below, listing descriptions of what each shader is responsible for, as well as what uniforms, samplers, and define directives are available to each shader.

Name	Used for	Sample images	Available uniforms blocks	Available samplers. All samplers are of type `sampler2d` unless otherwise specified	Define directives
animate_sprite_blit	Renders non-interpolated texture animations. Uses the `core/animate_sprite.vsh` vertex program.		`SpriteAnimationInfo`	`Sprite` - The next animation frame	None present.
animate_sprite_interpolate	Renders interpolated texture animations. Uses the `core/animate_sprite.vsh` vertex program.		`SpriteAnimationInfo`	`CurrentSprite` - The current animation frame `NextSprite` - The next animation frame	None present.
blit_screen	Copies one buffer to another, cannot be fully overriden with a resourcepack.		None present.	`Sampler0` - The buffer to copy from.	None present.
block	Renders blocks that aren't part of chunk meshes such as falling sand, or blocks being moved by a piston. ^{[more information needed]}		`DynamicTransforms` `Fog` `Projection`	`Sampler0` - The blocks atlas. `Sampler2` - The lightmap.	`ALPHA_CUTOUT` - Minimum opacity before pixels are discarded, if not defined no pixels get discarded.
debug_point	Used for some debug renderers ^{[more information needed]} Uses the `core/position_color.fsh` fragment program.		`DynamicTransforms` `Projection`	None present.	None present.
entity	Renders most entities including but not limited to: Mobs Items (in the world and in guis) that can be used to place non-translucent blocks ‌^{[until JE 26.1]} End crystal beams Block entities that use special rendering such as banners and chests, both in the world and in guis Equipment and other overlays such as the charged creeper energy swirls Experience orbs ‌in 26.1^[upcoming]		`DynamicTransforms` `Fog` `Lighting` `Projection`	`Sampler0` - The base texture of the entity. `Sampler1` - The red damage indicator overlay. `Sampler2` - The lightmap. `DissolveMaskSampler` ^{[upcoming JE 26.1]} - An alpha mask to use when the `DISSOLVE` define is set.	`ALPHA_CUTOUT` - Minimum opacity before pixels are discarded, if not defined no pixels get discarded. `APPLY_TEXTURE_MATRIX` - Whether or not the uv should be offset by the `TextureMat` uniform. `EMISSIVE` - Whether or not lighting should be applied to the entity. `NO_CARDINAL_LIGHTING` - Whether or not directional shading should be applied. `NO_OVERLAY` - Whether or not the red damage tint should be applied. `PER_FACE_LIGHTING` - Whether or not lighting should be calculated seperately for the front and back quad faces. `DISSOLVE` ^{[upcoming JE 26.1]} - Whether or not the `DissolveMaskSampler` should be used as an alpha mask.
glint	Renders the enchantment glint on items, equipment, etc.		`DynamicTransforms` `Fog` `Globals` `Projection`	`Sampler0` - The enchantment glint texture.	None present.
gui	Renders flat colored gui elements including but not limited to: Chat and F3 screen text background Advancement screen lines and background darken effect Background of resource/datapack screen items Background of selected world/server in world/server screens Loading screen background Selected language in language menu Selected statistic in statistics menu Inventory screen backgrounds World loading progress Text background on "Saving world" and similar screens		`DynamicTransforms` `Projection`	None present.	None present.
item ^{[upcoming JE 26.1]}	Renders all item models in the world and in guis		`DynamicTransforms` `Fog` `Lighting` `Projection`	`Sampler0` - The items or blocks atlas depending on the model currently being rendered. `Sampler2` - The lightmap.	`ALPHA_CUTOUT` - Minimum opacity before pixels are discarded, if not defined no pixels get discarded.
lightmap	Renders the lightmap which is used by other shaders to determine how bright or dark parts of the world should be. Uses the `core/screenquad.vsh` vertex program.	In this image the lightmap shader outputs a horizontal gradient from black to red Here the lightmap has been modified to output a gradient from black to red horizontally, and black to green vertically. A mod has been used to display the output of this shader to the top left of the screen for a clearer visualisation	`LightmapInfo`	None present.	None present.
panorama	Renders the title screen panorama cubemap.		`DynamicTransforms` `Projection`	`Sampler0` (samplerCube) - A cubemap sampler containing all 6 panorama images.	None present.
particle	Renders all particle effects. Also renders the rain and snow weather effects.		`DynamicTransforms` `Fog` `Projection`	`Sampler0` - The particles or blocks atlas, depending on the particle that is being rendered. If rendering a weather effect then this is the corresponding texture for that effect. `Sampler2` - The lightmap.	None present.
position_color	Renders the lower half of the sky at sunrise and sunset. Also renders the F3 debug pie and chunk borders.		`DynamicTransforms` `Projection`	None present.	None present.
position_tex_color	Renders some miscellaneous textured things including but not limited to: The end skybox GUI buttons, backgrounds, tooltips, icons etc Pre-rendered items and entities in GUIs (see the Render process section for more information) World icons, server icons, resourcepack icons, datapack icons, etc HUD elements such as the hotbar, crosshair, health hearts, tab list heads, etc The Mojang and Minecraft logos Fire overlay Camera overlay effects such as the vignette, pumpkin blur, freezing effect, etc The sun and moon	In this image, the square to the right is a prerendered item being drawn onto a quad	`DynamicTransforms` `Projection`	`Sampler0` - For most gui widgets and icons, this is the gui atlas. For world, resourcepack, etc icons, mojang logo, camera overlays, or other non-gui things this is the texture of the object being rendered.	None present.
position_tex	Unused.		None present.	None present.	None present.
position	Handles depth for the ender dragon's death rays^{[more information needed]}.		`DynamicTransforms` `Fog` `Projection`	None present.	None present.
rendertype_beacon_beam	Renders the beacon and end gateway beams.		`DynamicTransforms` `Fog` `Projection`	`Sampler0` - The texture of the current part of the beam being rendered.	None present.
rendertype_clouds	Renders the clouds.		`CloudInfo` `DynamicTransforms` `Fog` `Projection`	`CloudFaces` (isamplerBuffer) - Data about cloud faces^{[more information needed]}	None present.
rendertype_crumbling	Renders the block breaking animation.		`DynamicTransforms` `Fog` - Although not explicitly defined in the code this can be used `Projection`	`Sampler0` - The texture for current stage of the block breaking animation.	None present
rendertype_end_portal	Renders the end portal and end gateway "starfield" effect.		`DynamicTransforms` `Fog` `Globals` `Projection`	`Sampler0` - The end sky texture `textures/environment/end_sky.png`. `Sampler1` - The end portal stars texture `textures/entity/end_portal.png`.	`PORTAL_LAYERS` - The amount of star layers to render.
rendertype_entity_alpha ‌^{[until JE 26.1]}	Acts as an alpha mask for the ender dragon while it is dying. Pixels that are discarded in this shader will make the corresponding pixels on the ender dragon invisible.	In this image the shader has been edited to dicard all pixels on the right half of the screen	`DynamicTransforms` `Projection`	`Sampler0` - The dragon exploding texture `textures/entity/enderdragon/dragon_exploding.png`.	None present.
rendertype_entity_decal ‌^{[until JE 26.1]}	Renders the textured parts of the ender dragon while it is dying.	In this image the shader has been edited to always output yellow	`DynamicTransforms` `Fog` `Lighting` `Projection`	`Sampler0` - The base texture of the entity. `Sampler1` - The red damage indicator overlay. `Sampler2` - The lightmap.	None present.
rendertype_entity_shadow	Renders the shadow that appears under most entities.	Highlighted in orange is where the shadow is normally visible in vanilla	`DynamicTransforms` `Fog` `Projection`	`Sampler0` - The shadow texture `textures/misc/shadow.png`.	None present.
rendertype_item_entity_translucent_cull ‌^{[until JE 26.1]}	Renders experience orbs and items that are not rendered by the `entity` shader including: Items that can be used to place translucent blocks, for example stained glass Items that cannot used to place a block Additionally renders invisible entities in some situations: Invisible entities while the player is in spectator mode Invisible entities while the player is on the same team as the entity, and the team has `seeFriendlyInvisibles` enabled	In this image, entities highlighted in semi transparent red are invisible and the player is in spectator mode	`DynamicTransforms` `Fog` `Lighting` `Projection`	`Sampler0` - The texture of the object being rendered; either the blocks atlas, the experience orb texture, or the entity texture. `Sampler2` - The lightmap.	None present.
rendertype_leash	Renders leads that are attached to entities in the world.		`DynamicTransforms` `Fog` `Projection`	`Sampler2` - The lightmap.	None present.
rendertype_lightning	Renders lightning bolts and the ender dragon's death rays.		`DynamicTransforms` `Fog` `Projection`	None present.	None present.
rendertype_lines	Renders all types of lines including: The block outline Entity debug hitboxes The F3 screen crosshair Structure and test block bounding boxes		`DynamicTransforms` `Fog` `Globals` `Projection`	None present.	None present.
rendertype_outline	Renders a flat colored outline of entities which have the glowing effect. The colour of this is based on the team the entity is in, or the glow color override for display entities, which is passed to the shader via the `Color` vertex attribute. The output of this shader is saved to a buffer and then later used in the `entity_outline` post effect to create the full glowing effect.	In this image, the entity_outline post effect has been disabled to clearly show what this shader outputs	`DynamicTransforms` `Projection`	`Sampler0` - The base texture of the object being rendered.	None present.
rendertype_text_background_see_through	Renders the background of text display entities that are set to render through blocks.		`DynamicTransforms` `Projection`	None present.	None present.
rendertype_text_background	Renders the background of text display entities that are not set to render through blocks.		`DynamicTransforms` `Fog` `Projection`	None present.	None present.
rendertype_text_see_through rendertype_text_intensity_see_through	Renders text that is visible through blocks. Also renders the background of player and entity nameplates. Note: rendertype_text_intensity_see_through is identical, however it is only used to render ttf fonts.		`DynamicTransforms` `Projection`	`Sampler0` - An automatically generated 256x256 atlas which contains the current character that is being rendered.	None present.
rendertype_text rendertype_text_intensity	Renders text in the world and in GUIs. Also renders maps in item frames or when held in first person. Note: rendertype_text_intensity is identical, however it is only used to render ttf fonts.		`DynamicTransforms` `Fog` `Projection`	`Sampler0` - An automatically generated 256x256 atlas which contains the current character that is being rendered. For maps, this is the map background texture, map_decorations atlas, or the map itself depending on which part is currently being rendered. `Sampler2` - The lightmap.	None present.
rendertype_translucent_moving_block	Renders translucent blocks, such as stained glass, that are being moved by a piston. Non-translucent blocks are rendered by the `block` shader.		`DynamicTransforms` `Fog` - Although not explicitly defined in the code this can be used `Projection`	`Sampler0` - The blocks atlas. `Sampler2` - The lightmap.	None present.
rendertype_water_mask	A mask used to hide water inside boats.	In this image the shader has been edited to discard all pixels on the right half of the screen	`DynamicTransforms` `Projection`	None present.	None present.
rendertype_world_border	Renders the world border.		`DynamicTransforms` `Projection`	`Sampler0` - The world border texture `textures/misc/forcefield.png`.	None present.
sky	Renders the upper half of the overworld skybox.		`DynamicTransforms` `Fog` `Projection`	None present.	None present.
stars	Renders the stars in the overworld sky at night.		`DynamicTransforms` `Projection`	None present.	None present.
terrain	Renders all blocks and fluids in the world.		`ChunkSection` `Fog` `Projection`	`Sampler0` - The blocks atlas. `Sampler2` - The lightmap.	`ALPHA_CUTOUT` - Minimum opacity before pixels are discarded, if not defined no pixels get discarded.

Include shaders

Include shaders (stored in assets/<namespace>/shaders/include) contain helper functions and variables that can be used in multiple shader programs. These must have the .glsl, .vsh, or .fsh file extensions.

To import an include shader, add one of the following import directives anywhere in a vertex or fragment shader program

#moj_import <filepath.glsl> imports a file from assets/minecraft/shaders/include/<filepath>.glsl
#moj_import <namespace:path.glsl> imports a file from assets/<namespace>/shaders/include/<path>.glsl
#moj_import "filepath.glsl" imports a file from assets/minecraft/shaders/core/<filepath>.glsl

When importing an include shader, the game replaces the import directive with the contents of the include shader. The imported file needs to end with an empty line, otherwise the shader does not load.

Vanilla include shaders

The following include shaders are used throughout the vanilla resource pack

Name	Description
fog.glsl	Contains the `linear_fog` function to calculate the color based on the vertex distance. Contains a definition of the `Fog` uniform block
light.glsl	Contains the `minecraft_mix_light` function, used to calculate face lighting in entity shaders. Contains a definition of the `Lighting` uniform block
matrix.glsl	Contains the `mat2_rotate_z` function that returns the rotation matrix for a vec2 around the z-axis.
projection.glsl	Contains the `projection_from_position` function. Contains a definition of the `Projection` uniform block
globals.glsl	Contains a definition of the `Globals` uniform block.
dynamictransforms.glsl	Contains a definition of the `DynamicTransforms` uniform block.
chunksection.glsl	Contains a definition of the `ChunkSection` uniform block.
animation_sprite.glsl	Contains a definition of the `SpriteAnimationInfo` uniform block.
smooth_lighting.glsl ^{[upcoming JE 26.1]}	Contains the `minecraft_sample_lightmap` function, used by various shaders to sample the lightmap texture.

Post-processing effects

As mentioned previously, post-processing effects are used in menu backgrounds, when spectating certain mobs to create vision effects, the Fabulous! graphics setting, and when rendering the glowing effect.

Post-effect file format

Post-processing effects are made up of multiple passes and render targets. A target is a buffer that can be read from and written to. The game provides some built-in targets that contain certain parts of the game world (particles, water, etc), and you can define your own to read and write data to. A pass can have multiple inputs from png textures or render targets.

Post-processing effects are defined in assets/<namespace>/post_effect/<post effect>.json. Note that post-processing effects are applied before the HUD and GUI elements are rendered

[NBT Compound / JSON Object]: The root tag
- [NBT Compound / JSON Object] targets: Custom render targets to be used by render passes
  - [NBT Compound / JSON Object] target definition: The key is the name of the target
    - [Int] width: Defaults to the current viewport width. The width of the target
    - [Int] height: Defaults to the current viewport height. The height of the target
    - [Boolean] persistent: Defaults to false. If true, this target is not cleared between frames. It is still cleared when the game window is resized, however.
    - [NBT List / JSON Array][Int] clear_color Defaults to [0, 0, 0, 0]. The colour this target is filled with when it is created or cleared. Supports two formats. A list of floats in 0-1 range [R, G, B, A], or a colour in decimal format calculated from the red, green and blue components using this formula:
      (Alpha << 24) + (Red << 16) + (Green << 8) + Blue
- [NBT List / JSON Array] passes: Render passes
  - [NBT Compound / JSON Object] pass: A render pass
    - [String] vertex_shader: The namespaced id of a vertex shader to use for this pass, relative to the shaders folder. minecraft:post/blit resolves to assets/minecraft/shaders/post/blit.vsh
    - [String] fragment_shader: The namespaced id of a fragment shader to use for this pass, relative to the shaders folder. minecraft:post/box_blur resolves to assets/minecraft/shaders/post/box_blur.fsh
    - [NBT List / JSON Array] inputs: A list of render target inputs and / or texture inputs
      - [NBT Compound / JSON Object] render target input
        [String] sampler_name: The name of the sampler uniform
        Setting this to MainDepth, for example, makes a sampler2D uniform called MainDepthSampler available to the shader program for this pass. This will also provide an additional vec2 to the SamplerInfo uniform block called <sampler_name>Size, for example MainDepthSize
        
        [Boolean] bilinear: Default: false. If set to true, the sampler uses bilinear filtering instead of nearest neighbor
        
        [String] target: The name of the target. Can either be a custom target as specified in targets above, or one of the following built in targets: minecraft:main, minecraft:translucent, minecraft:item_entity, minecraft:particles, minecraft:weather, minecraft:clouds, or minecraft:entity_outline
        
        [Boolean] use_depth_buffer: Default: false. If set to true, it samples from the depth texture instead of the color texture.
      - [NBT Compound / JSON Object] texture input
        [String] sampler_name: The name of the sampler uniform
        Setting this to MyTexture, for example, makes a sampler2D uniform called MyTextureSampler available to the shader program for this pass. This will also provide an additional vec2 to the SamplerInfo uniform block called <sampler_name>Size, for example MyTextureSize
        
        [Boolean] bilinear: Default: false. If set to true, the sampler uses bilinear filtering instead of nearest neighbor
        
        [String] location: The resource location of the texture. my_namespace:post_texture resolves to assets/my_namespace/textures/effect/post_texture.png
        
        [Int] width: The width of the texture in pixels
        
        [Int] height: The height of the texture in pixels
    - [String] output: The target to output to. Can either be a custom target as specified in targets above or minecraft:main. Note: you cannot read and write to the same target in the same pass
    - [NBT Compound / JSON Object] uniforms: An object of uniform blocks to pass to the vertex and fragment shaders. For example, uniforms: { "UniformBlockName": [ { "type": "vec2", "value": [...] } ] }
      - [NBT List / JSON Array] uniform block: The key is what this uniform block will be called when referenced in a shader
        [NBT Compound / JSON Object] uniform definition
        [String] name: The name of the uniform. This is unused by the game, however it is recommended to set it for organizational purposes
        
        [String] type: The type of the uniform, can be any of: int, float, ivec3, vec2, vec3, vec4, and matrix4x4
        
        [Int][Float][NBT List / JSON Array] value: Uniform values. The amount and format of this depends on what the type field is set to
        int requires a single int
        
        float requires a single float
        
        ivec3 requires list of 3 ints
        
        vec2 requires list of 2 floats
        
        vec3 requires list of 3 floats
        
        vec4 requires list of 4 floats
        
        matrix4x4 requires 16 floats

List of post-processing effects

There are currently six post-processing effects used in the game:

Name	Used for	Sample images
blur	Used for the blur effect in the background of most menus in-game and on the title screen. This post effect is not used when the "Menu Background Blur" accessibility setting is set to 0.
creeper	Adds a green filter over the screen and give the appearance of a reduced resolution. Used when spectating a creeper.
entity_outline	Applies a blur over a solid color silhouette of an entity. Used when an entity with the glowing effect is on-screen.	Left side is the "minecraft:entity_outline" target before the post effect is applied, right side is the final image with the post effect applied
invert	Inverts the colours of the screen. Used when spectating an enderman.
spider	Renders a blurred version of the screen with 5 additional copies overlapped on top with blurred edges. Used when spectating a spider.
transparency	Combines multiple passes (targets) of different objects in the world, resulting in slightly better translucency blending compared to "Fast" or "Fancy" graphics. Used when the graphics mode is set to "Fabulous!".	"minecraft:main" target "minecraft:translucent" target "minecraft:item_entity" target "minecraft:particles" target "minecraft:clouds" target "minecraft:weather" target Final image

Render process

This section needs expansion.

You can help by expanding it.

General game rendering

Each frame is rendered in the following order^{[more information needed]}

The world, including entities, blocks, the sky, items, etc is rendered (by core shaders)
Any Post effects are applied as necessary
The GUI and HUD elements are rendered (by core shaders)

GUI item and entity rendering

When the game draws an item or entity in a GUI the following process occurs:

The item or entity is pre-rendered to an internal texture. For items, this may be an atlas of all currently visible items ("GUI items atlas") or a single texture for that item. This depends on if the oversized_in_gui field is set to true or false in the items model definition. For entities, each one always has a unique texture that it gets rendered to
For each item or entity, a quad is drawn to the screen which samples from either the GUI items atlas or individual texture for the corresponding item or entity

The game can skip rendering an item when neccesary and will use whatever was drawn on the previous frame. An item is only re-rendered if one of the following conditions is met:

The item has an animated texture somewhere on its model
The item has an enchantment glint
The GUI items atlas fills up, in this case it is cleared and all currently visible GUI items are redrawn
The GUI scale is changed, in this case the GUI items atlas is cleared and all currently visible GUI items are redrawn
The item data is changed in a way that would cause a visual update. This includes but is not limited to: changing the item_model, custom_model_data, or profile data components

Vanilla uniform blocks

Using uniform blocks outside supported shaders may work in some cases, however this is undefined behavior and may cause unexpected results or crashes. Refer to the list of core shaders for more info

Uniforms blocks use the std140 layout. All uniforms must be specified and in the correct order and with the correct type, otherwise weird and undefined behavior will occur. For convenience, some uniform blocks are pre-defined in include shaders, see the include shaders section for more information.

Some shaders may not use all uniforms in a given uniform block, in this case the unused uniforms will have a 'default' value. For example, while the rendertype_lines core shader will have the proper value for the LineWidth uniform, other shaders will have a "default value" for which will likely not be useful.

Common blocks

The following uniform blocks are available in both post-processing and core shaders.

Globals

This uniform block is always bound and has proper values in all shaders.

(ivec3) CameraBlockPos Block position of the camera in world-space coordinates.
(vec3) CameraOffset Fractional position of the camera in world-space coordinates.
(vec2) ScreenSize The width and height of the current framebuffer in pixels.
(float) GlintAlpha The value of the Glint Strength accessibility setting in a 0-1 range.
(float) GameTime A value that constantly increases from 0-1 over the span of roughly 20 minutes, then resets to 0. The exact formula for this is (<age of the world> modulo 24000) / 24000.
(int) MenuBlurRadius The value of the Menu Background Blur accessibility setting in a 0-10 range.
(int) UseRgss A "boolean" value. Value is 1 if the texture filtering video setting is set to RGSS, otherwise 0.

Core blocks

The following uniform blocks are only available in core shaders.

Fog

This uniform block is always bound, however may not have proper values if used outside shaders which support it.

(vec4) FogColor Colour of the fog.
(float) FogEnvironmentalStart Starting distance of environmental fog.
(float) FogEnvironmentalEnd Ending distance of environmental fog.
(float) FogRenderDistanceStart Starting distance of render distance fog.
(float) FogRenderDistanceEnd Ending distance of render distance fog.
(float) FogSkyEnd Ending distance of fog for the upper portion of the sky.
(float) FogCloudsEnd Ending distance for clouds fog.

DynamicTransforms

(mat4) ModelViewMat The model-view matrix.
(vec4) ColorModulator A color multiplier that can be set in game code to modify the final color of objects.
(vec3) ModelOffset The offset of the model being rendered.
(mat4) TextureMat A 4D matrix used to transform UV's for some animated effects, such as the enchantment glint, breeze and wind charge wind, world border, etc.

Lighting

This uniform block is always bound, however may not have proper values if used outside shaders which support it.

(vec3) Light0_Direction First light direction. Used to calculate directional entity shading.
(vec3) Light1_Direction Second light direction. Used to calculate directional entity shading.

Projection

This uniform block is always bound, however may not have proper values if used outside shaders which support it.

(mat4) ProjMat The projection matrix

LightmapInfo

(float) AmbientLightFactor ‌^{[until JE 26.1]} How much ambient light there should be. This is 0.1 for the nether, 0.25 for the end, and 0 for the overworld.
(float) SkyFactor A value that specifies how much to brighten the lightmap by when the sky flashes, typically when a lightning strike occurs. This value comes from the minecraft:visual/sky_light_factir environment attribute.
(float) BlockFactor A value that fluctuates randomly, used in the vanilla shader for block light flickering.
(float) NightVisionFactor A value in a 0-1 range that specifies how much the Night Vision status effect should brighten the lightmap by.
(float) DarknessScale A value in a 0-1 range that specifies how much the Darkness status effect should darken the lightmap by.
(float) DarkenWorldFactor (renamed to BossOverlayWorldDarkeningFactor ‌in 26.1^[upcoming]) A value that specifies how much to darken the lightmap by when a bossbar is visible. This is seemingly only used in the ender dragon fight ^{[more information needed]}.
(float) BrightnessFactor The value of the brightness video setting in a 0-1 range.
(vec3) BlockLightTint ^{[upcoming JE 26.1]} The color of block light. This value comes from the minecraft:visual/block_light_tint environment attribute.
(vec3) SkyLightColor The color of sky light. This value comes from the minecraft:visual/sky_light_color environment attribute.
(vec3) AmbientColor The ambient light color. This value comes from the minecraft:visual/ambient_light_color environment attribute ‌in 26.1^[upcoming].
(vec3) NightVisionColor ^{[upcoming JE 26.1]} The color of the Night Vision status effect. This value comes from the minecraft:visual/night_vision_color environment attribute.

CloudInfo

(vec4) CloudColor The color of the clouds.
(vec3) CloudOffset Offset of the clouds ^{[more information needed]}.
(vec3) CellSize Size of each individual cloud ^{[more information needed]}.

ChunkSection

(mat4) ModelViewMat The model-view matrix.
(float) ChunkVisibility Value that increments from 0 to 1 once a chunk section has been displayed. The amount of time this takes is dependent on the "Chunk Fade" video setting
(ivec2) TextureSize ^{[more information needed]}
(ivec3) ChunkPosition ^{[more information needed]}

SpriteAnimationInfo

(mat4) ProjectionMatrix The projection matrix
(mat4) SpriteMatrix ^{[more information needed]}
(float) UPadding ^{[more information needed]}
(float) VPadding ^{[more information needed]}
(int) MipMapLevel ^{[more information needed]}

Post-processing blocks

The following uniform blocks are only available in post-processing shaders.

SamplerInfo

(vec2) OutSize The width and height of the output buffer in pixels.
(vec2) All other inputs specified in the same order as the post-effect definition. These are named as <sampler_name>Size, for example, MainSize for an input with a name of "Main"

Bedrock Edition

This section needs expansion.

You can help by expanding it.

Since Bedrock Edition 1.18.30, third-party shader in resource packs are no longer supported on all devices due to the implementation of RenderDragon.

Deferred rendering pipeline

The deferred rendering pipeline is an alternative rendering pipeline which can be customized via resource packs and is used in the vanilla game for the Vibrant Visuals graphics mode.

Although it doesn't directly support custom shaders, it offers ways to define properties about light, fog, atmosphere, and PBR texture materials. This can be used to create lighting effects similar to those seen in Java Edition's shader packs.

History

Java Edition
1.7.2	13w38a	Shaders were added for Super Secret Settings.
1.8	14w05a	The Creeper and Spider shaders were added. Shaders are automatically applied in spectator mode when viewing the world as a creeper, spider or enderman.
	14w05b	Shaders have been removed from view when changing perspective while spectating a mob.^[1]
	14w05b	`F4` now toggles different shaders rather than turning them off.^[1]
	14w06a	The `entity_outline` post effect shader was added.
1.9	15w31a	Removed the Super Secret Settings button for an internal rewrite.^[2]
1.16	20w22a	The `transparency` post effect shader was added for Fabulous! graphics mode.
1.17	21w10a	Added core shaders.
		Added the `fog.glsl`, `light.glsl`, `matrix.glsl`, and `projection.glsl` include shaders
		The game now requires OpenGL 3.2 Core Profile.
		Upgraded the existing shader programs for post processing effects from glsl version `110` to `150`
1.18.1	?	The `fog.glsl` include shader now has a `cylindrical_distance` function. All core shaders that previously used the builtin `length` function to calculate vertex distance use this.
1.18.2	?	In `fog.glsl` the `cylindrical_distance` function has been renamed to `fog_distance`. It also takes an additional int parameter for fog shape.
1.18.2	?	Added the `FogShape` uniform for core shaders.
1.19	22w12a	There are now shader files for translucent entity rendering.
1.20.5	24w05a	The attributes array in core shader definitions has been removed. All attributes are now always bound for a given shader.
		The unused `position_color_normal` and `position_tex_lightmap_color` core shaders have been removed
		The `position_tex_color_normal` core shader has been renamed to `rendertype_clouds`
		The `IViewRotMat` uniform has been removed, and the Position attribute for entities is now in (camera relative) world space
		Light direction uniforms are no longer premultiplied by the view matrix
	24w09a	The menu background dirt texture has been replaced by a post-processing blur shader.
	24w11a	All unused post-processing shaders that were used for Super Secret Settings have been removed.
1.21.2	24w34a	Shader program configurations can now specify preprocessor define directives to apply to their linked shaders.
		The format of core shader and post-processing shader configurations have been consolidated.
		The `rendertype_entity_glint_direct` core shader has been removed and replaced by `rendertype_entity_glint`.
		The `rendertype_entity_translucent_cull` shader has been removed and replaced by `rendertype_item_entity_translucent_cull`.
	?	Renamed the `ChunkOffset` uniform to `ModelOffset`
	?	The `moj_import` directive now accepts a resource location, allowing include shaders to be placed in namespaces other than minecraft
	?	Most textured gui elements now use the `position_tex_color` core shader instead of `position_tex`
1.21.5	25w06a	Added a new core shader, `rendertype_world_border`, which is used to render the world border
	25w07a	Shader program configuration files have been removed. The shader programs are still present, however the only uniforms available to them are the default ones that are used in the vanilla rendering.
		In post-processing effects, the field `program` was replaced with `vertex_shader` and `fragment_shader` which resolve to `assets/<namespace>/shaders/<path>.<vsh or fsh>`
		In post-processing effects, `type` is now a required field for each `uniform`, with the possible values being `int`, `ivec3`, `float`, `vec2`, `vec3`, `vec4` and `matrix4x4`
		In post-processing effects, the `values` field is now option for each `uniform`. Leaving it unset is not recommended as it will result in undefined behavior. Leaving it unset is only used for runtime configuration of the blur post-processing effect in the vanilla rendering
		The `EndPortalLayers` uniform has been removed and replaced by a pre-processor define called `PORTAL_LAYERS`
	25w10a	"Global" uniforms can now be defined in shader programs. If a uniform is not usually available to that shader, or the type of the uniform is not defined as what it would normally be, undefined behavior will occur
	25w10a	Currently, the "global" uniforms are: `ModelViewMat`, `ProjMat`, `TextureMat`, `ScreenSize`, `ColorModulator`, `Light0_Direction`, `Light1_Direction`, `GlintAlpha`, `FogStart`, `FogEnd`, `FogColor`, `FogShape`, `LineWidth`, `GameTime`, and `ModelOffset`
1.21.6	25w16a	All built-in uniforms are now uniform blocks instead of opaque loose uniforms
		Custom uniforms provided to post-process shaders are now uniform blocks
		In post-processing effects, `targets` now supports two new optional fields: `persistent` and `clear_color`
		In post-processing effects, the `uniforms` field is now a list of uniform blocks, example: `{ "UniformBlockName": [ { "type": "vec2", "value": [...] } ] }`.
		In post-processing effect uniform definitions, the `name` field is now unused by the game but still present. The `values` field has been replaced with `value`, behaving largely the same but for the `int` and `float` uniform types this field accepts a single number instead of a list with 1 entry.
		In post-processing effects, the list of size (all vec2 *Size) uniforms have been replaced with a single `SamplerInfo` uniform block.
		The main menu panorama now uses a new fragment program, `core/panorama.fsh`.
		The `core/position_tex.fsh` program is now unused.
		The `position` core shader can now have a `FOG_IS_SKY` define directive.
		The `minecraft_sample_lightmap` has been removed from the `light.glsl` include shader. All shaders that previously used this function now instead sample the lightmap texture directly.
	25w17a	Added two new core shaders; `stars`, and `sky` which are used to render the stars and upper portion of the sky respectively.
	25w17a	Removed the `FOG_IS_SKY` define directive, as the sky now uses a separate shader.
	25w19a	The main menu panorama now uses a new vertex program, `core/panorama.vsh`.
		The `core/position_tex.vsh` program is now unused.
		Added four new uniforms, `FogEnvironmentalStart`, `FogEnvironmentalEnd`, `FogRenderDistanceStart` and `FogRenderDistanceEnd`.
		The `FogShape`, `FogStart` and `FogEnd` uniforms have been removed.
1.21.9	25w31a	Removed the `post/blit.vsh`, `post/blur.vsh`, `post/invert.vsh`, `post/sobel.vsh`, `post/screenquad.vsh`, and `core/blit_screen.vsh` shader programs and replaced them with `core/screenquad.vsh`.
	25w31a	Vertex shaders for post-processing effects and full screen blits are no longer are passed a `Position` attribute. Instead these must assign vertex coordinates using `gl_VertexID`. Additionally, these shaders are only executed with 3 vertices instead of a full quad like they were previously.
	25w33a	In the `LightmapInfo` uniform block, the `int UseBrightLightmap` uniform has been removed, and `vec3 AmbientColor` has been added.
	25w33a	The `core/lightmap.fsh` shader has been modified for the new end flashes.
	25w35a	The `core/lightmap.fsh` shader has been modified slightly to fix some issues with end flashes. The darkness effect pulsing is no longer applied in the end as part of these changes.
	25w36a	Removed the unused `core/position_color_lightmap.fsh`, `core/position_color_lightmap.vsh`, `core/position_color_tex_lightmap.fsh`, and `core/position_color_tex_lightmap.vsh` shader programs.
	25w36a	Minor change to uv calculations in the `minecraft_sample_lightmap` function in the `core/terrain.vsh` program.
	25w37a	The `core/entity` shader can now have a `PER_FACE_LIGHTING` flag. When set, cardinal lighting will be computed separately for front and back faces of each quad.
		The game now requires OpenGL 3.3 Core Profile.
		Upgraded all shader programs from glsl version `150` to `330`
		Split the logic for `minecraft_mix_light` function in `include/light.glsl` into two additional functions: `minecraft_compute_light` and `minecraft_mix_light_separate`
1.21.11	25w41a	Added a new shader program `core/debug_point.vsh`
	25w41a	Removed the `LineWidth` uniform from the `DynamicTransforms` uniform block. Line width is now passed as a vertex attribute to the `core/rendertype_lines` and `core/debug_point` shaders instead.
	25w44a	Added new shader programs `core/animate_sprite.vsh`, `core/animate_sprite_blit.fsh`, and `core/animate_sprite_interpolate.fsh` for rendering texture animations.
		Changes have been made to the `core/terrain` shader for texel antialiasing and chunk fade animations.
		The `Sampler0` uniform in the `core/terrain` shader now uses linear filtering instead of nearest.
		Added new shader programs `core/block.vsh` and `core/block.fsh` for rendering non-chunk-meshed blocks such as falling sand or blocks being moved by a piston.
		Added new include shaders `include/animation_sprite.glsl` and `include/chunksection.glsl` which contain definitions for new `SpriteAnimationInfo` and `ChunkSection` uniform blocks respectively.
		Added two new uniforms, `ivec3 CameraBlockPos` and `vec3 CameraOffset`, to the `Globals` uniform block.
	pre1	The `core/terrain.fsh` shader has been modified to implement RGSS texture filtering.
	pre1	Added a new uniform, `int UseRgss`, to the `Globals` uniforms block.
Upcoming Java Edition
26.1	26.1-snapshot-1	The `core/lightmap.fsh` shader has been mostly rewritten
		Added two new uniforms to the `LightmapInfo` uniform block: `vec3 BlockLightTint` and `vec3 NightVisionColor`.
		The `float AmbientLightFactor` uniform has been removed from the `LightmapInfo` uniform block. It is now pre-multiplied into the `vec3 AmbientColor` uniform.
		The `float DarkenWorldFactor` uniform in the `LightmapInfo` uniform block has been renamed to `float BossOverlayWorldDarkeningFactor`
		Added a new `include/smooth_lighting.glsl` shader. Contains a function called `minecraft_sample_lightmap` used by various shaders to sample the lightmap texture.
	26.1-snapshot-5	Various shaders now sample the lightmap texture using the `texture` function instead of `texelFetch`. This includes `core/entity.vsh`, `core/rendertype_entity_decal.vsh`, `core/rendertype_item_entity_translucent_cull.vsh`, `core/rendertype_leash.vsh`, `core/rendertype_text.vsh`, `core/rendertype_text_background.vsh`, `core/rendertype_text_intensity.vsh`, and `core/rendertype_translucent_moving_block.vsh`.
	26.1-snapshot-6	The `core/rendertype_item_entity_translucent_cull` shader has been removed, most things that were previously handled by this shader are now handled by `core/entity`.
		The `core/rendertype_entity_alpha` and `core/rendertype_entity_decal` shaders have been removed and replaced by a `DISSOLVE` define directive in `core/entity`
		All item models are now rendered using a new `core/item` shader instead of `core/entity`, with the exception of special model renderers which still use `core/entity`