JPEG XL

It looks like a part of a bent leg. Soon you'll be able to generate photos of people. 😄

A bit of offtopic https://niftygateway.com/itemdetail/primary/0xc7cc3e8c6b69dc272ccf64cbff4b7503cbf7c1c5/1

> The Pixel is a digitally native artwork visually represented by a single pixel (1x1).

data:image/jxl;base64,/wr6GLFATAhmv+gXASyAEQC8AEs4Qjwt5k9UG5S8OCysfHJ+RxUKwV0JLEQcSIzbcFgQvYPoIRaWjIWoI2xIEg4A

Here's the same file, for free, at original resolution!

Oh wow, you can't even see it lmao. Here's a base64 version of it: data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQYV2NoaGj4DwAFhAKAowjAZgAAAABJRU5ErkJggg0KDQpJIGFtIHRoZSBtZWRpdW0u

``` Orientation 6 RCT 1 if c > 1 if x > 0 if W-WW > -1 - W -1 - W 0 - Set 300 if c > 0 if Prev > 50 if W > -300 - Weighted -15 - Set 300 if W > 0 - AvgW+NW - 20 - AvgW+NW + 20 if N > -20 if WGH > 5 if WGH > 10 - AvgW+NW -2 - AvgN+NE +1 - Weighted -1 - Set 400 ```

"Coral Reef"

Found a new little trick

``` Bitdepth 10 Width 1024 Height 1024 Orientation 1 RCT 1 if c > 1 - Set -20 if c > 0 - Set 333 if W > 600 - AvgW+N -3 if WGH > 0 - Weighted +20 - Weighted -20 ```

"Skin"

data:image/jxl;base64,/wr6F0ORCCYA/SOABTACAGwASzhD5rbfEqhZ9DB4mjj4sNiJC8QixB4kCQcA

Wtf discord

Dark theme is messing it up

Well, it compresses previews on mobile <:SadOrange:806131742636507177>

Well what is it supposed to look like?

I have no jxl-capable chromium yet.

It is inverting the skin pigmentation into brighter spots instead of darker ones

Same as the image Jon sent, but it shows messed up for him on mobile

It looks relatively similar here (dark theme, firefox, not mobile).

Ok.

That was what I saw, wasn't clear to me what difference you were referring to.

How do you see the screenshot with discord?

this

and this look very similar to me

(in color/texture/pattern; the size of the latter is smaller)

But you do see it different here, right?

It's paler, and the "pattern" looks brighter than the background. In the (I think) correct image the pattern is darker than the background.

Discord does some trickery to auto invert some stuff to convert what it thinks is dark text on bright background to bright text on dark background

It works well to convert 'light mode' screenshots to 'dark mode' screenshots

But here it goes wrong

The pigmentation is supposed to be darker than the rest of the skin. Trying to imitate natural skin texture here

``` Bitdepth 11 Width 1024 Height 1024 Orientation 1 RCT 1 if c > 1 /* hint of moss */ if y > 600 if PPrev > 500 if y > 800 - AvgN+NW + 5 - AvgN+NW + 2 - Set 100 - Set 100 if c > 0 - Set 600 if W > -50 if W > 1000 - W -80 if WGH > 0 - AvgAll 50 - AvgAll -50 - W 200 ```

data:image/jxl;base64,/wr6GMZKJAgmAP0igAUwAgDAAEs4Q5zDgjP4U60vLOXaj56HhIWFYMa+QPKQBAu9+iCRRcgOqPfhAumQSGdEknAAAA==

"Tree Bark"

``` Bitdepth 10 Width 600 Height 750 Orientation 7 RCT 0 if y > 374 if x > 299 - NW 0 if x > 298 if y > 450 if y > 600 - Set 1000 - Set 0 - NE 0 - NE 0 if y > 0 if x > 0 if x > 598 if y > 150 - Set 0 - Set 500 if x > 299 - NE 0 - NW 0 if y > 150 - Set 0 - Set 500 if x > 450 - Set 0 if x > 150 - Set 1000 - Set 0 ```

Another variation of the logo, this one could be overlaid on the tropical island image

``` Bitdepth 10 Width 4096 Height 2048 Orientation 7 RCT 1 if c > 1 if x > 200 if g > 22 if g > 26 - W -1 - W 1 - W -1 - Set 0 if c > 0 if y > 200 if g > 24 - N 1 - N -1 - Set 0 if W > -500 if W > 1200 - N -30 if WGH > 0 if g > 21 if g > 22 if g > 23 if g > 25 if g > 26 if g > 27 - AvgAll 50 - AvgN+NE 50 - AvgAll 50 - AvgN+NE 50 - AvgAll 50 - AvgN+NE 50 - AvgAll 50 if g > 21 if g > 22 if g > 23 if g > 24 if g > 25 if g > 26 if g > 27 - AvgAll -44 - AvgN+NE -53 - AvgAll -53 - AvgN+NE -50 - AvgN+NE -52 - AvgAll -49 - AvgN+NE -51 - AvgAll -58 - N 200 ```

data:image/jxl;base64,/wr6P9dQTAgGAQCgAQAAQAAEQAAEQAAEQAAEAAuAEwyCcBQjJSFKAByjALlciUUShQRb/Hl0mgCcsANYZOZAXlrSCYTwpk2LAhRF84uVBPrFOsM8cyRHnTiW1C5kybFfsGGpC0qyc4/kCb/JltQmRDku3pdsHSPJTr417QUaxlSScAAAAwMDAwMDAwM=

Texture study: lightning and bamboo

``` Bitdepth 3 Width 3072 Height 3072 Orientation 5 RCT 1 if c > 1 if g > 21 if g > 22 if g > 23 if g > 24 if g > 25 if g > 26 if g > 27 if g > 28 - Set 4 - Set -1 - Set 0 - Set 3 - Set 0 - Set 2 - Set 5 - Set -1 - Set 0 if c > 0 if g > 24 if g > 26 - Set -3 - Set 1 - Set 4 if y > 0 if N > 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 - N + 0 - Set 6 if x > 511 - Set 6 - Set 0 ```

data:image/jxl;base64,/wr6X5GwEBMIBgEA+AAAAEAABEAABEAABEAABEAAC0RIQEHJjdExOEgM+xdCCljm14PCfpf7rLiGZe33j4GBM+BZ2fNSBJ6yw2mciz759lqxku5qGmVAciQJBwADAwMDAwMDAwM=

"Fast-forward or Rewind? A Warholian Political Compass"

- Which quadrant are you in? - *`yes`*

data:image/jxl;base64,/wr6GAGRCGa/6BcBLIARAIAASzhC5rZrBW+CfWSwkBzs8oWqfl70hZQd+TbyAEnCAQA=

