JPEG XL

This channel is for artistic small jxl files. Please provide the .jxl and a png/jpg for convenience of viewing (since discord does not support jxl... yet).

If it is a MA-tree-only image created with `jxl_from_tree`, please also share the tree.

Has anyone tried the jxl_from_tree toy already?

If you write a https://github.com/sipa/gramtropy grammar for it, we could try randomly generating some of limited size.

I'll try to find some time.

Not sure if the typical random tree does anything interesting

But could generate a bunch of images and sort by png size

Boring images are small pngs or very large ones (too noise-like to look nice)

OK, I'll start with my first image in the allrgb.com fashion, but never published there. Created in 2014, converted today. I hope it meets the expectation. 🙂

Not bad

But what about a tree-only version of an all-rgb image (or something close to it, the current jxl_from_tree produces only 1024x1024 images)

If I wanted to study the MA-trees, where should I start? 😇

in `tools/example_tree.txt`

``` if y > 0 if x > 0 if c > 1 if N > 253 - Set 0 - N + 2 if c > 0 if W+N-NW > 253 - Set 0 - AvgW+N + 1 if W > 253 - Set 0 - W + 2 - Set 0 - Set 0 ```

```if c > 1 if N > 125 - Set 0 if W > 125 - Set 0 - AvgW+NW + 1 if y > 400 if N > 0 if WGH > 0 if N-NE > 0 - Set 0 - Set 128 if N-NE > 0 - Set 64 - Set 0 if NW-N > 0 if N-NE > -1 - Set 255 - Set 0 if N-NE > -1 - Set 0 - Set 255 if c > 0 if x > 0 if W > 253 - Set 0 if y > 100 if y > 270 - W + 1 if N > 252 - Set 0 - N + 3 - W + 1 - Set 0 if x > 511 - Set 200 - Set 0 ```

```if c > 1 if W > 10 - W - 1 - Set 200 if N > 224 - Set 32 if N > 16 if W > 224 - Set 32 if W > 16 - AvgAll + 1 if c > 0 - Set 192 - Set 180 - Set 192 ```

```if N > 224 - Set 32 if N > 16 if W > 224 - AvgW+N - 1 if W > 16 - AvgAll + 1 if c > 1 - Set 192 if c > 0 - AvgW+N + 0 - Set 230 - AvgW+N + 1 ```

It reminds me of 64K demos

64k is a very big for this, I think closer would be 32-256 bytes demos <https://youtu.be/O-WjF_dxdHM?t=1233> <https://youtu.be/Imquk_3oFf4> And for example 64k demos: <https://youtu.be/QhqT0DhV9yE> <https://youtu.be/UnjIMd3kVf4> <https://youtu.be/JZ6ZzJeWgpY> <https://youtu.be/MAnhcUNHRW0>

The main difference is that for a jxl 'demo', you don't get a compact Turing complete language (machine code) plus whatever platform-specific things that can be just used, but only a restricted, non-Turing complete language (a jxl bitstream).

Yep, that's what I mean, for a demo in 64k this is not a challenge, where people make mini movies and possibilities are not so limited, usually kinds of effects and procedural generation are in competitions with a much smaller size

```#!/bin/bash for i in $(seq -3 3); do for j in $(seq -3 3); do for k in $(seq -3 3); do cat > jxlart-$i-$j-$k-tree.txt <<EOF if W > 200 - Set 10 if W > 20 if WGH > -4 if WGH > 1 - AvgW+N $i - AvgN+NW $j - Select $k if c > 1 - W + 100 if c > 0 - W + 110 - W + 120 EOF ./jxl_from_tree jxlart-$i-$j-$k-tree.txt jxlart-$i-$j-$k.jxl djxl jxlart-$i-$j-$k.jxl jxlart-$i-$j-$k.png done done done ```

these are all 47-50 byte .jxl files made by the above script (same tree structure, just changing the offsets a bit)

https://tenor.com/view/wow-phenomenal-amazing-great-gif-5981661

``` if W+N-NW > 130 - Set 0 if N-NE > 20 - Set 254 - W + 1 ```

"Infinite Aquaducts"

only 34 bytes

impressive

```if y > 50 if N > 240 - Set 240 if N > 10 if N-NN > 0 - N + 1 if c > 1 - N - 2 - N - 1 - N + 1 if W > 240 - Set 240 if W > 10 if W-WW > 0 if c > 0 - W + 5 - W + 4 - W - 2 - W + 1 ```

"Rainbow Plasma"

This is like a cheap shader coding comp

I love this

Anyone else been playing with the jxl_from_tree toy?

This one is similar to some allrgb images. Beautiful!

```if y > 100 if N > 20 if x > 511 - AvgN+NW - 1 - AvgN+NE - 1 - Set 200 if W > 240 - Set 240 if W > 10 if W-WW > 0 if c > 0 if c > 1 - W + 3 - W + 5 - W + 4 - W - 2 - W + 1 ```

JXL live on stage

```if N-NN > -1 if W > 250 - Set 250 if W > 2 if W-WW > -1 - AvgN+NE + 1 - W - 3 - Set 3 if N > 6 - AvgN+NW - 1 - Set 0 ```

there's something satisfying about this one

I can't put my finger on it but it feels like some kind of weird cave full of stalactites

This one actually looks pretty natural-like

```if c > 1 if N > 20 - N - 20 - Set 140 if N-NN > -1 if W > 220 - Set 220 if W > 2 if W-WW > -1 - AvgN+NE + 1 - W - 3 - Set 3 if N > 6 - AvgN+NW - 1 - Set 0 ```

A variation on the above

```if y > 400 if N-NN > 0 - AvgAll + 0 if N > 20 - AvgN+NE - 1 - N + 150 if y > 0 if y > 200 if W > 50 - W - 2 if c > 0 if c > 1 - Set 232 - Set 214 - Set 250 if c > 0 - N - 1 - N + 1 if c > 0 if c > 1 - Set 250 - Set 200 - Set 0 ```

"Sunset over the strawberry fields, forever"

If this utility had been a little more user friendly, I think Fabian would have reached good results with it by changing a lot of random numbers

