Shaders

This article is a work in progress.

Please help in the expansion or creation of this article by expanding or improving it. The talk page may contain suggestions.

Shaders are used to depict how to render the game.

Java Edition

There are two kinds of shaders: core shaders and post-processing shaders.

Core shaders are used to render different parts of the game.

Post-processing shaders are used for mob view in spectator mode, blending of translucent layers in Fabulous! graphics, and glowing status effect.

Shaders are written in OpenGL Shading Language (GLSL). Each single render program come in two parts, vertex and fragment. The vertex shaders modify the positions of individual vertices and are most often used to create waving foliage and water. Fragment shaders are applied to every pixel and can be used to add effects like bloom, god rays, and blur.

Shaders are stored in the assets/minecraft/shaders/ directory of minecraft.jar. Can be replaced with a resource pack. Note that if any error occurs when loading the shaders, the resource pack will be disabled and fabulous graphics mode will be turned off^{[needs testing]}.

Core shaders

Core shaders are responsible for rendering parts of the game. They are used to render not only blocks and entities when playing the game, but also the main screen, option screen and so on.

Each core shader is a single render program defined by a JSON file, in which vertex and fragment shader file are specified.

Core shaders are stored in the assets/minecraft/shaders/core directory of minecraft.jar.

The following table lists them all including a short description of what the shader renders, as well as, an image highlighting the shaders target in red.

This section is too long. Please click the "show" button to read it

This section is missing information about What affects the following specially rendered game elements:

Fishing rod line
Darkness vignette, and world border vignette screen effects
The super subtle underwater screen effect
Totem of Undying use animation
End gateway beam (possibly different from beacon beam due to a since-fixed rendering issue MC-173745, however it may have been unified as a result)
Wither armor
Enchantment overlay
Ender dragon death beams
Ender dragon disintegration effect.

Please expand the section to include this information. Further details may exist on the talk page.

Non-rendertype

Name	Used for	Sample Images
blit_screen	Blit copies one buffer to another, however this cannot be overridden in a resource pack.
block	Unknown
new_entity	Unknown
particle	All particles.
position	Top sky and stars in the overworld Dark fog when the player is in the void The highlight color when selecting a world.
position_color	Used for solid color-block, including: Sunrise and Sunset Chunk border Black background of spyglass overlay Sleep overlay Black background on UI elements Text box in UI Floating tooltip Text background Highlighting over item slots
position_color_lightmap	Unknown
position_color_normal	Unknown
position_color_tex	Suffocation overlay screen effect On fire overlay Distortion effect overlay for nausea effect when "Distortion Effects" less than 100%
position_color_tex_lightmap	Unknown
position_tex	Used to render a texture: The sun and the moon World border Underwater screen effect Spyglass texture overlay Carved pumpkin overlay Powder snow overlay Portal overlay Hotbar CrossHair Bossbar overlay health bar, armor bar, food bar, air bar, jump bar, experience bar Effect icons Normal GUIs Button in GUI Game logo and mojang logo
position_tex_color	Skybox with the `minecraft:the_end` dimension effect. Dirt background of GUIs
position_tex_color_normal	Clouds.
position_tex_lightmap_color	Unknown

Rendertype

Blocks