``` RCT 1 if c > 1 - Set -200 if c > 0 - Set 200 if W > -230 if WGH > 3 if N > 200 - AvgW+N -30 - AvgW+N 4 - AvgW+N -4 - Weighted 350 ```

"Creepy Zombie Arms"

First day of the 91th JPEG meeting is over (at least for me). The above image kind of captures my mental state after ~13h of online meetings (from 6am to 7:30pm).

<a:PepeHackerman:806632585429909514>💻

If you look at it from another perspective it looks like the black background is bleeding

``` Bitdepth 3 Width 1024 Height 1024 Orientation 1 RCT 0 Squeeze if W > -3 if W > 3 - W - 1 if W-WW > 0 - NW + 1 - W - 1 - W + 1 ```

data:image/jxl;base64,/wr6H8FCJAgGAQBEAEsosG34Dd/w6qDYGQ4KScIJ

No idea what I am doing but it looks like there's xorpinski-like stuff hidden in Squeeze

Such weird things

``` Bitdepth 3 Width 1024 Height 1024 Orientation 1 RCT 0 Squeeze if W > -3 if W > 2 - W - 1 if WGH > 0 - Weighted + 1 - Weighted - 1 - W + 1 ```

data:image/jxl;base64,/wr6H8FGJAgGAQBIAEsosG289dKTfuhjph/6kCScAA==

``` Bitdepth 7 Width 1024 Height 1024 Orientation 1 RCT 0 Squeeze if N > -5 if N > 5 - NE - 1 if N-NN > 0 - NE + 1 - NE - 1 - NE + 1 ```

What is this animal and how do you tame it

data:image/jxl;base64,/wr6H8FCJAgGAQAsAEsoNDI+loKJJOEE

``` Bitdepth 3 Squeeze if W > -3 - W -1 - Set 3 ```

Bitdepth 3 Squeeze if W > -1 - W -1 - Weighted 3

data:image/jxl;base64,/wr6H8FEJAgGAQA4AEsocJxP7UcKMzCRJJwA

``` Bitdepth 5 Squeeze RCT 0 if c > 1 if N > -5 - Weighted -1 - Set 3 - W 1 ```

"Vaguely Sierpinskian Mosses"

Bitdepth 5 Squeeze RCT 0 if c > 1 if N > -2 - Weighted -1 - Set 1 - W 1

What is this stuff

Bitdepth 3 Squeeze RCT 0 if c > 1 if N > -2 - AvgN+NE -1 - Set 2 - Set 0

Bitdepth 3 Squeeze RCT 0 if c > 1 if N > -1 - Weighted -1 - Set 2 - Set 0

This is a strange world

These are all below 30 bytes

data:image/jxl;base64,/wr6H8FDJAgGAQA0AEsoNBbe0Q3k4ECScAI=

``` Bitdepth 4 Squeeze RCT 0 if c > 4 if N > -4 - Weighted -1 - Set 4 - Set 0 ```

"Squeezed Coral Reef"

I wonder if it would be possible to make a macroscopic tesselation one

This looks a bit like a stained glass window to me. And under 30B? Wow

Quickly sifting through, i like this one the most. Wow. And 30b only?! Incredible ❤️ We've come far since the "proof of concept" of sierpinski in 32 😄 So, when will this be doable in the (a) only tool? 🙂

whenever we do a version bump, the snippets above will work in the public `jxl_from_tree` tool (and I guess also in the web version as soon as Surma updates it)

26b even. That achieves x86 asm (msdos) density by now. And that's one of the highest densities i would know of. In 2014, 32 bytes for a dragon fractal had quite a "wow" factor to it. Not as much anymore it seems 😄 So how long until JXL animates a fractal in 32bytes? 😄 (Is that even possible)

https://www.pouet.net/prod.php?which=63522

<@!794205442175402004> also, i'm wondering how smart the tree learning algorithm is. I mean one of these textures above could with different colors (and maybe slight modications) very well be used as soil texture. So if the loss function of an assumed deep learning approach would be SSIM (or a variant), intuitively some RL textures could have *really* small JXL estimates (?) https://2.bp.blogspot.com/-r82m1xLwXks/UCpI9-_S1CI/AAAAAAAAB-o/ReKXIWmW7vs/s1600/Seamless+ground+sand+dirt+crack+texture.jpg

We currently don't do lossy modular in that way, it would be interesting but I think quite hard

not sure what the overhead of animation is, there is some cost per frame so I don't think you can do 2+ frames in 32 bytes but I could be wrong

but if something like 128 bytes or 256 bytes is allowed, it should certainly be possible to make neat animations in that byte budget

jxl_from_tree in current public code should work with the stuff I have been sharing above

Please try your own stuff and make art, I also want to tweet jxl art made by other people than me 😅

<@228116142185512960> maybe a good time to update the online jxl art tool?

I’ll take a look at in the next couple days!

``` Width 2048 Height 2048 RCT 1 if c > 0 if c > 1 if W > -512 - W - 1 - Set 511 if |N| > 511 if N > 0 - N - 32 - N + 32 if y > 0 if N-NN > 0 - N + 32 - N - 32 if W-WW > 0 - W +32 - W -32 if |W| > 255 if W > 0 - W - 8 - W + 8 if x > 0 if W-WW > 0 - W + 8 - W - 8 if N-NN > 0 - N +8 - N -8 ```

Some random pattern that tiles nicely

It is shown 2x2 times here

ooh

got it working now

data:image/jxl;base64,/wr6H8FCJAgGAQBcAEsosSljvvbpOsGtZEh49k6CDAs2JAkn

``` Bitdepth 3 Width 1024 Height 1024 RCT 0 Squeeze if c > 10 if |N| > 3 if N > 0 - N - 1 - N + 1 if y > 0 if N-NN > 0 - N + 1 - N - 1 if W-WW > 0 - W +1 - W -1 - Set 0 ```

"Worn Tetris T-shirt"

``` Bitdepth 4 Width 1024 Height 1024 Squeeze RCT 4 if W > 4 - N -4 if WGH > 0 - AvgN+NW 1 - W 2 - Set 0 ```

'Alien Artifact'

data:image/jxl;base64,/wr6H8FDJAgGAQBIAEsoMW6Nh0F0HtgCV5AkLABSAA==

'Alien Artifact' is SO interesting

when fabian comes back online i should tell him to mess around with jxl from tree

like you said he might make some interesting stuff changing values

``` Bitdepth 4 Width 1024 Height 1024 Squeeze if c > 1 if |W| > 2 - Set 0 if N-NN > 0 - NW 1 - NW -1 - W 1 ```

