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, supports multiple shading languages and can easily be added to virtually any project. There are already integrations for almost all major environments, engines and frameworks.
#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);
}
LYGIA Shader Library
If you are working on a project and want to use LYGIA, you have two options: cloning a local version that you can bundle into your project; or using the server ( https://lygia.xyz ) to resolve the dependencies online.
LYGIA Locally
If you want to work locally, you must ensure that your environment can resolve #include dependencies. You can find some examples in here specifically for GLSL. Then you just need to clone LYGIA into your project relative to the shader you are loading:
If you are concerned about the size of the library you might also be interested on pruning the library to only the language you are using. You can do that by using the prune.py script. For example:
python prune.py --all --keep glsl
Alternatively, if you are working on a npm project, there is a npm bundle you could use.
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 JavaScript source -->
<script src="https://lygia.xyz/resolve.js"></script>
<!-- Or as an ES6 module -->
<script type="module">
import resolveLygia from "https://lygia.xyz/resolve.esm.js"
</script>
Then you can 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 function can also resolve dependencies to previous versions of LYGIA by using this pattern lygia/vX.X/... or lygia/vX.X.X/... on you dependency paths. For example:
LYGIA is designed to be very granular (each file holds one function), multi-language (each language has its own file extension) and flexible. Flexible how?
There are some functions whose behavior can be changed using the #define keyword before including them. For example, gaussian blurs are usually 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, as follows:
LYGIA has a long way to go and welcomes all kinds of contributions. You can help by:
Bug fixing
Translation, keeping parity between languages (GLSL, HLSL, MSL, WGSL, TSL, CUDA, OSL, etc.) is a big part of the challenge. Not all languages are the same and we want to make sure each function is optimized and carefully crafted for each environment. This means, the more eyes are looking at this, the better. Please make sure to read and understand the Design Principles before starting.
New functions or improving the current implementations. Please take a look to the Contribution Guidelines before starting.
Documentation. Each function has a header with some information describing the function. Make sure to fill this information when adding a new function.
Adding new examples and integrations for new environments like: Godot, ISF, MaxMSP, etc.
Financialsponsorships. Right now, the money that flows in is invested on the server and infrastructure. Long term plan will be to be able to pay lead contributors and maintainers.
Collaborators and sponsors are automatically added to the commercial license. Making a PR or subscribing to the GitHub sponsors program is the shortest path to get access to the commercial license. It's all automated, not red taping. LYGIA belongs to those that take care of it.