Name	Description	Sample Image
rendertype_beacon_beam	The beam of the beacon.
rendertype_crumbling	The block cracks when mining a block.
rendertype_cutout	All non-cube-hitbox blocks.^[verify]
rendertype_cutout_mipped	Some blocks: grass blocks, iron bars, glass panes, tripwire hooks, hoppers, chains (leaves when using fancy or fabulous graphics)
rendertype_end_gateway	Unknown.
rendertype_end_portal	The inside of an end portal, as well as the insides of end gateways.
rendertype_solid	All solid blocks, lava, and when in fast mode, leaves.
rendertype_translucent	Translucent blocks: water (still and flowing), ice, nether portal, stained and tinted glass, slime and honey, bubbles, water.
rendertype_translucent_moving_block	Blocks which are translucent and are being moved by a piston. The one below is stained glass.
rendertype_translucent_no_crumbling	Unknown.
rendertype_tripwire	Tripwire (sections connected to tripwire hooks are instead rendered completely solid^[1]
rendertype_water_mask	Unknown.

Entities

Name	Desciption	Sample Image
rendertype_energy_swirl	Charged Creeper swirling outline.
rendertype_entity_alpha	Unknown.
rendertype_entity_cutout	Items in the inventory, head (e.g. of armor stands) hand that are blocks (not flat textures)? Doesn’t seem to work with shulker boxes.
rendertype_entity_cutout_no_cull	All entities and guardian beams.
rendertype_entity_cutout_no_cull_z_offset	Skulls on entities and as an item.
rendertype_entity_decal	Unknown.
rendertype_entity_glint	Unknown.
rendertype_entity_glint_direct	Unknown.
rendertype_entity_no_outline	Unknown.
rendertype_entity_shadow	The blocks that are affected by an entity's shadow, but not the shadow itself.
rendertype_entity_smooth_cutout	End crystal beams.
rendertype_entity_solid	Certain entities or entity-style objects: banners, shulker heads, books on lecterns/enchantment tables, shields, beds, bell part of bells, capes, shells of conduits, paintings, tridents, the ears on the Deadmau5 skin. With item frames, the item frame entity itself is part of the shader, however items on it are not. Only the filled in parts of maps placed on an item frame are part of the shader. Also includes the first person bottom skin layer.
rendertype_entity_translucent	Translucent entities and parts of entities: slimes, players (possibly outer layers of player skins?), markings on horses, shulker bullets, elder guardian particle effect.
rendertype_entity_translucent_cull	Flat texture items held by entities (and in the inventory).
rendertype_eyes	A shader for the entire body of an entity that has glowing eyes (not the eyes themselves). This is not fully opaque.
rendertype_item_entity_translucent_cull	Unknown.
rendertype_leash	A leash on an entity. Applies when on a fence too.
rendertype_outline	Glowing effect on entities. This buffer only draws the already-outlined and semi-transparent glowing, not covering the entire entity like pre-snapshot.

Miscellaneous

Name	Description	Sample Image
rendertype_glint	Unknown.
rendertype_glint_direct	Unknown.
rendertype_glint_translucent	Unknown.
rendertype_lightning	Unknown.
rendertype_lines	The outline when hovering over a block, as well as the debug crosshair and hitboxes.
rendertype_text	All parts of text, including the shadow. This encompasses all text rendered including: F3 Menu, Menu button text, Entity names, Item names, descriptions & amounts in the inventory and the Chat etc.
rendertype_text_see_through	The background nameplate of an entity’s custom name.

Include shaders

Include shaders aren't stand-alone shader programs. They should be invoked by other shader files.

Include shaders contain helper functions that are commonly used. To import a glsl file in a shader use #moj_import <FILENAME.glsl> or #moj_import "FILENAME.glsl". NOTE: The imported file needs to end with an empty line, otherwise the shader will not load.

Core shaders are stored in the assets/minecraft/shaders/include directory of minecraft.jar.

Name	Description
fog	Contains the `linear_fog` function to calculate the color based on the vertex distance.
light	Contains the `minecraft_mix_light` function.
matrix	Contains the `mat2_rotate_z` function that returns the rotation matrix for a vec2 around the z-axis.
projection	Contains the `projection_from_position` function.

Post-processing shaders

Currently, post-processing shaders is used for mob view in spectator mode, blending of translucent layers in Fabulous! graphics, and glowing status effect.

Post-processing shaders use "post" files to define a pipeline made up of applying a sequence of "programs".

Each "program" is then defined by another JSON file, in which a single render program is defined.

"post" files are stored in the assets/minecraft/shaders/post directory of minecraft.jar. And programs are stored in the assets/minecraft/shaders/program.

There are only 4 post-processing shaders are used in the game:

creeper.json: Used when spectating a creeper
invert.json: Used when spectating an enderman
spider.json: Used when spectating a spider
entity_outline.json: Used when a glowing entity is on screen
transparency.json: Used when in "Fabulous!" graphics mode.

In these two directories, there are also many useless shaders, which were used for "Super Secret Settings" before 1.9 (15w31a). See Shaders/Before 1.9.

Render process

This section needs expansion.

You can help by expanding it.

File format

Render program

The root tag
- blend: Settings for OpenGL blending.
  - func: Operator to be used when blending. Can be add, subtract, reversesubtract, reverse_subtract, min, or max. Not case sensitive. Defaults to add. Used as mode parameter of glBlendEquation
  - srcrgb: Used as sfactor parameter of glBlendFunc or srcRGB parameter of glBlendFuncSeparate. Can be 0, 1, srccolor, 1-srccolor, dstcolor, 1-dstcolor, srcalpha, 1-srcalpha, dstalpha, or1-dstalpha. Case insensitive. Ignores "_". "1", "0", "-" can be replaced by "one", "zero", "minus".
  - dstrgb: Used as dfactor parameter of glBlendFunc or dstRGB parameter of glBlendFuncSeparate. Can be 0, 1, srccolor, 1-srccolor, dstcolor, 1-dstcolor, srcalpha, 1-srcalpha, dstalpha, or1-dstalpha. Case insensitive. Ignores "_". "1", "0", "-" can be replaced by "one", "zero", "minus".
  - srcalpha: Used as srcalpha parameter of glBlendFuncSeparate. Can be 0, 1, srccolor, 1-srccolor, dstcolor, 1-dstcolor, srcalpha, 1-srcalpha, dstalpha, or1-dstalpha. Case insensitive. Ignores "_". "1", "0", "-" can be replaced by "one", "zero", "minus".
  - dstalpha: Used as dstalpha parameter of glBlendFuncSeparate. Can be 0, 1, srccolor, 1-srccolor, dstcolor, 1-dstcolor, srcalpha, 1-srcalpha, dstalpha, or1-dstalpha. Case insensitive. Ignores "_". "1", "0", "-" can be replaced by "one", "zero", "minus".
- cull: If true, run glEnable(GL_CULL_FACE). If false, run glDisable(GL_CULL_FACE). Defaults to true.
- vertex: The name (without file extension) of the vertex shader to be used.
- fragment: The name (without file extension) of the fragment shader to be used.
- attributes: Attributes to be used by the vertex shader.
  - : An attribute. Available values are hard-coded.
- samplers: A list of samplers that may be used in the shaders.
  - : A sampler.
    - name: The samplers name.
    - file: ^{[more information needed]}
- uniforms: A list of uniforms that can be used in the shaders.
  - : A uniform.
    - name: The name of the uniform as referenced in the GLSL code. Some names give a uniform special behavior(Note that these following special uniform does not work in all shader programs):
      - Time: A value from 0 to 1, representing time in seconds. Resets every second.
      - InSize: The width and height of the input buffer in pixels.
      - OutSize: The width and height of the output buffer in pixels.
      - ModelViewMat: The model-view matrix.
      - ProjMat: The projection matrix.
      - TextureMat: 4D matrix used to transform UV's for item glint effects
      - ScreenSize: vec2 containing the current framebuffer width and height, in that order
      - ColorModulator: A global vec4 of multipliers that can be set from the game code as a color multiplier
      - Light0_Direction: First light direction as vec3 for entity rendering
      - Light1_Direction: Second light direction, see Light0_Direction
      - FogStart: Fog start distance from the camera
      - FogEnd: Fog end distance from the camera
      - FogColor: vec4 fog color
      - LineWidth: Line width, used for rendering wireframe lines such as the block selection frame and debug hitboxes
      - GameTime: Global time of the world, in fractional days
      - ChunkOffset: When rendering a chunk section, the offset from the camera world position to the chunk section's base point
    - type: The type of the uniform. Can be one of int, float, matrix4x4, matrix3x3 and matrix2x2. int can also be interpreted as ivec2, ivec3 or ivec4 depending on how many values are actually included in values. float can also be interpreted as vec2, vec3 or vec4 depending on how many values are actually included in values.
    - count: The number of values included in values.
    - values: The value of the uniform, given as a list of floats. The length of the list should be the same as count.

Render pipeline

Here's the process of how a post-processing shader is used in game: first, the shader initializes all of the render targets specified in the "targets" list with the proper width and height. After that, the shader goes through each render pass specified in the "passes" list from first in the list to last in the list. Each pass will apply the program shader on the render target specified by "intarget" (with any extra data provided by other auxiliary render targets) and output the end result on the render target specified by "outtarget".

The root tag
- targets: A list of render targets. They can be buffer provided by the game, or new buffer with any name.
  - : The name of a render target. The size defaults to screen resolution.
  - : A render target to add.
    - name: The name of the render target to add.
    - width: The width of the render target.
    - height: The height of the render target.
- passes: A list of passes.
  - : A render pass.
    - name: The name of a program shader to apply on the input and post into the output. Use "blit" to copy the data from intarget to outtarget.
    - intarget: The name of a render target to use as an input. Use minecraft:main to specify the main screen.
    - outtarget: The name of a render target to output to. It should not be the same as intarget. Use minecraft:main to specify the main screen.
    - auxtargets: A list of auxiliary targets.
      - An auxiliary target.
        name: The auxiliary target's name that is passed into the "Program" JSON.
        
        id: The auxiliary target's id. Either points into the name of a buffer that is defined in targets or into the location of a texture under assets/<namespace>/textures/effect (use a namespaced id to reference it).
        
        width: Required if id references a texture. Describes the width of the texture in pixels.
        
        height: Required if id references a texture. Describes the height of the texture in pixels.
        
        bilinear: Required if id references a texture. Determines whether the scaling algorithm used for the image is bilinear or nearest neighbour.
    - uniforms: A list of overrides that change the values in the uniforms list in the "Program" JSON.
      - : A uniform.
        name: The name of the field that should be changed.
        
        values: The values that the field should be changed to.

Tutorials and useful docs

Here are some guides for creating your own shaders:

Bedrock Edition