"Sierpinskiesque Autumn Dreams"

data:image/jxl;base64,/wr6H8FDJAgGAQBAAEsocJxPzSEFuDkKR5AknAA=

<@!794205442175402004> I’m guessing it’s ToT in the repo you are referring to? The most recent, tagged release is 0.3.7 which is 3 weeks old

yup

``` Bitdepth 4 Squeeze if c > 1 if W > 1 - Set -2 - W 1 - Set -2 ```

data:image/jxl;base64,/wr6H8FDJAgGAQAwAEsoNBRejlAoFiQJJw==

"Intergalactic Symmetries"

25 bytes

Only 25 bytes?

I really don't know how to work with Squeeze, it produces 48 channels and each of them corresponds to a different component and scale and what is encoded are residuals, so basically you have to give it values close to zero and weird stuff happens in very hard to anticipate ways

25 bytes for an image like this is pretty cool, right?

I've been seeing these, this is creating images by only using prediction to achieve insane filesizes right?

Yes. All encoded values are zero, which means the asymptotic cost per pixel is exactly 0 bits.

(because the entropy coder behaves that way for singleton histograms)

We could actually also do repeating sequences of encoded values with an asymptotic cost of zero

I wonder what we'd get when we learn to combine squeeze with the weighted predictor...

``` if W > 0 if PrevAbsErr > 10 - Gradient + 1 - Weighted - 1 - Weighted + 70 ```

Looks like some 3d bar diagram.

``` Squeeze if W > 0 if PrevAbsErr > 10 - Gradient + 1 - Weighted - 1 - Weighted + 70 ``` Same code, but squeeze

Generally same code plus squeeze gives the kind of blocky pattern you get from ``` Squeeze - Set 128 ```

Nice, brick like. Where does the color come from?

I don't know, to be honest

🙂

I don't really know why there would be any difference between R, G and B

The default squeeze will first squeeze G and B because it assumes they are chroma (usually it would get Y,X,B or Y,Co,Cg)

So probably it ends up squeezing R one step less than G and B

Or two steps

Yes, that must be it

``` Squeeze if N > 0 - Weighted -1 - Select 2 ```

'Minimalistic Infinite Weaving Loom'

data:image/jxl;base64,/wr6HwGRCAYBADAASxJlxrGVOAtaJAkn

24 bytes

Those pixel patterns it creates are quite cool

``` Bitdepth 12 if W > 0 if PrevAbsErr > 100 - Gradient + 170 - Weighted - 5 - Set 700 ```

Wavy plasma ghost

``` Bitdepth 3 Squeeze if N > 0 - N -1 - Weighted 7 ```

data:image/jxl;base64,/wr6H9fQIGACCBggAABsAQAAQAAEAAuAo21blWLLyED4CoDwbPwXhfArBkQRi1EU7xDGEeYHiJAaQPJZh/umLoa66D2WT/LQH/1yMMYHOLPAtzsaxYGQTHihR9eUE5p4fi7GEbZ4fqBFMgOQBpKEAwADAwgYIlEAABwBAABAAAQAC0RIMaNdxRgMRkVHMwL9BIST+feQ//dftoD+EBr8ZkT5KTHO/69dA5I0I/OVm+QB/u+yIfEOsoBk64P8UA4kwGkASEnCAQADAw==

I am experimenting with stuff

Looks <:Poggers:805392625934663710>

**Update to jxl-art.surma.technology** - Using Emscripten’s file system emulation, so I don’t need to vendor/monkey-patch `jxl_from_tree` anymore. If `jxl_from_tree` gets an update, all y’all need to do is to update the commit hash in the `Makefile` and open a PR with the re-built binaries. - Updated the prettifier for support of the new syntax https://jxl-art.surma.technology/?zcode=dVDLCsIwELznK%2FZeAkkf1pOgInqqoELO0sY2lyoSRP%2Fe3SZ9hOptd5jHzm6MrfTDNrBkx6fRrb1ac28hZ6ftBSRj5gYfWIHMBAPApcSFRgAOhZ8QfiOcCbd2gNofCPIAsdevuogKBRHEM3SHUzyKyS3NRUhTJOajdggZeUGM%2FAFTjnRFulbJoi9QToz8KqdRYUHnedYWD5pjqZgrw2uUvyPUuSf%2FCaR3R8FDCzLJ%2BgIK%2BXwwwAht6sbqCrhk05AkFl8%3D

Would be lovely if some of you people with magic spec access ( <@!794205442175402004> <@!179701849576833024> ) update the help page with a description for the new options/parameters https://github.com/surma/jxl-art/blob/main/src/wtf.html.ejs

Nice! will take a look at it when I get the chance

working on adding even more stuff (will take a while before others can use it, I still need to make a merge request in the private repo for it, let alone having it in the public repo)

`FramePos x0 y0` you can use (with negative x0 and/or y0) to crop/hide initial columns/rows that you don't want to show

and `NotLast` will be a new flag that indicates that the tree will be followed by _another_ tree which describes an overlay frame which will get blended on top of the first frame

only useful if you also have the `Alpha` flag, which gives you an alpha channel

nice! exciting stuff

I am mostly happy that I can stay up-to-date with ToT by just updating the commit hash now

Emscripten really comes with a lot of batteries included 😄

Nice! Does it support syntax like Bitdepth? When I try it says "Unexpected node type: Bitdepth". Thanks 🙂

Oh, fixed it by doing a hard refresh (ctrl+F5)

Browsers like to cache JS, to fix that you can add something like "<script src="main-4731ffda.js?version=something..."></script> to the JS inclusion

not true, you can use Add 😄

more than magic spec access, it's magic knowledge of not-very-documented code...

right, just haven't done the plumbing yet to select blend modes yet, so it's always kBlend for now

<@!768090355546587137> all files have their hash in their filename, so caching shouldn’t really be a problem. Maybe I messed up somewhere in the service worker

data:image/jxl;base64,/wraHNTQIGACCJitkOMAHsBAAAB8AQAAQAAEAAuAo21bLaPKyBwPmAAmM/03iRCZjVBUzAilhVqNiIdCcBpMEbiPPg8So43fsXQxjmKEXqbFg0GLk7/d/PkRitc4BCtg8Xlt9FQmeAITz2vFOPuMz4+VMCZYSkCScAAAAwMImK2Q4wAewESiAAAcAQAAQAAEAAuAi2UrKor1RkxDgFBgxeZDMX4rMCb0q/qgOlIYoHnwNz+nVsB/CywPlidcVj7p3xhjtIhBoufAwQ/Swyxj2UWAo4IEKUkYAwM=

