LYGIA is the biggest shader library. Battle proof, cross platform and multi-language. Is made of reusable functions that will let you prototype, port and ship projects in just few minutes. It's very granular, flexible and efficient. Support multiple shading languages and can easily be added to virtually any project. There are already integrations for almost all mayor enviroments, engines and frameworks.

Best of all, LYGIA grows and improves every day thanks to the support of the community. Become a Contributor or a

In your shader just #include the functions you need and then use them:

#ifdef GL_ES
precision mediump float;
#endif

uniform vec2    u_resolution;
uniform float   u_time;

#include "lygia/space/ratio.glsl"
#include "lygia/math/decimate.glsl"
#include "lygia/draw/circle.glsl"

void main(void) {
    vec3 color = vec3(0.0);
    vec2 st = gl_FragCoord.xy/u_resolution.xy;
    st = ratio(st, u_resolution);
    
    color = vec3(st.x,st.y,abs(sin(u_time)));
    color = decimate(color, 20.);
    color += circle(st, .5, .1);
    
    gl_FragColor = vec4(color, 1.0);
}

If you just need to resovle the dependencies of a shader file you got, the fastest way would be to drag&drop your shader file in the box below. We can resolve the dependencies for you.

LYGIA have been integrated into the following Engines, Frameworks, Creative Tools and online editors:

If you are working on a project and want to use LYGIA, you have two options: cloning a local version that then you can bundle into your project; or using the server ( https://lygia.xyz ) to resolve the dependencies online. How each one works?

If you are working locally in an environment that can resolve #include dependencies, just clone LYGIA into your project relative to the shader you are loading:

    git clone https://github.com/patriciogonzalezvivo/lygia.git

or as a submodule:

    git submodule add https://github.com/patriciogonzalezvivo/lygia.git

or you may clone LYGIA without the git history and reduce the project size (9MB+) with the following command:

    npx degit https://github.com/patriciogonzalezvivo/lygia.git lygia

There is also a npm bundle you could use.

If you are working on web project you may want to resolve the dependencies using a bundler like vite glsl plugin (local bundle), esbuild glsl plugin (local bundle) or webpack glsl plugin (local bundle).

If you are working on a cloud platform (like CodePen or Observable ) you probably want to resolve the dependencies without needing to install anything. For that just add a link to https://lygia.xyz/resolve.js (JS) or https://lygia.xyz/resolve.esm.js (ES6 module):

    <!-- as a JavaScript source -->
    <script src="https://lygia.xyz/resolve.js"></script>

    <!-- Or as a ES6 module -->
    <script type="module">
        import resolveLygia from "https://lygia.xyz/resolve.esm.js"
    </script>

To then resolve the dependencies by passing a string or strings[] to resolveLygia() or resolveLygiaAsync():

    // 1. FIRST

    // Sync resolver, one include at a time
    vertSource = resolveLygia(vertSource);
    fragSource = resolveLygia(fragSource);

    // OR.
    
    // ASync resolver, all includes in parallel calls
    vertSource = resolveLygiaAsync(vertSource);
    fragSource = resolveLygiaAsync(fragSource);
    
    // 2. SECOND

    // Use the resolved source code 
    shdr = createShader(vertSource, fragSource);

This this function can also resolve dependencies to previous versions of LYGIA by using this pattern lygia/vX.X.X/... on you dependency paths. For example:

#include "lygia/v1.0.0/math/decimation.glsl"
#include "lygia/v1.1.0/math/decimation.glsl"

The functions are divided into different categories:

• math/: general math functions and constants: PI, SqrtLength(), etc.
• space/: general spatial operations: scale(), rotate(), etc.
• color/: general color operations: luma(), saturation(), blend modes, palettes, color space conversion, and tonemaps.
• animation/: animation operations: easing
• generative/: generative functions: random(), noise(), etc.
• sdf/: signed distance field functions.
• draw/: drawing functions like digits(), stroke(), fill, etc/.
• sample/: sample operations
• filter/: typical filter operations: different kind of blurs, mean and median filters.
• distort/: distort sampling operations
• lighting/: different lighting models and functions for foward/deferred/raymarching rendering
• geometry/: operation related to geometries: intersections and AABB accelerating structures.
• morphological/: morphological filters: dilation, erosion, alpha and poisson fill.

There are some functions whose behavior can be changed using the #defines keyword before including it. For example, gaussian blurs are usually are done in two passes. By default, these are performed on their 1D version, but if you are interested in using a 2D kernel, all in the same pass, you will need to add the GAUSSIANBLUR_2D keyword this way:

    #define GAUSSIANBLUR_2D
    #include "filter/gaussianBlur.glsl"

    void main(void) {
        ...
        
        vec2 pixel = 1./u_resolution;
        color = gaussianBlur(u_tex0, uv, pixel, 9);
        ...
    }

Learn more about LYGIAS design principles here.

LYGIA has a long way to go. Your support will be appreciated and rewarded! All contributors are automatically added to the commercial license. This support can take multiple forms:

• fixing bugs!
• expanding the cross-compatibility between languages GLSL/HLSL/MSL/WGSL/CUDA
• contributing new functions
• adding new examples and integrations for new environments like: GoDot, ISF, MaxMSP, etc.
• through sponsorships

LYGIA belongs to those that support it. For that it uses a dual-licensed under the Prosperity License and the Patron License for sponsors and contributors.

Sponsors and contributors are automatically added to the Patron License and they can ignore any non-commercial rule of the Prosperity License software.

It's also possible to get a permanent commercial license hooked to a single and specific version of LYGIA.

If you have doubts please reaching out to patriciogonzalezvivo at gmail dot com

Created and mantained by Patricio Gonzalez Vivo( Mastodon | Twitter | Instagram | GitHub ) and every direct or indirect contributors to the GitHub.

This library has been built in many cases on top of the work of brilliant and generous people like: Inigo Quiles, Morgan McGuire, Alan Wolfe, Matt DesLauriers, Bjorn Ottosson, Hugh Kennedy, and many others.

Also is being constantly mantain, translated and/or extended by generous contributors like: Shadi El Hajj, Kathy, Bonsak Schiledrop, Amin Shazrin, Guido Schmidt, and many others.