Introduction

Jot is a programming language based on combinators designed to be able to build up functions, but also to be a language where every string of 1’s and 0’s is systematically turned into a different valid program. (This is different from many languages where technically they could be turned into a string of 1’s an 0’s, like anything else, but most of these would be invalid programs).
​
I haven’t seen either code implementing Jot, nor visualizations of it running, and so I wrote some code to do so. In the final sections I try running each jot program from program 0 to program, and then provide an interface for running / visualizing your own jot programs.

Code

In[]:=
jotSpecific={0[x_]x[s][k],1[x_][a_][b_]x[a[b]]};
In[]:=
skRule={s[x_][y_][z_]x[z][y[z]],k[x_][y_]x};
In[]:=
iRule={i[x_]x};
In[]:=
jotRule=Join[jotSpecific,skRule,iRule]
Out[]=
{0[x_]x[s][k],1[x_][a_][b_]x[a[b]],s[x_][y_][z_]x[z][y[z]],k[x_][y_]x,i[x_]x}
In[]:=
evaluateCombinatorList[init_,rule_,maxIterations_:Infinity]:=​​FixedPointList[ReplaceAll[#,rule]&,init,maxIterations]
In[]:=
jotList[{},___]={""};
In[]:=
jotList[init:{(1|0)..},maxIterations_:Infinity]:=​​evaluateCombinatorList[Fold[#2[#1]&,i,init],jotRule,maxIterations]
In[]:=
jotList[s_String/;StringMatchQ[s,("1"|"0")...],maxIterations_:Infinity]:=​​jotList[Map[ToExpression,Characters[s]],maxIterations]

Testing Jot Programs

In[]:=
jotK="11100";
In[]:=
jotS="11111000";
In[]:=
jotList[jotK]//Column
Out[]=
0[0[1[1[1[i]]]]]
0[1[1[1[i]]]][s][k]
1[1[1[i]]][s][k][s][k]
1[1[i]][s[k]][s][k]
1[i][s[k][s]][k]
i[s[k][s][k]]
s[k][s][k]
k[k][s[k]]
k
k
In[]:=
jotList[jotS]//Column
Out[]=
0[0[0[1[1[1[1[1[i]]]]]]]]
0[0[1[1[1[1[1[i]]]]]]][s][k]
0[1[1[1[1[1[i]]]]]][s][k][s][k]
1[1[1[1[1[i]]]]][s][k][s][k][s][k]
1[1[1[1[i]]]][s[k]][s][k][s][k]
1[1[1[i]]][s[k][s]][k][s][k]
1[1[i]][s[k][s][k]][s][k]
1[i][s[k][s][k][s]][k]
i[s[k][s][k][s][k]]
s[k][s][k][s][k]
k[k][s[k]][s][k]
k[s][k]
s
s
In[]:=
test="1"<>jotK<>"11"<>jotS<>jotK<>jotK<>jotK
Out[]=
1111001111111000111001110011100
In[]:=
jotList[test]//Column
Out[]=

Enumerating Jot Programs

Here’s what the first 16 jot programs do (including the empty string Jot program)
In[]:=
Table[jotList[Rest@IntegerDigits[j,2]],{j,16}]//Column
Out[]=
{}
{0[i],i[s][k],s[k],s[k]}
{1[i],1[i]}
{0[0[i]],0[i][s][k],i[s][k][s][k],s[k][s][k],k[k][s[k]],k,k}
{1[0[i]],1[i[s][k]],1[s[k]],1[s[k]]}
{0[1[i]],1[i][s][k],i[s[k]],s[k],s[k]}
{1[1[i]],1[1[i]]}
{0[0[0[i]]],0[0[i]][s][k],0[i][s][k][s][k],i[s][k][s][k][s][k],s[k][s][k][s][k],k[k][s[k]][s][k],k[s][k],s,s}
{1[0[0[i]]],1[0[i][s][k]],1[i[s][k][s][k]],1[s[k][s][k]],1[k[k][s[k]]],1[k],1[k]}
{0[1[0[i]]],1[0[i]][s][k],0[i][s[k]],i[s][k][s[k]],s[k][s[k]],s[k][s[k]]}
{1[1[0[i]]],1[1[i[s][k]]],1[1[s[k]]],1[1[s[k]]]}
{0[0[1[i]]],0[1[i]][s][k],1[i][s][k][s][k],i[s[k]][s][k],s[k][s][k],k[k][s[k]],k,k}
{1[0[1[i]]],1[1[i][s][k]],1[i[s[k]]],1[s[k]],1[s[k]]}
{0[1[1[i]]],1[1[i]][s][k],1[i][s[k]],1[i][s[k]]}
{1[1[1[i]]],1[1[1[i]]]}
{0[0[0[0[i]]]],0[0[0[i]]][s][k],0[0[i]][s][k][s][k],0[i][s][k][s][k][s][k],i[s][k][s][k][s][k][s][k],s[k][s][k][s][k][s][k],k[k][s[k]][s][k][s][k],k[s][k][s][k],s[s][k],s[s][k]}

Interactive Jot Evaluation Visualizer

Enter your own string here to see Jot visualized
In[]:=
Manipulate[​​jotList[input,maxIterations]//Column,​​{{input,jotK,"Input"},InputField[#,String]&},​​{{maxIterations,20,"Max Iterations"},1,20,1,Appearance->"Open"},​​SaveDefinitions->True]
Out[]=
​
Input
11100
Max Iterations
1
0[0[1[1[1[i]]]]]
0[1[1[1[i]]]][s][k]

Acknowledgements

I would like to thank user Discord user Ykulvaarlk for taking the time to help me to understand how Jot works.

CITE THIS NOTEBOOK

Implementing and visualizing the Jot programming language​
by Eric Parfitt​
Wolfram Community, STAFF PICKS, March 28, 2025
​https://community.wolfram.com/groups/-/m/t/3433677