``` Bitdepth 10 Orientation 7 Width 2048 Height 1024 RCT 1 Alpha FramePos -662 -100 /* crops the init rows away, and part of the sea to get a 2:3 aspect ratio */ NotLast /* we will overlay something on top of this */ if c > 2 - Set 1023 /* opaque bg layer */ /* Chroma */ if c > 0 if c > 1 if g > 21 - Set -50 if x > 40 if W-WW > -1 - W -1 - W 0 - Set 300 if g > 21 if x > 0 - W - 2 - Set 1000 if x > 650 - W + 3 - Set -900 /* Luma */ if y > 20 /* Sky and mountains */ if g > 21 if x > 0 if WGH > 3 - AvgN+NW + 5 if NW-N > -500 - AvgN+NE - 5 - NW + 1 /* extend mountain */ /* init mountains */ if N > -6000 - N - 20 - Set -1000 /* Sea */ if x > 1015 - W -100 if WGH > 1 - AvgN+NW +2 - AvgN+NE -2 /* Randomness */ if g > 21 if W > 50 - Weighted -10 - Set 1200 if W > -50 - Weighted -4 - Set 500 /* logo layer on top of it */ RCT 0 if g > 21 /* only in the top part */ if c > 2 /* the logo is in the alpha */ if y > 561 if x > 611 - NW 0 if x > 609 if y > 638 if y > 811 - Set 400 - Set 0 - NE 0 - NE 0 if y > 0 if x > 0 if x > 1022 if y > 227 - Set 0 if y > 70 - Set 400 - Set 0 if x > 611 - NE 0 - NW 0 if y > 27 - Set 0 - Set 400 if x > 922 - Set 0 if x > 300 - Set 500 if x > 127 - Set 0 - Set 400 /* color of the logo */ if c > 0 - Set 1000 /* turquoise */ - Set 0 /* nothing in the bottom part */ - Set 0 ```

a similar mechanism could be used to do animations (but maybe it would be good to have browser support for animation first 😅 )

I had cache issues too to be honest 😄

That image looks just way too good :p

Then I probably screwed up my service worker logic lol

For future reference: The “help” page has a “nuke cache” button at the bottom in case it goes back to the old cached version after a refresh

I’ll investigate

``` if W > 10 if WGH > 30 if PrevAbsErr > 2 - AvgW+N -3 - AvgW+N 9 - AvgW+N -4 - Set 300 ```

(fwiw these caching hours are pretty much guaranteed to resolve themselves within 24 hours. But seems like there is still a bug about refreshing sooner)

``` Bitdepth 5 if PrevAbsErr > 1 - Set 16 if WGH > 5 - AvgW+N 2 - AvgW+N -1 ``` edit: Triangular Cubism 🙂

that looks some kind of cubism / futurism abstract art

you should give your pieces a title 🙂

https://github.com/surma/jxl-art/pull/1

negative alpha does something interesting

<@!794205442175402004> Thanks for the PR! I just applied some formatting to it. Should be live in the next couple minutes.

You didn’t explain `Orientation`. If you give me a quick description I’ll add it

it's just the exif orientation

ah yes

1 is normal, 2 is flipped horizontally, 3 is upside down, 4 is flipped vertically

and 5,6,7,8 are rotated +-90 degrees and flipped versions of that

You say that like everybody knows what that means 😅

heh, I made that assumption because I know nothing of metadata but I know what it is xD

so really, orientiation semantically in jxlfromtree language just changes the meaning of all the N,E,S,W directions

i think

and maybe ordering of groups?

also changes meaning of cropping IIRC

i wonder if the language could instead of having an orientation field just have it infer from which N,E,S,W variables are used (and something similar slightly higher abstraction for cropping and groups)

Well also the order in which the pixels are generated

So seeing it as a Post-Generation transform is arguably the easiest imo

The AvgAll and Weighted predictors are hard to express without referring to orientation

Updated the app with documentation for `Orientation` and fixed the prettifier for 0-arg header directives

btw, the caching was not a bug. That’s technically WAI. You need to close the tab for the new service worker (that holds the new cache) to take effect. I’ll have to add some more plumbing to add a proper reload UI there

I hope people will have much fun with the new options as I had

```html <li> <code>Squeeze</code>: Apply the Squeeze transform. Weird things will happen and the image gets many channels. */ </li>``` <@!228116142185512960> comment closing tag `*/` remained after the help page revamp, I've just made a pull request and signed Google CLA so you can hopefully merge without problems 😃

If you prefer to fix simple things by yourself in order not to clutter contributor and PR lists, just let me know so I'll forward fixes to you.

Formic etches https://jxl-art.surma.technology/?zcode=ZY4xDoAgDEV3TvF308Sis0dgcegBjCTsLt5eCikibn3%2Ft%2BlLETc2eAekiKDjOmcoeGTkAgBhP69WNmZvy3rL1ipT0MiSehMwYRkSgnd9z9VF%2Fi4V7POH3kUZPIREfh6S%2F3jXc2%2BhLT8%3D

https://jxl-art.surma.technology/?zcode=dY67CoAwDEX3fsXdJdBY0E4u7h1UyAeIgruLf2%2Bj%2BKjFLefehJyuHcDGLDM2NCgNEMego7cRDhwj8gEAoZ9WlJVN%2BVnWW3L26jWhoOGV6E1AAZcwwZt3y6eJ5Cafz%2FxrIpmJkMjHROKvOmG6zc6Wdw%3D%3D

Same concept but in RCT 1 and adjusting some values

https://jxl-art.surma.technology/?zcode=Cy4sTU2tSuVyyixJSS0oyVCw4PIvykzNK0ksyczPUzDkCnIOUTDg4spMU0hWsFMwNODSVQhOLVEwNYAJmQNFwhUMTaESQLUA

Tetris Block Factory

ti tididi tididi tididi tididi tidi ti ti ti ti

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsODyL8pMzStJLMnMz1Mw5ApyDgGSXJlpCgFFqWWOScWuRUUKdkAhoEgymKGrEJxaoqBragBlARlAuXB3D6CsMZeCgq6CY1m6n7afK1AtlBeu7ReuoAs0FgA%3D

ta tadada tadada, tada tadada tada da da da da da

https://c.tenor.com/2aCgSgX1b_AAAAAM/tetris-fail.gif

Is it possible to inverse a channel? if "condition" - |W - 255|

You cannot do math directly

What are you trying to do?

You can often generate things in an inverse way, like doing `if W > 0 - W -1 - Set 255` instead of `if W > 254 - Set 0 ; W +1`

No! I totally appreciate the PRs. Thank you!

I like how this art is open source in many layers: you share the 'source code' (tree) for the art, using an online tool that is itself open source, and it is all based on an image format with open source reference software

