
Special K: an interactive K compiler that generates GLSL - tosh
http://beyondloom.com/tools/specialk.html
======
tluyben2
Nice work!

For people who don't know this one: another JS based version of k:
[http://johnearnest.github.io/ok/ike/ike.html](http://johnearnest.github.io/ok/ike/ike.html)

(without the glsl)

~~~
RodgerTheGreat
When Special-K is more mature, I'll probably integrate them- oK communicating
with a Special-K shader via uniforms would open up many more interesting
possibilities.

~~~
tluyben2
That would be excellent... I play around with oK quite a bit on my phone.

------
speps
That's just awesome, everyone try the reticulum example!

~~~
shoo
reticulum variation:

    
    
        f:{
          x.z+:((frame + x.x*sin 0.03* frame + x.y*cos 0.2 * frame)*.03); a:x.z^0.94
          x.xy*:mat[cos a;sin a;-sin a;cos a]
          .02-#(cos x.xy)+sin x.yz
        }
        p: 70{x+f[x]*0.5-(pos.xy;340)%size.x}/(0;0;0)
        col:((3;5;1)%#p),1
    
    

Can anyone give a bit of intuition behind the following construction in
reticulum?

    
    
        p:32{x+f[x]*.5-(pos.xy;1)%size.x}/0 0 0
    

It appears to be some kind of fixed-point iterative approximation: we
initialise an accumulator with the zero vec3 (0;0;0) then transform it 32
times by iteratively mapping it by lambda : vec3 -> vec3 where lambda(x) :=
x+f[x]*.5-(pos.xy;1)%size.x

So if we crank up the number of iterations from 32 to 64 or 1000 or whatever
we get a better approximation of the limit, but it looks better -- due to the
fuzzier edges -- after a modest number of iterations. (it also takes a lot
less effort to compute the fewer iterations we do).

~~~
RodgerTheGreat
A few recognizable parts:

    
    
        *.5-(pos.xy;1)%size.x
    

This produces a vec3 of the screen-space coordinates of the fragment, scaled
to a -0.5 to 0.5 range (assuming a square display) and the z component will be
the scaling factor. This also happens to invert the axes, which doesn't
matter.

    
    
        x.xy*:mat[cos a;sin a;-sin a;cos a]
    

This is a standard 2d rotation matrix- rotate the position xy about the origin
by angle a.

Your comment is a good description of the overall algorithm.

------
bjconlan
Wow his is cool. Very nice work! Apl's seem like the perfect fit for this kind
of thing and feels like a great way for people to cut there teeth on something
like k. Hopefully the syntax will become a moot point since 1/2 the code I
love reading are algorithmically terse (and clever)... I hope this gets picked
up by the demo or 'tweetcart' like scenes. Theyre always a source of
inspiration.

------
smabie
I could imagine this being really useful in live coding shader competitions.

------
rbanffy
I wonder if the ungoogleable syntax hurts language adoption.

~~~
chongli
The syntax definitely hurts adoption but I don’t think it’s due to google
unfriendliness. The whole language is very small, so the usual need to google
for documentation doesn’t seem to apply.

The real barrier to adoption is likely the same with most non-mainstream
languages: unpopularity is a vicious cycle, just as popularity is a virtuous
one.

------
BubRoss
Is this meant as a way to practice K? GLSL is not really a difficult language
to program in, it's actually pretty great.

~~~
joan_kode
Sure, GLSL is easy to learn, because it's basically a simplified C, which many
people are already familiar with. It's intentionally bare-bones, verbose and
old school, so that everyone can learn it and every vendor won't get bogged
down writing compilers for it. In that sense, it achieves its purpose well
enough.

But come on, it doesn't even have first-class functions. There are countless
examples of unreadable macros and code duplication out there due to GLSL's
extreme simplicity.

~~~
BubRoss
I have never seen anyone think GLSL needed first class functions. Can you give
me an example of how you would use them instead of a macro? GPUs can't jump to
a function pointer as far as I know and macros can't be passed to functions.

~~~
fulafel
GPUs can jump to function pointers and some GPU languages support them.

Have a look at "4.2 Branching" in
[http://developer.amd.com/wordpress/media/2013/12/AMD_GCN3_In...](http://developer.amd.com/wordpress/media/2013/12/AMD_GCN3_Instruction_Set_Architecture_rev1.1.pdf)

Also, it's possible to compile code using function pointers down to more
limited forms of flow control instructions.

~~~
TazeTSchnitzel
Good luck with performance if it's non-uniform across the warp.

------
suyash
What is K?

~~~
RodgerTheGreat
K is a general-purpose vector-oriented programming language with a concise
syntax. See
[https://en.wikipedia.org/wiki/K_(programming_language)](https://en.wikipedia.org/wiki/K_\(programming_language\)).

Special-K is a subset of the k6 dialect of this language, in part due to the
constrants of GLSL, which retains its concise nature and which should be
intelligible and convenient for those who already know K. For those who do not
yet know K, it may still be a pleasant way to experiment with fragment
shaders.