```if y > 200 if WGH > -240 if WGH > 240 - AvgAll + 0 - Gradient + 0 if W > 120 - W - 110 - W + 110 if y > 20 if N-NN > 0 - AvgAll + 0 if N > 20 - AvgN+NE - 1 - N + 150 if W > 50 - W - 2 if c > 0 if c > 1 - Set 235 - Set 220 - Set 250 ```

weighted predictor shows its colors, huh? 😄

what's not very user-friendly about it?

For the casual user it is not very clear how to use this utility, what combinations and what are the limits of values, etc.

what would make it clearer?

about the combination, I'd say that finding out is kinda the point 😛 about the limits - usually 0-255 but depending on the tree you make it might require less than that, I don't think anybody knows 😄

I wonder would it be possible to crossbreed these images Puppy Farmer style? (http://www.pouet.net/prod.php?which=59302)

IDK what Puppy Farmer style implies, but you could technically swap nodes between trees. Doing it randomly wouldn't be very efficient because you're likely to produce unsupported structures.

not really art, but maybe a useful test image

```if c > 1 if y > 0 if y > 255 if y > 256 if y > 511 if y > 512 if y > 767 if y > 768 - N + 0 - N + 64 - N + 0 - N + 64 - N + 0 - N + 64 - N + 0 if x > 255 if x > 511 if x > 767 - Set 48 - Set 32 - Set 16 - Set 0 if c > 0 if y > 0 if N > 254 - Set 0 - N + 1 - Set 0 if x > 0 if W > 254 - Set 0 - W + 1 - Set 0 - Set 0 ```

this looks like 3D LUT templates

``` if y > 915 if x > 940 if c > 1 - Set 0 - Set 255 if x > 900 - Set 0 if x > 250 - Set 255 if x > 220 - Set 0 if c > 1 - Set 255 - Set 0 if y > 865 if x > 900 - Set 0 if x > 250 - Set 255 if x > 220 - Set 0 if c > 1 - Set 255 - Set 0 if y > 765 if x > 940 - Set 255 if x > 900 - Set 0 if x > 250 - Set 255 if x > 220 - Set 0 if c > 1 - Set 255 - Set 0 if y > 730 - Set 0 if y > 365 if x > 250 if c > 0 - Set 0 - Set 255 if x > 220 - Set 0 - Set 255 if y > 305 if x > 250 if c > 0 - Set 0 - Set 255 - Set 0 if x > 250 if c > 0 - Set 0 - Set 255 if x > 220 - Set 0 - Set 255 ```

adding ``` if W > 100 - W - 5 ``` at the top of the above

``` if y > 0 if N > 0 if NW-N > -1 if N-NE > 0 - Set 0 - Set 255 if N-NE > 0 if c > 0 - Set 255 - Set 0 - Set 0 if NW-N > 0 if N-NE > -1 - Set 255 - Set 0 if N-NE > -1 - Set 0 - Set 255 if c > 1 if x > 800 - Set 255 - Set 0 if x > 510 if x > 512 - Set 0 - Set 255 - Set 0 ```

Ok this one is my favorite so far

```if y > 0 if N > 0 if y > 600 if c > 1 if N > 30 - N - 10 - N - 1 if x > 511 - AvgN+NW + 0 - AvgN+NE + 0 if NW-N > -1 if N-NE > 0 - Set 0 - N + 0 if N-NE > 0 - N + 0 - Set 0 if NW-N > 0 if N-NE > -1 - NW + 0 - Set 0 if N-NE > -1 - Set 0 if c > 0 if c > 1 - Set 200 - Set 150 - Set 255 if x > 200 if x > 511 if x > 800 - Set 1 if c > 0 - Set 0 - Set 2 - Set 1 - Set 0 ```

This gives some proper synthwave vibes, especially the lower half

This piece is called "EEG at the base of Mount Sierpinski"

Is there a cheat sheet for this tool ?

tools/example_tree.txt is the cheat sheet

How can I compile this thing? ```ziemekz@ZiemekLaptop:~/jpeg-xl$ gcc tools/jxl_from_tree.cc -o build/tools/jxl_from_tree tools/jxl_from_tree.cc:21:10: fatal error: lib/jxl/base/file_io.h: No such file or directory 21 | #include "lib/jxl/base/file_io.h" | ^~~~~~~~~~~~~~~~~~~~~~~~ compilation terminated.```

It should be compiled together with cjxl and djxl and all the rest

```ziemekz@ZiemekLaptop:~/jpeg-xl/build/tools$ ls CMakeFiles box djxl CTestTestfile.cmake cjxl libcjxltool.a Makefile cjxl_auto.sh libdjxltool.a benchmark_xl cmake_install.cmake libjxl_tool.a```

yeah I already found this but idk what all of this means ``` List of properties: c, g, y, x, |N|, |W|, N, W, W-WW-NW+NWW, W+N-NW, W-NW, NW-N, N-NE, N-NN, W-WW, WGH List of predictors: Set, W, N, AvgW+N, Select, Gradient, Weighted, NE, NW, WW, AvgW+NW, AvgN+NW, AvgN+NE, AvgAll ```

Just do the usual build process and you should find it in build/tools

Ah yes what it means is not really documented anywhere except in the code and in the spec

c is channel (0=R, 1=B, 2=B)

g is not useful with this tool atm

I did the same process as usual (the one from GitLab): ```git clone https://gitlab.com/wg1/jpeg-xl.git --recursive cd jpeg-xl mkdir build cd build cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF .. cmake --build . -- -j$(nproc)```

x and y are pixel coords

``` git clone https://gitlab.com/wg1/jpeg-xl.git --recursive cd jpeg-xl ./deps.sh ./ci.sh release ```

N and W are the values of the pixel above (north) and to the left (west)

You can only do tests of the form [property] > some_value

Do I really need to do `./deps.sh` if I `git clone`'d that thing with `--recursive`?

idk I just do it

no

> Important: If you downloaded a zip file or tarball from the web interface you > won't get the needed submodules and the code will not compile. You can download these external dependencies from source running `./deps.sh`.

I think I just cloned it without `--recursive`

also, you need to enable dev tools for jxl_from_tree

Decision nodes are of the form ``` if [property] > value (THEN BRANCH) (ELSE BRANCH) ```

Leaf nodes are of the form ``` - [predictor] +-offset ```

What is the difference between `|N|` and `N` ?

does it work with 0,3,6

also `WGH` ?

|N| is abs val of N, which in this case is not useful (it is useful for non-RGB / after RCT / squeeze residuals though)

and this monster `W-WW-NW+NWW`

West-WestWest-NorthWest+NorthWestWest

WGH is the signed max-absval-error of the weighted predictor

That's basically the error of the gradient predictor for the previous pixel

ok so to resume List of properties: `c, g, y, x, |N|, |W|, N, W, W-WW-NW+NWW, W+N-NW, W-NW, NW-N, N-NE, N-NN, W-WW, WGH` List of predictors: `Set, Select, Gradient, Weighted, W, N, NE, NW, WW, AvgW+N, AvgW+NW, AvgN+NW, AvgN+NE, AvgAll` c is channel (0=R, 1=G, 2=B) g is not useful with this tool atm x and y are pixel coords N and W are the values of the pixel above (north) and to the left (west) |N| is abs val of N, which in this case is not useful (it is useful for non-RGB / after RCT / squeeze residuals though) WGH is the signed max-absval-error of the weighted predictor W-WW-NW+NWW is basically the error of the gradient predictor for the previous pixel You can only do tests of the form `[property] > some_value` Decision nodes are of the form ``` if [property] > value (THEN BRANCH) (ELSE BRANCH) ``` Leaf nodes are of the form ``` - [predictor] +-offset ```

Thanks!

Wouldn't hurt to pin that for curious others.

How do I do that?

add `-DJPEGXL_ENABLE_DEVTOOLS=ON`

At least, that's what got it to build in 0.3.5.

I usually build with `./ci.sh opt`

I think that enables devtools by default, at least I don't think I had to do anything to enable it

```if x > 940 if y > 915 if c > 1 - Set 0 - Set 255 if y > 865 - Set 0 if y > 765 - Set 255 if y > 730 - Set 0 if c > 0 - Set 0 - Set 255 if x > 900 if y > 730 - Set 0 if c > 0 - Set 0 - Set 255 if x > 250 if y > 765 - Set 255 if y > 730 - Set 0 if c > 0 - Set 0 - Set 255 if x > 220 - Set 0 if y > 765 if c > 1 - Set 255 - Set 0 if y > 730 - Set 0 if y > 365 - Set 255 if y > 305 - Set 0 - Set 255```

88 byte version

Thanks, it worked perfectly! 😃

Changing the main traversal direction from vertical to horizontal, good catch.

``` if y > 0 if N > 0 if y > 600 - AvgN+NE + 0 if NW-N > -1 if N-NE > 0 - Set 0 - N + 0 if N-NE > 0 - N + 0 - Set 0 if NW-N > 0 if N-NE > -1 - NW + 0 - Set 0 if N-NE > -1 - Set 0 if c > 0 if c > 1 - Set 255 - Set 180 - Set 255 if x > 600 - Set 0 if c > 1 - Set 220 - Set 255 ```

ok I'm trying to get a hang of this but I feel so dumb, how would I make a gradient

just a vertical one

"The Lighthouse of Mt. Sierpinski"

oh this is nice

The bottom part inspired by my LSD dice, eh? 😉

``` if c > 0 - Set y + 1 - Set 0 ``` ``` terminate called after throwing an instance of 'std::invalid_argument' what(): stoi Aborted (core dumped) ```

set only eats integers i guess

Yes

in the example there is this ``` if W > 200 - Set 0 - AvgW+NW + 1 ```

omg

nvm

It's a bit finicky and tricky

Have to avoid out-of-range values and stuff

`Set` is just a fun name for the zero predictor, and the + for positive offsets is optional

ok this compiles but I guess does nothing ``` if c > 1 if N > 255 - N + 1 - Set 0 - Set 0 ```

That gives an instant out of range

oh wait yes it does

its a start

with the last set as 200

It's a start, now turn it into art

we should make some website where people can upload those 😄 and maybe vote too

compile to webasm

Yes. At some point I will also want more features for jxl_from_tree, like multiple groups / adjustable group size / prevchannel properties / doing stuff in XYB / throwing a default squeeze or palette transform into the mix

Something like this https://codepen.io/skal65535/project/full/ZwnQWM (but even better with an online encoder)

or an RCT for that matter

unfortunately my web devving is extremely out of date, I last did something web-based like 7 years ago xD

Well, you can do 88 bytes "vertically" as well. And you can go smaller, I was just being lazy after trying the first one. (edit: got it down just 77 bytes just now)

Oh and choosing the bit depth would also be nice. 10-bit allows slower gradients, and less than 8-bit allows smaller files because the constants in the tree get shorter

Anyway even just what is there currently is far from well-explored. It is a big space, and nobody really knows what gems are hidden in it.

I can't decode this one

What was the input?

There are plenty of ways to make invalid input.

``` if c > 0 - Set 0 if c > 1 if x > 200 if y > 200 - Set 200 - Set 0 - Set 0 - Set 200 ```

I feel like I am mentally regressing when using this tool

third line

`if c > 1` ?

if green ?

that's the 'else' after checking if c > 0

so uhhh, if red set 0 then if green do stuff

looks like you're trying to do stuff on the blue channel rather

I am so confused

well, just move line two to the end for now

then you'll at least have output

oohhhh

i'm dumb

omg

thanks

for real

I can do assembly, I was paid to work on old computers to reverse engineer old programs, but this is my limit

a 2d shader esolang toy

This is a true masterpiece. Decode it yourself, it's a surprise. ```if y > 825 if x > 525 - Set 255 if x > 500 - Set 0 - Set 255 if y > 800 if x > 845 - Set 255 if x > 655 - Set 0 if x > 525 - Set 255 if x > 500 - Set 0 if x > 345 - Set 255 if x > 320 - Set 0 if x > 180 - Set 255 if x > 155 - Set 0 - Set 255 if y > 525 if x > 680 - Set 255 if x > 655 - Set 0 if x > 525 - Set 255 if x > 500 - Set 0 if x > 345 - Set 255 if x > 320 - Set 0 if x > 180 - Set 255 if x > 155 - Set 0 - Set 255 if y > 500 - Set 0 if y > 185 if x > 845 - Set 255 if x > 820 - Set 0 if x > 680 - Set 255 if x > 655 - Set 0 if x > 525 - Set 255 if x > 500 - Set 0 if x > 180 - Set 255 if x > 155 - Set 0 - Set 255 if x > 525 - Set 255 if x > 500 - Set 0 - Set 255```

I knew it

good meme

I don't know that meme

your loss

``` if y > 0 if N > 1 if y > 511 - AvgN+NE - 1 if NW-N > -1 if N-NE > 0 - Set 0 - N + 0 if N-NE > 0 - Set 0 - N + 0 if NW-N > 0 if N-NE > -1 if NW-N > 2 - NW - 3 - NW - 1 - Set 0 if N-NE > -1 - Set 0 if c > 0 if c > 1 - Set 250 - Set 240 - Set 255 if x > 511 if x > 512 - Set 0 - Set 255 - Set 0 ```

67 bytes

"The Sierpinski Instability"

now do that without the `y > 511` 😛

(I don't think you can)

Then you get something like that

Does JXL support layers that are larger than the image canvas?

Yes

So you could just crop the image without affecting the file size?

Yes, well it would add maybe 4 bytes to signal that there's a crop

I mean get the same image but without "cheating" and changing trees midway 😛

Oh

It might be possible, for now I am basically just doing an effectively binary cellular automaton and then switch at row 512, but there must be automata with more values that do cooler stuff (without having to use x/y)

'Ever Given' 2021, Jon Sneyers, image/jxl, 85 bytes

``` if c > 1 if y > 0 if N > 50 if N > 180 - Set 180 if N-NN > 0 - N + 6 - N - 6 - Set 51 if W > 50 if W > 180 - Set 180 if W-WW > 0 - W + 3 - W - 3 - Set 51 if x > 300 if x > 700 - Set 220 if y > 200 if y > 800 - N + 0 if x > 301 - NW + 0 if y > 400 - Set 50 if c > 0 - Set 180 - Set 30 - Set 50 - Set 220 ```

Can we also have this channel blocked until evergreen is removed? <:whatisthis:672847617796997165>

Ever Given

what organization need take on responsible for evergreen stuck?

<@794205442175402004> Is there documentation for the jxl-from-tree file format somewhere?

The pinned message here is the best documentation for now :)

(if someone feels like writing something in more detail, I'm not going to stop them... :P)

How do the image dimensions get decided?

Ah, fixed 1024x1024 ?

yep, at least for now

What are Set and Select?

Set is setting it to a constant, I assume?

yes

Select is I think Top or Left depending on some condition I don't fully recall

Decision nodes are of the form: if [property] > [value:int] (THEN BRANCH) (ELSE BRANCH) Leaf nodes are of the form; - [predictor] +-[offset:int] List of properties: - c: the channel number (0=R, 1=G, 2=B) - g: group id, not useful (jxl_from_tree makes a single-group image) - x, y: coordinates - |N|, |W| : not useful (only useful after transforms) - N: pixel above (north) - W: pixel to the left (west) - W-WW-NW+NWW: basically the error of the gradient predictor for the pixel on the left - W+N-NW: value of gradient predictor (before clamping) - W-NW: left minus topleft, i.e. error of the N predictor for the pixel on the left - NW-N: topleft minus top, i.e. error of W predictor for the pixel above - N-NE: top minus topright, i.e. error of W predictor for pixel on top right - N-NN: top minus toptop, i.e. error of N predictor for pixel above - W-WW: left minus leftleft, i.e. error of W predictor for the pixel on the left - WGH: signed max-absval-error of the weighted predictor List of predictors: - Set: always predicts zero, so effectively sets the pixel value to [offset] - W: value of pixel on the left - N: value of pixel above - NW: value of topleft pixel - NE: value of topright pixel - WW: value of pixel to the left of the pixel on the left - Select: predictor from lossless WebP - Gradient: W+N-NW, clamped to min(W,N)..max(W,N) - Weighted: weighted sum of 4 self-correcting subpredictors based on their past performance (warning: not clamped so can get out of range) - AvgW+N, AvgW+NW, AvgN+NW, AvgN+NE: average of two pixel values - AvgAll: weighted sum of various pixels: `(6 * top - 2 * toptop + 7 * left + 1 * leftleft + 1 * toprightright + 3 * topright + 8) / 16` Edge cases: If x=y=0, W is set to 0. Otherwise, if x=0, W is set to N. If y=0, N is set to W. If x=0 or y=0, NW is set to W. Similarly, NE and NN fall back to N and WW falls back to W.

1024x1024 is the largest group size for modular, so it is a natural choice. Groups share the tree (but the tree can take group id into account), but they do not look at each other (so can be decoded in parallel), so predictors and properties get their edge cases on the group edges, not only on the image edges.

``` if N > 0 - Set 0 - Set 255 ```

Why does this generate a checkerboard?

I’d have expected alternating lines

nvm, just saw the edge case

> If y=0, N is set to W.

Okay fine I’ll admit this is _really_ fun

Yes, the edge cases can really influence the whole image. Easiest way to get rid of them is start with `if x > 0 if y > 0`

we can make this twice as much fun by adding the LZ77 -- that would allow 'surgical' insertions of pixels into or creating patterns through a combo of LZ77 and contexts

and triple as much fun by building this with the palette coding

We can predict (delta) palette codes through context trees by basing the decisions of the palette index by surrounding palette indices

this means that it gives a cross-color-channel context and prediction, and we can even have the same color on different indices contributing to different contexts

I believe it allows things like creating arbitrary sprite graphics, fonts, etc. -- only limited by the maximum palette size (IIRC, 32k colors)

and from there we can make it four times as much fun by using patches on top of all of this, where the patches file is also synthesized by all these methods

and finally five times as much fun by composing the image of multiple layers each alpha blended with a (low-frequency coded) mask

...

I think the actually useful way to build practical low-bpp images would include color quantization and then building state machines with contexts and replicated pixels in the palette

there is no real limit on palette size 🙂

but adding a palette might be a lot more complex than it is worth - likely better use of our time to add color transforms, squeeze, and especially previous-channel-properties (which also allow doing fun things with colours)

LZ77 is also probably a bit more complex...

the palette is also coded as an jxl image and can have contexts 🙂 ?

i recently made a 32 byte intro -> https://www.pouet.net/prod.php?which=88205

so a person from the sizecoding community i'm interested to learn more

For those interested, here are more 128/256 byte intros by myself and my girlfriend (DOS mostly and a few TIC80)

https://www.pouet.net/groups.php?which=14389

i'm interested to know if i can do a calculation for a SET command

yep - but it might be nontrivial to specify how to define it 🙂

not for SET, you can just do constants with that. but you can do 'W+1' or things like that

i cannot set a variable correct?

nope, no variables

does the palette have to be a one dimensional image (like I did in WebP lossless) -- or is it allowed to be two dimensional?

pretty sure it's one-dimensional

``` Set y + 1``` -> is there anywhere i can read up on how much this logic can be stretched? say set x^y for example or x*y

you can only add or subtract

read the pin

sh*t, its going to be hard to do non-sirpinksi like stuff 😄

and y is not a predictor

the palette is a nb_colors x nb_channels image, e.g. 100x3 for an RGB palette - but you can also do RGBA palettes, or a CMYKOGV+alpha+depth+temperature palette for that matter, which would be 10 rows high 🙂

the math you can do is quite limited, but I think there might be ways to get further by using prev-channel properties and/or multi-layer images, which would allow you to use layers as "scratch space" for calculations, and then with blending you can do multiplications and other kinds of less trivial things

really shame no calculations for SET are possible, but i wss thinking along these lines as wel;l by possible storing sinustables with different phases in layers and doing an animated plasma effect

(it was the only thing i could think of with my limited knowledge of JXL)

Animation could also be nice, yes. Sadly trees cannot be shared between frames, but if the tree is small enough, it may be ok to re-encode it per frame

or could also do a hidden huge layer that contains all the frames, and then use Patches to blit parts of it to each frame

I see <@!436097739391107072> jumped onto the server as well, lets see if he can think of a way of doing interesting stuff

`jxl_from_tree` only gives a small sandbox playground of a single-group 1024x1024 image without any transforms

a lot more would be possible in a 256-byte jxl bitstream

Yep, i was curious when i saw some sierpinski in just a few bytes. For Msdos, sierpinski would be 10 bytes, and the dragon fractal 16 bytes (see for example here : https://www.pouet.net/prod.php?which=68474 ) I'm just wondering if the "instruction set" is not too limited for demoish effects 😉

Whoops sorry, the sierpinski isn't in there -> https://codegolf.stackexchange.com/questions/6281/draw-a-sierpinski-triangle/95479#95479

it's certainly a very different "instruction set" compared to the more usual ones

math is restricted, and there's no looping, just the implicit looping over the image

but when also using transforms like Squeeze, interesting things can likely be done

(Squeeze is a modified Haar transform that turns an image into a pyramid, encoding a 'zoomed out' image first, and residuals later - doing cellular automata on that would likely allow interesting fractals)

How would i go on and create code for this? Is there an online playground to test out things?

``` if x > 1 if W > 254 - Set 200 - W + 1 - Set 0 ``` Aha! I did it! a gradient, I have no idea of what going on on the right tho

Online playground: no, unless someone with more frontend skills than me can make an emscripten build of jxl_from_tree and put it online somewhere

But how do people do it right now?

Compile and run jxl_from_tree

``` git clone https://gitlab.com/wg1/jpeg-xl.git --recursive cd jpeg-xl ./ci.sh opt cd build/tools ./jxl_from_tree ../../tools/example_tree.txt example.jxl ./djxl example.jxl example.png ```

Something like that should work (going by memory so there might be a typo here or there)

Compiled version for Windows

After doing the 0 to 255 gradient, it keeps going from 200 to 255

Ohh

``` if x > 1 if W > 0 if W > 254 - Set 255 if W-WW > 0 - W + 1 - W - 1 - Set 1 - Set 0 ```

Try something like that

neat

`if W-WW > 0` that's if W > WW ?

Yes

ok cause you describe it as `left minus leftleft, i.e. error of W predictor for the pixel on the left`

on the left, simple easy explanation, on the right confusing

Yes, the "i.e." part is probably more confusing than helpful

Just to check, is this right ? ``` if c > 1 bluestuff if c > 0 greenstuff redstuff ```

The 'waves' in the B channel are just a vertical oscillating gradient, initialized with a horizontal oscillating gradient.

Yes

I sometimes write it as ``` if c > 0 if c > 1 bluestuff greenstuff redstuff ```

oh nice

ok

The tool doesn't care about indentation or whitespace in general

<:hypers:714771549374251039>

If you vary the gradient range or speed per channel, it also gives a fun effect since they don't stay in sync then

I run it through this Makefile: ``` watch: while inotifywait -e close_write source.txt; do make build; done build: source.txt clear jxl_from_tree source.txt source.jxl djxl source.jxl output.png ``` Then I open VSCode, `source.txt` to the left pane, `output.png` to right pane and I have live preview

Nice!

Do not forget to share examples if you find a nice tree!

https://c.tenor.com/I_-KjeRZFggAAAAM/flowers-tree.gif

you could likely also use https://github.com/gittup/tup with a Tupfile like this: ``` : source.txt |> jxl_from_tree %f %o |> source.jxl : source.jxl |> djxl %f %o |> output.png ``` and then `tup monitor -a -f`

can also make it work for all .txt in the directory with: ``` : foreach *.txt |> jxl_from_tree %f %o |> %B.jxl {jxls} : foreach {jxls} |> djxl %f %o |> %B.png ```

```if y > 768 if c > 1 - N - 1 if c > 0 - Set 0 - N + 1 if y > 513 if c > 1 - N + 1 if c > 0 - N - 1 - Set 0 if y > 258 if c > 1 - Set 0 if c > 0 - Set 255 - N - 1 if y > 3 if c > 1 - Set 0 if c > 0 - N + 1 - Set 255 if c > 0 - Set 0 - Set 255``` Hard to get something going in this language, but here is at least a rainbow in under 64 bytes 🙂 I guess the bands are somewhat wrong so i need a small fifth to start with red...

omfg I've been trying to do this for hours

<@!794205442175402004> thanks for the guide, i built from source (the win7 binary was reported as a virus 😛 ) It doesn't finish to 100% but the build is complete enough to use the tools 🙂

``` if W > 0 if W > 250 - W - 200 if W-WW > 0 if c > 0 if c > 1 - W + 5 - W + 2 - W + 3 - W - 1 - W + 10 ```

"African Textile"

Here is a variant that makes kind of interesting wavy patterns as you go towards the right

``` if W > 2 if W > 250 - Set 1 if W-WW > 0 if c > 0 if c > 1 - W + 5 - W + 2 - W + 3 - W - 3 - AvgW+NW + 40 ```

Okay, I did a small hack

https://jxl-art.surma.technology/

Definitely planning on improving the UX. I’ll probably be able to OSS this in the next week or so and then contributions would be very welcome

but I thought it might be nicer to not have to rely on the CLI and stuff

works offline and 100% in the browser 🙂

Good news everybody! <@!179701849576833024> made an encoder improvement that will trim ~5 bytes off of all of the above 🙂

Nice!

We are making good progress in improving the productivity of our procrastination!

(Also added a link with “documentation”. Will improve all of that later, but it’s good enough for now :3)

```if W > 0 if W > 250 - W - 170 if W-WW > 0 if c > 0 if c > 1 - W + 2 - W + 2 - W + 7 - W - 1 - W + 40```

that last band though

think you could make a version of that that has a "gallery" of submissions? 😄 and maybe also an upvote button...

<@!179701849576833024> That’d require a server side

also, then we have to think about abuse and stuff. Like, what if people spam-submit JXL art that is just a swastika or genitals or other offensive stuff

the server side is less of a problem... the abuse, ugh

Abuse is annoying. Guess could require google account?

A static gallery where you can click to copy the tree to make it a starting point for experimentation would already be cool

I could at least make it that you can create a sharable link with a specific piece of code preset

(Currently fleshing out the docs a bit :3)

```if y > 2 if N > 240 - Set 240 if N > 10 if N-NN > 0 - N + 3 if c > 1 - N - 5 - N - 2 - N + 1 if W > 240 - Set 240 if W > 10 if W-WW > 0 if c > 0 - W + 2 - W + 4 - W - 2 - W + 1```

I wonder to what extent this is just a toy, and to what extent it may actually have practical uses. E.g. for a game that ships a jxl decoder anyway for game graphics, maybe these could be a cheap source of extra textures...

Or maybe it could be used as a kind of grain synthesis

i remember coding stuff like this as a kid, but with more options 😄 <@!794205442175402004> how exactly would i use the "squeeze" operator? ```if c > 0 if N > 5 if W > 5 - AvgAll - 1 - W + 200 - N + 200 - Set 0```

Squeeze is currently not supported by jxl_from_tree, it would need to be implemented in a different way to make that work

<@179701849576833024> to make global transforms work, it would have to write a Modular image, then undo transforms to get the original image, but also remember the transforms and pass them to enc_modular (or skip the original image completely and somehow directly feed a modular image to the encoder)

yup, and then you'd get different channels...

Okay, I added a share button https://jxl-art.surma.technology/

But also, I wrote a bit more on the “help” page. <@!179701849576833024> <@!794205442175402004> I’d appreciate a fact-check if you ever get a sec https://jxl-art.surma.technology/wtf.html

It would also be nice to be able to save the resulting jxl file

Very nice, it's very convenient already 🙂 . Maybe the image is a *tad* to big.

Yes, squeeze residuals are many channels to play with. Also RGBA would be easier that way, could also be fun...

<@!111445179587624960> omg I planned to add that and completely forgot about it. hang on

<@!436097739391107072> It’s 1:1 😄 original size

I do wanna add a pinch-zoom, but haven’t really found an easy way

will do all that a bit later

Fair enough 🙂 Still feels huge even in 1440p resolution 😄

You are definitely right ;)

But I spent a total of ... 40 minutes on this? And most of it went to debugging the C++ tokenizer until I realized I was overthinking it 😭😂

can we add printing the error message from the parser if parsing fails? 😄

<@179701849576833024> yeah wanna do that. It should be visible in the DevTools console

Just need to rewrite your parser to put those errors somewhere i can grab ^^

ah, right, 'cause that's stderr

you can probably just redefine JXL_FAILURE 😛

also, some errors cause bigger failures, i.e. ``` if N > 200 - Set 0 - N + a ``` - result is always-grayed-out "Run"

I have a few of these "grayed-out runs", too 😦

I'll take a look at that later!

(i guess it's really prudent I get this OSS'd lol)

```if N > 20 if W > 20 if NW-N > 0 - AvgAll - 1 - N - 3 - W + 180 - N + 180``` 🤔

https://jxl-art.surma.technology/?code=CmlmIGMgPiAwCmlmIE4gPiAyNQppZiBXID4gMjUKLSBXZWlnaHRlZCAtIDEKLSBXICsgMTgwCi0gTiArIDE4Ci0gU2V0IDA%3D

That N + 18 was an accidental backspace that made it a lot better, lol

Also, no one has yet made a JXL logo in an interesting art way <:Thonk:805904896879493180>

I figured that any picture can be transformed into that tree, but that wouldn't be fun, would it 😉

``` if c > 1 if N > 20 if W > 10 - AvgW+NW - 1 - W + 100 - N + 150 if c > 0 if N > 30 if W > 17 - AvgN+NW - 1 - W + 200 - N + 200 if N > 10 if W > 8 - AvgN+NE - 1 - W + 100 - N + 200 ```

using <@!111445179587624960> trick to invert direction to generate some other colors, but hmm ... i feel a bit too much restricted here 😛 ``` if W > 254 - Set 254 if W > 2 if W-WW > 0 if c > 0 if c > 1 - W + 2 - W + 1 - W + 1 if c > 0 if c > 1 - W - 1 - W - 1 - W - 2 - W + 1```

https://jxl-art.surma.technology/?code=CmlmIE4gPiAyNQppZiBXID4gNTAKLSBXZWlnaHRlZCAtIDIKaWYgYyA%2BIDAKaWYgYyA%2BIDEKLSBXICsgMTU1Ci0gVyArIDEwMAotIFcgKyAxNjAKLSBXZWlnaHRlZCArIDE%3D

``` if c > 1 if N > 10 if W+N-NW > 10 - AvgW+NW - 1 - Gradient + 100 - N + 100 if c > 0 if W+N-NW > 10 if W > 10 - AvgW+NW - 1 - W + 100 - Gradient + 100 if N > 10 if W > 10 - AvgN+NW - 1 - W + 100 - N + 100 ```

``` if N > 25 if W > 50 - Weighted - 2 if c > 0 if c > 1 - W + 155 - W + 100 - W + 160 - Weighted + 1 ```

Hm, a way to share the image easily would be nice

Weighted predictor is by far the most chaotic one

Looks like a robotic lizard's scales

https://jxl-art.surma.technology/?code=aWYgTiA%2BIDEwCmlmIFcgPiA1MAotIFdlaWdodGVkIC0gMgppZiBjID4gMAppZiBjID4gMQotIFcgKyAxNTUKLSBXICsgMTQwCi0gVyArIDE2MAotIFdlaWdodGVkICsgNA%3D%3D

but can go out of range, is there a good way to avoid out of ranges, even with random-ish pixel inputs to it?

the predictors that have a matching property seem to be N, W and Gradient in some form, so for those you can use protective ifs

Checking for neighbors to be between 50 and 200 or something generally helps to avoid Weighted going out of range

is there any way out of ranges could be allowed rather than give error?

But with a different implementation of jxl_from_tree, you could just let it go out of range, modular can do out of range values and the decoder will clamp

It can currently not be allowed because jxl_from_tree does not hook into the modular image directly, it goes through the normal encode path, only using the fixed tree hook

The discord preview does not do justice to the actual image...

Yep, but a full image is fine

<@228116142185512960> feature request: show jxl filesize

https://jxl-art.surma.technology/?code=aWYgTiA%2BIDYKaWYgVyA%2BIDU1Ci0gV2VpZ2h0ZWQgLSAyCmlmIGMgPiAwCmlmIGMgPiAxCi0gVyArIDE2MAotIFcgKyAxNjAKLSBXICsgMTYwCi0gV2VpZ2h0ZWQgKyAx

That looks vaguely like a zoomed in fingerprint

https://jxl-art.surma.technology/?code=CmlmIGMgPiAxCmlmIE4gPiAyNQppZiBXID4gMjUKLSBXZWlnaHRlZCAtIDEKLSBXICsgMTgwCi0gTiArIDE4CmlmIFcgPiA4CmlmIFcgPiAxMDAKaWYgVyA%2BIDIwMAotIFcgLSAxNQotIEF2Z04rTlcgLSAzCi0gQXZnTitOVyAtIDEKLSBTZXQgMjU1

``` if c > 1 if N > 25 if W > 25 - Weighted - 1 - W + 180 - N + 18 if W > 8 if W > 100 if W > 200 - W - 15 - AvgN+NW - 3 - AvgN+NW - 1 - Set 255 ```

neat 🙂 also cool that i can Check that out right from the sofa now 🥳

Got back to working on this. Pushed a few quick things because <@!794205442175402004> tweeted about it. So it now shows the file sizes, the perma-disabled “run” button is fixed and you can download .jxl and .png 🙂

https://jxl-art.surma.technology/?code=aWYgYyA%2BIDEKCmlmIE4gPiAxMAppZiBXID4gMTAKLSBBdmdOK05XIC0gMQotIFcgKyAxMDAKLSBOICsgMTAwCgppZiBjID4gMAoKaWYgTiA%2BIDEwCmlmIFcgPiAxMAotIEF2Z1crTlcgLSAxCi0gVyArIDEwMAotIE4gKyAxMDAKCmlmIE4gPiAxMAppZiBXID4gMTAKLSBBdmdOK05XIC0gMQotIFcgKyA5OQotIE4gKyAxMDA%3D

I crossposted the new web playground in our size coding communities. I hope it gains some momentum 🙂

link? 😄

https://www.pouet.net/topic.php?which=12091&page=1#c568691

https://discord.com/channels/534447164043165696/534447164043165700/826211354510753813

https://discord.com/channels/787349849808699433/787349849808699436/826211083928862742

(those discord links don't work for me)

Sizecoding invite : https://discord.gg/aSa9xRGR

Demoscene discord : https://discord.gg/cMv5YUHr

Having an online interface is *much* more attractive than anything else 🙂

I never really was in the demoscene, but I was at Wired'98 and I have very good memories of that.

I was a sysop of a BBS and of course intros and demos were a big thing - and the tracking scene. MP3 didn't exist yet, video codecs were not yet practical, so demos and mods were the only way to share digital audiovisual art.

lol that filename

it looks great

it's a bit fat, at 214 bytes

yep

lots of little details

for no reason

could probably be optimized too

new version on dev repo reliably shaves off 4-5 bytes 🙂

it's a nice composition though

thanks

I particularly like the red in the top right quadrant

looks like a regular pattern until it collides with the right border and then like a particle accelerator it scatters

the triangles in different orientations are also nice

I like the bottom left, it looks 3D-ish with a bit of shading. Sierpinski again, yes, but a good one 🙂

yes, that part is neat too

oh lol I hadn't seen the .txt yet

that's meta-art

175b, sorry if someone has done that before 😄

so one thing that is possible in the bitstream but I didn't wire up in the tree program is to add an extra invisible first channel, and then reference it from other channels... I suspect that it can help creating interesting things 😄

New release! https://jxl-art.surma.technology/

- Smaller image that can be zoomed using pinch-zoom gesture/mouse wheel - UI face lift - Smaller payload overall (combined everything into one wasm module)

Also question for the JXL artists in here: If you zoom into an image, do you want:

a.) Pixelated zooming

b.) smoothed zooming (~bilinear filtering)

Vote with thumbs up reaction!

114 B, and made the squares even

Just as a proof of concept that *any* image can be done in JXL_Tree 😉

this one could be made more compact if the tool would let you choose image dimensions and group dimensions. Now it sets group dimension to max (1024x1024) and image dimensions to 1 group, but you could do this one with default group size (256x256) and just have the same simple image in every group

It's not small either. Just a statement, that *technically* JXL_Tree is unlimited 🙂

haha well it also is unlimited without any tree 🙂

Right, i fixed that 🙂

Is that a real compressed Einstein? I wouldnt know before chrome/gimp supports that 😉

Yep, just checking what the size would be for normal encoding

<https://squoosh.app/> can also be used for viewing only

Ha, neat 🙂

Well, the huge Einstein one just uses "if" and "Set", and it's a reminder (for myself at least) that there is no limit, i quickly did that in python : ```python from PIL import Image im = Image.open('onestone.png') pix = im.load() s = "" dim = 256 for x in range(0,dim-1): s = s + "if x > "+ str(x*4) + "\n" for x in range(0,dim): for y in range(0,dim-1): s = s + "if y > "+ str(y*4) + "\n" for y in range(0,dim): s = s + "- Set " +str(pix[x,255-y]*255) + "\n" text_file = open("onestone.txt", "w") text_file.write(s) text_file.close()```

Secretly i hoped that the tree compressor will chop a lot of that away (also using just two different colors to help with that), but it didn't. Anyway i wonder how the classic CA and gradient stuff can be combined with explicitly setting image content for results with more freedom 🙂

Neat! UI is starting to look fancy 🙂 also the intro text in help/wtf is nice

Currently no attempt is made to simplify trees — normally they wouldn't be hand-written, but they would get learned from the image data by an algorithm that wouldn't introduce redundant branches in the first place

I wonder what can be done with splines (when they will be supported in the encoder) and how costly they are 🤔

that's all there is to know about splines 🙂

splines feature is implement in jpeg xl 0.3.7?

the decode side of this has been there since at least 0.1

the encode side I don't expect anytime soon

but you could do it manually

it is not that cheap though

that's `5*4*32` bits to describe the spline color and thickness

look like splines feature is very suitable some non-photographic image, I still wait jpeg xl implement some vardct improvement 🙂 (reverse the order of dct size selection to merge instead of split)

Another mini update for https://jxl-art.surma.technology/ - Nearest-Neighbor zooming instead of bilinear (thanks for voting!) - Prettier button to auto-format your code - Better error reporting (not just “parsing failed”) - Share button behaves and auto-copies the URL to clipboard

Ooh auto-format, that is convenient!

https://jxl-art.surma.technology/?code=aWYgYyA%2BIDEKCmlmIE4gPiAxMAppZiBXID4gMTAKLSBBdmdOK05XIC0gMTAKLSBXICsgMjI1Ci0gTiArIDIyNQoKaWYgYyA%2BIDAKCmlmIE4gPiAxMQppZiBXID4gMTEKLSBBdmdOK05XIC0gMTEKLSBXICsgMjI1Ci0gTiArIDIyNQoKaWYgTiA%2BIDEyCmlmIFcgPiAxMgotIEF2Z04rTlcgLSAxMgotIFcgKyAyMjUKLSBOICsgMjI1

It would also be convenient to name the images automatically based on the hash (maybe even in human-readable words like Twitch does, for example: `SplendidRealCatThisIsSparta--9qJDd0tgrUQvvG7`)

https://jxl-art.surma.technology/?code=aWYgYyA%2BIC0xCiAgaWYgYyA%2BIDAKICAgIGlmIGMgPiAxCiAgICAgIC0gU2V0IDAKICAgICAgaWYgeSA%2BIDUwNAogICAgICAgIGlmIHkgPiA3NjIKICAgICAgICAgIGlmIHkgPiA4OTMKICAgICAgICAgICAgaWYgeSA%2BIDk1OAogICAgICAgICAgICAgIGlmIHkgPiA5OTEKICAgICAgICAgICAgICAgIC0gU2V0IDI1NQogICAgICAgICAgICAgICAgLSBTZXQgMAogICAgICAgICAgICAgIC0gU2V0IDI1NQogICAgICAgICAgICAtIFNldCAwCiAgICAgICAgICAtIFNldCAyNTUKICAgICAgICAtIFNldCAwCiAgICBpZiB4ID4gNTA0CiAgICAgIGlmIHggPiA3NjIKICAgICAgICBpZiB4ID4gODkzCiAgICAgICAgICBpZiB4ID4gOTU4CiAgICAgICAgICAgIGlmIHggPiA5OTEKICAgICAgICAgICAgICAtIFNldCAyNTUKICAgICAgICAgICAgICAtIFNldCAwCiAgICAgICAgICAgIC0gU2V0IDI1NQogICAgICAgICAgLSBTZXQgMAogICAgICAgIC0gU2V0IDI1NQogICAgICAtIFNldCAwCiAgaWYgeSA%2BIDUwNAogICAgaWYgeSA%2BIDc2MgogICAgICBpZiB5ID4gODkzCiAgICAgICAgaWYgeSA%2BIDk1OAogICAgICAgICAgaWYgeSA%2BIDk5MQogICAgICAgICAgICAtIFNldCAyNTUKICAgICAgICAgICAgLSBTZXQgMAogICAgICAgICAgLSBTZXQgMjU1CiAgICAgICAgLSBTZXQgMAogICAgICAtIFNldCAyNTUKICAgIC0gU2V0IDAKLSBTZXQgMjU1

<@!111445179587624960> The noise at the end is the actual code. You’d need to represent the user code with that human-readable format