Can we somehow make an art gallery with PNG versions of the image, a link with the ?zcode source code, and a way to upvote images and sort to see the best or to see the latest?

Maybe just a reddit thread or something could work, though I don't think you can have images in the thread itself

Maybe a new subreddit?

Any other existing things that could be used for this?

(you can scroll up in this discord channel but that's not a very convenient way to view jxl art)

Yes a jxl-art subreddit will be super cool 😄

Created https://www.reddit.com/r/jxlArt/

But reddit doesn't seem to be very convenient to upload images to

<@!794205442175402004> I think it would be nice to add examples and descriptions of interesting things that were used in their creation in this thread <https://www.pouet.net/topic.php?which=12091>, with links to the web tool and will also be easier to then do reposts and links when all the important will be in one place

My first commissioned art piece: https://twitter.com/jonsneyers/status/1385954683479527424?s=19

That would be useful I suppose, but I don't really feel like duplicating the above channel over there...

<@!794205442175402004> I mean not just a gallery for all images, but the most interesting examples that show JXL features with a description of how it was created and the most spectacular/technically impressive arts, I think this could further fuel interest among demo-makers, especially considering that JXL is already supported in Chrome (with a flag, but still) Single posts will usually just get lost or finding that information all over discord isn't as convenient (also not everyone can be on that server) Unless it requires some free time to write/describe it (and I don't have enough knowledge or good English to do that)

