I find the Jitter/OpenGL options overwhelming

estevancarlos, my understanding is that [jit.gl.pix] is the only gen object that uses the GPU, much like [jit.gl.slab] - the difference being [jit.gl.pix] compiles the code internally while [jit.gl.slab] reads it from a file. It's not clear to me if there is a performance benefit to either compared to the other. I don't think there is but I vaguely recall that compiling it makes it bit faster than slab. Either way.. it's easier for me to build stuff in Gen than straight GLSL (openGL shader code) so I prefer [jit.gl.pix].

Regarding the relationship between jitter and GL. Standard Jitter uses the CPU and GL uses the GPU. Jitter also operates upon matrices (hence the term MOP objects... "matrix operator objects") while jit.gen/pix *generates* MOP objects. That is, when coding and patching within gen/pix, you don't think of the code as operating upon a matrix as much as it is defining the functionality of something that will. The main differences being, you can't access arrays or dynamically change dimensions, data types, etc. when patching inside gen. The compiled result is something that operates on a given input, but you need to define that matrix and access individual elements of that matrix elsewhere.

It's also worth noting that the benefits of using [jit.gl.pix] usually entail staying within the GPU domain as long as possible. Going back and forth between the GPU and CPU can be expensive so it's good to plan things out, get all of your matrices prepped for the journey to the GPU and only bring it back to the CPU as needed. Hope that helps. I'm only just starting getting the hang of it.

Metamax, you're obviously pretty on it with jit.gl.pix - I've found your posts on it really informative and clear. It's something I've been a little timid in getting into, mainly because there doesn't seem to be much in the way of documentation. Would you have any pointers you could give to find the way in?

Hi Joseph.
Heres a link to a wiki page i made ( but never finished due to being a code noob)
https://cycling74.com/wiki/index.php?title=Porting_Shadertoy_tutorials_to_jit.gl.pix
It translates basic shadertoys tutorials into jit.gl.pix.
Was a great way for me to learn the basics.
Hope it helps !

I did see that Andro - it's definitely on my 'to do' list. Thanks for doing that, and thanks for the reminder!

johyde, check out the Joy of Swiz and read all of the reference docs. There isn't much available but it's a good start. I agree with Sandro about porting shaders. That's what I have been doing and it has helped me understand some basics. Learning how shaders work from the GL side of things is good too.

andro, I finished 27 of those tuts (I couldn't figure out one of them). I'll dig them up and post them. And I ported a boatload of other shaders... some are really nice. I don't know how the hell I did it. Anyway, I must have 50+ of them. I like the wiki, but we should also get a new thread started and flood it with shader examples to encourage more discussion.

edit: .... examples of from sources other than shadertoy as well...

Thanks Metamax. I think I fundamentally don't understand shaders in some way - not so much the code but the concepts - the whole pipeline thing. Don't know why, but it's been a bit of a 'block' for me. I'll give it another go though - Christmas break ahead of me, and some nice starting points here. Having a go at porting something sounds like a good way to start. Yes, do post the ones you did if you get a chance!

Hey Johyde, you can check my tutorials on jit.gl.pix and jit.gen on my youtube channel: https://www.youtube.com/channel/UCvDUaH2fbXP_Yc5Lc9UXfqA
Basically there are three types of shaders: vertex, fragment and geometry (you don't see the last one so often though).
jit.gl.slab requires both vertex and fragment shaders, while jit.gl.pix is basically the gen way to write a fragment shader.
The vertex shaders work with, well, vertices. So if you apply a jit.gl.slab shader to a jit.gl.gridshape you can modify the shape of the object working on each vertex at a time. The fragment shader works out the final color of the shape or the image (if you're working with a jit.gl.videoplane).
It's important to get that when working with a fragment shader you're working with one pixel at a time. Your shader program will be applied to any pixel in a parallel way (the gpu is made to work in parallel using multiple cores).
Regarding the pipeline: it works like a server-client thing. The cpu is the client, the gpu is the server. You transfer instructions from the client to the server, which executes them. The slower part, as said, is the transferring of data between the cpu and the gpu.
When you use shaders, you modify the fixed pipeline to render things the way you want. And you can do that for any shape on your patch. The jit.gl.pix object can just create textures though.

federicofod, great stuff! Thank you for sharing. I will be sure to check out your videos.

johyde, I still find shaders mysterious and have only recently become a bit obsessed with them. I'll post what I have. I just need to clean them up a bit.

Thanks for the response @metamax and thanks for those tutorials @FEDERICOFOD. I've noticed you sharing them on facebook. They're great. I'm reading an ebook on GLSL as I type this. As well as looking through the provided materials in Max. What I find overwhelming (and maybe I should get over it) is some of these file formats and different language styles that all relate to OpenGL. I probably just need to accept the way it is and continue studying. However I'm looking at *.jitmtl, *.glsl, *.jxs, *.jxp and that doesn't even include jit.gen.

I understand what jitmtl does. I sort of understand what jxs does. I'm completely unfamiliar with jxp. So many different things here.