Makes sense. Anyone please feel free to add stuff to that thread, including just copy/pasting things from above that you particularly like (most of it should work in the online tool now, only cropping hasn't landed yet)

https://jxl-art.surma.technology/?zcode=tVM7T8MwEN79K25uZfXsNlAWJKgQDChIDZLnqDGJhZKg1kXtv%2BfOdkolVuMlfkT33fe4R%2Bcb%2B%2BU7UCje9s4OvvZuHOBWGNfQtcbVWmw376CEWMxg0%2B3HvobZQrgP2ME9IORaqaDiyi1ttMpVWUJlPcgCufSJSq%2FCzkhj6CCVkGCmD4r49xIxfyMJHiMg6GzaJYoK8YpjhJmDTpTkHV2xia%2FHaCHkXgR9Jug15i9NbVefZ6iHBvrxSCl1wyHFMHokLuKytc8vtF0S8YfvtpyXLEPBD6WRJXteBHXi4xOpV%2BQxIQCp0K09eXvV7L%2FoTTBucP6PIoHiDQaOJQdtSrUMCeEMVHaaYhZNoSpyBdEElF8XVLaIX7zU195pEQhtKRpjP9jDJIKJPvMQWNd23jZ0zJTyFLk0dTRqWceYw%2FkD

This one I still like the most so far

Or the one with the second layer for the logo, but the online/public tool cannot do that yet

Yes, I meant that art as well, although it may be worth waiting for adding crop to the online tool for maximum wow effect

https://jxl-art.surma.technology/?zcode=tVRBTsMwELz7FXtuZdVOGsgJiVYIDshIDZLPETGtVcVBrYva37PrOGkRJ6jxIdrEyszszNoL6xvz4TdQspedNc7X3nYObpm2DX7NxLxkq%2BUrSMZmE1hudl1bw2TG7Du8wR0ISLUioCTkNRaZTIXMoTIeeCFYXxUpKRDqSD4gtkamZKKj6kIIUnuKFEpDeO8psdBc65G%2Bf07Rw9hyjn9TbM%2BHPjRIvUZpyZFRdbU9Qe0aaLsDjqV1%2Bzh3fXTfbXh8wjLHvu8%2F12qqyIWMNpTmCnc4%2BThsPqC32Z9TCdgyCDRHby70%2FYvDSGOd9T9MCF2VIrSlqKFhurkUMfXKDCeVfJJCFqkmUxPL2Xfxy9%2FHjORlJnjDkOoVRt61zuyHTs%2FzzW%2FSXw5Xns98vFXkXLAv

Slightly tweaked/simplified to fit in 100 bytes (crop will add a few bytes though)

I wonder where the triangles come from

https://jxl-art.surma.technology/?zcode=Cy4sTU2tSuVyyixJSS0oyVAw5uLKTFNIVrBTMAEx%2FIAMXSMuXYXw1Mz0jJLUFAVdQyAvOLVEAUYbAAA%3D

Interaction between Squeeze and Weighted is nearly impossible to reason about

what does squeeze actually mean in terms of decoding algorithm?

Well

Encode side, one squeeze step is taking a 2W x H channel and turning it into two W x H channels, the first being the downscale (averaging two pixels into one), the other being the residual.

For pixels A and B, the first channel will be (A+B)/2, and the second will be A-B-T, where T is a tendency term that is nonlinear: if the local neighborhood is monotonic, it is an interpolation, otherwise it is zero.

(that T term makes the residuals suitable for quantization)

That would be a horizontal step, the same can be done for a vertical step, starting from W x 2H to get two W x H channels

The steps are alternated horizontally and vertically and applied recursively to the downscaled images but not to the residuals

Until you get something equal or smaller than 8x8

So a 3-channel 1024x1024 image becomes a 48-channel image where the channels have dimensions 8x8, 8x8 8x16, 16x16, 16x32, etc until 512x1024

You can then quantize the later large channels more and the earlier small ones less to do lossy compression

Or just keep it like that and have lossless with progressive

oh, i see

(with actual downscales in the intermediate previews, not NN subsampled like in flif)

it's something like adam7 interlacing

ah, but with avg/difference added to it

Yes except real downscales, not subsamples

And the tendency term makes it behave interestingly

tendency term?

That gets added to the diffs

It is made such that if you quantize the residual channels to zeroes, you get something that is smooth in locally monotonic parts of the image, and blocky in locally nonmonotonic parts

It could also always have done interpolation, but then you would get the usual ringing artifacts (overshoot issues)

Without the tendency term, if you just let the diffs be zero then you get only blocky stuff because you are then just doing NN upsampling

https://jxl-art.surma.technology/?zcode=Cy4sTU2tSuVyyixJSS0oyVAw4wpyDlEw4MpMU0hWsFMwAjFqwmuATBMQMxzIMODSBdK6hmBK2xAk7AcTTs1MzyhJTVHQBepE4morGMJMBGkLTi1RMIUJQIzTBgpAaCMA

"Impressionist Forest"

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKcg5RMOTiykxTSFawA7IUFHQVglNLFHRNDYBsoHBNeA1QwgjMBQuEA7kQDkhtuIKuERJH2wiHstTM9IyS1BQFXWNMMWMA

Looks like a level for a platform game

"Platformation"

I like the range of styles that can be obtained: somewhat realistic-looking clouds etc, paintery stuff, very structured things like sierpinskis and cellular automata, alien stuff, flames, plasmas, abstract stuff with strong lines, etc etc

29 bytes Sierpinski, what is the smallest so far? https://jxl-art.surma.technology/?zcode=y0xTqFCwUzDgUlDITFMIhzLBHD84BwR0FYJTSzD4Rqam2JSjSiJrhssAAA%3D%3D

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOTiykxTqFCwUzDgUlAAMsOhTDDHD84BAV2F4NQSDL4hNsXIUsgaoeIA

27 bytes

Gah, <@794205442175402004> beat me to it.

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOTKTFOoVLBTMOBSUAAyw3X9woE8XUMgF1nAAMxXUNBVCE4tQeNB1CJkoCwA

25 bytes

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKLixNTa1K5eLKTFNIVrBTMOFSUAAyK4FMAyATzAnX9QsH8nUNwQLIQgZQEQUFXYXg1BIMPkwHsiyCDWEZAQA%3D

Back to 28 bytes but now it's a glitchy colored one

https://jxl-art.surma.technology/?zcode=y0xTqFCwUzDgUlDITFMIhzLBHD84B8xNBnINoVwFBV2F8NTM9IyS1BQFUyTB4NQSZD0g84xM0RWgmKKgDeVj2uhHULcfXDey5VB1AA%3D%3D

Variant using WGH: https://jxl-art.surma.technology/?zcode=y0xTqFCwUzDgUlDITFMIhzLBHD84R0FBVyE4tQTOA6l09wBKG5lCRWAqDJH44QraUD6aYVCukSk%2B3X5w3ci2Q9UBAA%3D%3D

Construction x 1 https://jxl-art.surma.technology/?zcode=y0xTqFCwUzDgUlDITFMIhzLBHD8gx9AUzAPzk0F8KBcsUAkUMDIygAspKOgqOJal%2B2n7uQLFUYSDU0uQ9EL4BgijQfYamZpy4dYQrqAN5cNchqTdj6B2P7h2ZNuh6gA%3D

Hot chamber https://jxl-art.surma.technology/?zcode=y0xTqFCwUzDgUlDITFMIBzINTYFsMM8PwQPzk6EKUQQM4QIKCroK4amZ6RklqSkKuqjijmXp4dp%2BCrqWCP1IipHsALnAyNQU3RYDFNOCU0sUDA0UMMWQDVfQhvKhPjFAWOKHZgmmbj%2B4bpgsSDtUHQA%3D

wow, that has no x and y based branches :o

it's based on Sierpinski

Would it be correct to say squeeze performs a wavelet transform?

2d haar wavelet, i guess

ah makes sense. The tendency term is confusing but that helps a bit to imagine what's going on

isn't everything?

"She comes" - I didn't figure out how to change the colours https://jxl-art.surma.technology/?zcode=i4h04vIvykzNK0ksyczPUzDj4spMU6hQsFMw4FJQADKToUwFBV0Fx7J0P20%2FVyDLECYUnpqZnlGSmqJgiKk8OLVEwcjACIVnAAA%3D

Another 25 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOTKTFOoVLBTMOBSUAAyw6FMBQVdBT8oCyjsBxcGSQSnlqDxDLng4gA%3D

Pythonic triangle https://jxl-art.surma.technology/?zcode=C3IOUTDj4spMU6hUsFMw4FJQADLDoUwFBV0FPyA2BLOBEn5wCZBUcGoJnAeUTAZKGkK5IOnw1Mz0jJLUFAVDU2MkYZAuI1OQPqgJAA%3D%3D

https://jxl-art.surma.technology/?zcode=Cy4sTU2tSuUKcg5RMOHiykxTqFSwUzDgUlAAMsOhTAUFXQU%2FIDYEs4ESfkAJQ0uIFEgyOLVEAcYDSieDpKFckHR4amZ6RklqioKhqTE2YSNTkGaoMQA%3D

Those colors look so random

Compared to the other ones that have more IMO "algorithmic" looking colors

it's the squeeze transform that gives very different results

but making things that don't look super grid-aligned with squeeze is pretty hard

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKz0wB0oYGRiZcHqmZ6RklEHaQcwhQMriwNDW1KpWLKzNNIVzBTsGAS1fBT0HXGEwZAwA%3D "Alien scripture", 29b

For some weird reason, this variant is 24 bytes: https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOTKTFOoVLBTMOBSUAAya8JroBwFBV0FPygLKOEHFwZJBKeWoPEMueDiAA%3D%3D

First I only saw the blocks, but there are details in some of them which are pretty cool!

The url points to a different image it seems

The main thing is to keep the residuals close to zero (and also not only positive). Things like this https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKz0wB0oYGRiZcHqmZ6RklEHaQc4iCAVdwYWlqalUqF1dmmkKygp2CIYhRE14DZJpy6SoEp5YAFQGFwt09gEIGQKFwBV1DMGUIlTcCAA%3D%3D

Oops, looks like I forgot to click "Share". This code produces something slightly different but very similar - i'm not sure of the exact code I used for that image anymore. https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOQKLixNTa1K5cpMU0hWsFMwMuXSVQhOLQHKAEXCgSIGQIFwIBdE6hoCAA%3D%3D

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKz0wB0oYGRiZcHqmZ6RklEHaQc4iCAVdwYWlqalUqF1dmmkKygp2CIYhRE14DYppy6SoEp5YAVQHF%2FIAiBkCBcLARqSkKuobIPEOoWl0zAA%3D%3D

'Deep Purples'

Window on the horizon https://jxl-art.surma.technology/?zcode=bY2xCoAgFEV3v%2BL%2BQKDZG1xa2gsqaI6ycikIh%2Fr7nmVD0CCc%2Bw5yqt3Z1ffebSsyURcttBBuwokcUgCMXUQgQclP3cyiZKHMo4JsrMe7WA9Bxxl0Z928eDtCkf47pxSDB3%2FMjHkzYZL8ZlKin%2BzD2sgL

Construction x 2 https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMObiykxTqFCwUzDgUlAAMsOhTAUFXQU%2FIDYEs4ESfkAJQ0uIFEgyOLVEAcYDSieDpKFckHR4amZ6RklqioKhqTE2YSNTAwUFLoRBAA%3D%3D

A variation ~ note that it is 40 bytes! https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMObiykxTqFCwUzDgUlAAMsOhTAUFXQU%2FIDYEs4ESfkAJQ0uIFEgyOLVEAcYDSlcCpc3MLKACMAWGcD5QSTLIBLgASEl4amZ6RklqioKhqTF2CSNTAwUFLoR9AA%3D%3D

I wonder if one could make a game entirely out of this art? (bonus points if every scene including the player controlled objects were a single jxl_from_tree image)

"capture screenshot"... hmm, something's wrong, it's only creating a 73 byte file...

I am talking about jxl version

I presume sipa was talking about a hypothetical screenshot of the proposed game.

indeed

ha ha

I really wonder how far the context modeling can be taken in the future. Will we see 5% improvement? more?

What is even going on in this channel?

Unfortunately, I can't even encode all my screenshots at -s 9 right now, it would take over three months.

<@!353367770030931970> https://jxl-art.surma.technology/wtf.html

Pointillistic https://jxl-art.surma.technology/?zcode=C3IOUTDn8i%2FKTM0rSSzJzM9TMOLiykxTqFCwUzDgUlAAMpOBTEMgE8wJKEotg0qBgK5CcGqJgiGCGx6uoK1gDFMd7u6BohhJFqYXakklyBIDI4gcQgbGNjI24gIA

I have no idea what any of that means.

Unfortunately I don't know much of anything in compression.

Is it kind of like macroblocks?

I am no image format genius either, but what's happening in this channel is people are using the MA trees from modular to make interesting images

the MA tree is like a prediction of the actual image that's used for compression

but in these images that prediction IS the image

so it's ridiculously small

I don't know the logistics fully, you should ask jon or another of the core devs if you are confused because i'm a little confused too 😄

also these snippets of code such as ```RCT 7 Orientation 2 if x > 0 if c > 1 if Prev > 0 - Set 10 - WW + 3 if WGH > 0 - WW + 3 - Set 0 if y > 1023 - Set 0 - Set 232``` (the tree for image above from jjido) are a representation of the MA trees

also by messing around with some values in that one i was able to make this https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKLixNTa1K5eLKTFNIVrBTMOFSUAAyK4FMQyATzAnX9QsH8g3AfGQRI6iIgoKuQnBqCVwFjG%2FIhSmLkIGwjAA%3D

also this https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKLixNTa1K5eLKTFNIVrBTMDTgUlAAsitBbCATzAnX9QsH8g3AfGQRI6iIgoKuQnBqCVwFjG%2FIhSmLkIGwjAA%3D

actually when i play with it

this is just a macroscopic form of the other squeeze grid pattern

Looks like a lego brick birthday cake

A variation on the variation: https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMOTiykxTqFCwUzDgUlAAMsOhTAUFXQXHsnQ%2Fbb9wIMsQLAKU9gNKG5lCFICUBKeWKOgaGcAEgCoqgSrMzCygAiA1fnADoEqSgUoQAiAl4amZ6RklqSkKxnCz0SXAdkAsNAAA

reminds me a little of aurora borealis

Another variation: https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMOTiykxTqFCwUzDgUlAAMsOhTAUFXQXHsnQ%2FbT9XIMsILAKU9gNKG5lCFICUhKdmpmeUpKYo6JoYGMCEgeoqgerMzCygAiCVfkBsCOcDlSQDlSAEwIYhGY1mvAnYcF2F4NQSBQMA

Crazy out of bounds values are fun, the darker-than-black stuff gets clamped to black anyway

That's also how I made the mountains in the sunset image

The interesting thing is that this darker than black is actually darker than black when you do blending with multi-frame

So you can have blacks that still darken stuff even when overlaying it with opaque white

And you can make negative alpha which is even more fun

It basically does the opposite of what blending would do

"make the color more different from this one" instead of the usual "mix it X% with this one"

Something like that at least

And people are complaining about J2K being the only wavelet image codec... well, now JXL has something similar 😉

Squeeze is a kind of modified wavelet, the most simple kind of wavelet (Haar) but modified with a nonlinearity that makes it behave quite different from usual wavelet transforms (smooth in smooth areas, blocky in non-smooth areas, no ringing)

For the main lossy codec jxl uses the old battle-tested DCT though, which is probably the best thing that can be done in a classical codec in terms of speed/quality trade-offs.

Just refined a lot, with adaptive quantization, variable block sizes, filters, better entropy coding, etc.

JXL art in vardct mode would open up an entirely new can of worms/possibilities

Everything we do now, could also be done with the DC image (the 1:8 scale version of the image)

But then we could also generate trees to encode the control fields that encode block sizes, quant weights, chroma from luma multipliers, filter strengths

The AC itself does not use modular, but you could also have asymptotically zero-bit encodings of interesting non-zero coefficients

Another currently not yet explored possibility is to use the lz77 option in the entropy coding. That way you could e.g. do a repeating sequence of predictor residuals for basically free (instead of what we do now: all zeroes), which would still get interpreted according to the MA tree.

E.g. `- W + 3` currently means "take the pixel to the left, add 3, then add 0"

We can also do e.g. `- W + 3 + 5 * number`, where `number` is taken from a repeating sequence like 0, 1, -1, 0, 1, -1, 0, 1, -1, ...

With lz77 that sequence would just be encoded once and then a match of large enough length would do the rest

The residual multipliers in the tree are currently not useful since we use zero-residuals anyway, but the bitstream has it. It is how we do quantization in lossy modular or for the DC.

I think we only have multipliers >= 1 though, right <@179701849576833024> ? Not negative ones I mean

(or zero for that matter)

Drawing stuff with splines should also be fun. <@604964375924834314> how hard would it be to add a `Spline` option to jxl_from_tree ?

I suppose possibly not too much? but it would likely depend on the kind of interface we want for the color/thickness data

in the format, it’s stored as DCT32 coefficients

I believe so yes

so if the user enters that (or DCT8 or DCT16 coefficients) manually, it’s not too much work for jxl_to_tree, but also not very user-friendly

What is the thickest spline we can do?

not sure there is an actual limit

I mean a practical one

the “thickness” is actually the σ of a gaussian

Drawing a curvy "jpeg xl" on top of the sunset image would be neat

could also use patches 😄

first frame: a font second frame: uses that font

Could even upsample the font by e.g. 4x too, right?

in principle yes

A demuxer would be useful that lets you take an existing jxl as input to jxl_from_tree, makes the first frame a reference frame from the jxl file, and the second frame can use patches from it

(i don't think we want to manually make a font with trees)

no, we don't xD

even better if we could take a .ttf or whatever and actual text though

how to prettify this

Orientation 6 RCT 4 if x > 0 if W > 0 - AvgN+NW - 1 if W-NW=4 > 20 if y > 61 if y > 813 - N - 1 if c > 1 - Weighted 233 - Set 0

mhhh.. it would look pretty nice without the green stuff

maybe remove the last branch?

(I think the tree is truncated)

no this code don't work

why

this also not

https://jxl-art.surma.technology/?zcode=C3IOUTDn8i%2FKTM0rSSzJzM9TMOLiykxTqFCwUzDgUlAAMpOBTEMgE8wJKEotg0qBgK5CcGqJgiGCGx6uoK1gDFMd7u6BrNjPFShphKLVCGpJJcgSAyOIToiUARLbyNiICwA%3D

https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMOTiykxTqFCwUzDgUlAAMsOhTAUFXQXHsnQ%2Fbb9wIMsQLAKU9gNKG5lCFICUBKeWKOgaGcAEgCoqgSrMzCygAiA1fnADoEqSgUoQAiAl4amZ6RklqSkKxnCz0SXAdkAsNAAA

pretty nice 3d effect

i'll call this jein

or artaklsl (jein)

all this three arts in jxl and png format

ah sorry i stealed wb

what i made isn't mine

see

https://discord.com/channels/794206087879852103/824000991891554375/835831200420462603

https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMObiykxTqFCwUzDgUlAAMsOhTAUFXQU%2FIDYEs4ESfkAJQ0uIFEgyOLVEwdjIBMoHKkgGKYByQQrCUzPTM0pSUxQMTYywCRsZGygocEEMMuDiAgA%3D

What is your formula?

Do not know maybe i can check history

another image stealed

i can't use this program

Variation on Scienta's https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKLixNTa1K5QpyDlEwNOXyL8pMzStJLMnMz1Mw4eLKTFNIVrADshQUgMxKINMSyARzwnX9woF8AzBfQUFXITi1RMEQhQeRQ8hAWEYA

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKLixNTa1K5QpyDlEwNOXyL8pMzStJLMnMz1Mw4eLKTFNIVrADshQUdBWCU0sUDIEsoGAlUNCQCyJkDBRCloaxjQA%3D

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKLixNTa1K5QpyDlEwNOXyL8pMzStJLMnMz1Mw4eLKTFNIVrADshQUdBWCU0sUDIEsoGAlUNCQCyJkDBRCloaxjQA%3D

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKLixNTa1K5QpyDlEwNOXyL8pMzStJLMnMz1Mw4eLKTFNIVrADshQUdBWCU0sUDIEsoGAlUNCQCyJkDKXNDIByyOpgbCMA

https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMOTiykxTqFCwUzDgUlAAMsOhTAUFXQXHsnQ%2Fbb9wIMsQLAKU9gNKG5lCFICUBKeWKOgamRibciFxjAyh8kANlUANZmbGJqZQIZAmP7iJUEXJQEUIAZCS8NTM9IyS1BQFY7hl6BIGIAmIpQYA

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKcg5RMOTiykxTSFawA7IUFHQVglNLFHRNDYBsoHBNeA1QwgjMBQuEA7kQDkhtuIKuERJH28jEGIfC1Mz0jJLUFAVdYxNMQWNTAA%3D%3D

This one please can you make endless variant of it

https://discord.com/channels/794206087879852103/824000991891554375/835873252139728916

https://jxl-art.surma.technology/?zcode=Cy4sTU2tSuVyyixJSS0oyVAw4%2BLSVQhOLVEw5cpMU0hWsFMwAAqEK2gDBSC0EYwGAA%3D%3D

December

what i produced in two hours

<@!794205442175402004> can you connect the jxl art reddit

Yes. Done.

still don't appear in <#805722506517807104>

New posts to r/jxlart will go here

Can't make it post existing posts though

in reddit or in jxl art

Base sequences https://jxl-art.surma.technology/?zcode=i4h04vIvykzNK0ksyczPUzDh4spMU0hWsFMw5FJQ0FUITi1R0DU1ALKBwjXhNUAJIzAXIuAHFjCACIDUh6dmpmeUpKYAmUaYgtoKhuiaTbDpNTbBFDQ2BQA%3D

Zen swamp https://jxl-art.surma.technology/?zcode=C3IOUTDm8i%2FKTM0rSSzJzM9TMOHiykxTSFawUzDkUlDQVQhOLVHQNTUAsoHCNeE1QAkjMBci4AcWMIAIgNSHp2amZ5SkpgCZRpiC2gqGSJrBphli1WxsgilobAoA

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMDTgCnIOUTDk4spMU0hWsAOyFBSAzEog0wDIVFDQVfADC4JY4Qq6UPlkuDyQE1CUWgbnI4uYGMDEIOaYovAMuRBsXSOYYeFAfZYIk0BcQ0MUc8JhqqHc1Mz0jJLUFKDbDFD16aLaD1doaIpimhEA

Platformation: boss level

ok i saved those two

if you have other write bsf or bsp

bsf or bsp?

based on

bs

We do, no?

copy url

<@!228116142185512960> am I supposed to update that file since I signed Google CLA? https://github.com/surma/jxl-art/blob/main/CONTRIBUTORS

You can

You don’t have to

Jon has also made a contribution (much bigger than mine), maybe he should update this file with his data?

https://jxl-art.surma.technology/?zcode=Cy4sTU2tSuVyyixJSS0oyVAw4%2BLSVQhOLVEw5cpMU0hWsFMwAAqEK2gDBSC0EYwGAA%3D%3D

could you post this

December Paul97

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKLixNTa1K5QpyDlEwNOXyL8pMzStJLMnMz1Mw4eLKTFNIVrADshQUdBWCU0sUDIEsoGAlUNCQCyJkDKXNDIByyOpgbCMA

Hell piano Paul97

https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKcg5RMOTiykxTSFawA7IUFHQVglNLFHRNDYBsoHBNeA1QwgjMBQuEA7kQDkhtuIKuERJH28jEGIfC1Mz0jJLUFAVdYxNMQWNTAA%3D%3D

artWW Paul97

https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMOTiykxTqFCwUzDgUlAAMsOhTAUFXQXHsnQ%2Fbb9wIMsQLAKU9gNKG5lCFICUBKeWKOgamRibciFxjAyh8kANlUANZmbGJqZQIZAmP7iJUEXJQEUIAZCS8NTM9IyS1BQFY7hl6BIGIAmIpQYA

modestuart Paul97

https://jxl-art.surma.technology/?zcode=8y%2FKTM0rSSzJzM9TMOEKcg5RMObiykxTqFCwUzDgUlAAMsOhTAUFXQU%2FIDYEs4ESfkAJQ0uIFEgyOLVEwdjIBMoHKkgGKYByQQrCUzPTM0pSUxQMTYywCRsZGygocEEMMuDiAgA%3D

araaat Paul97.

These allmine