JPEG XL

huh did it publish my thing or

its usually instant

trying again

...it just refuses to?

no zcode link given to me or anything

since it wont work

Bitdepth 24 Upsample 4 Width 1024 Height 1024 Squeeze RCT 1 if y > 256 if y > 768 - Set 100000 - Weighted 128 if x > 256 - AvgAll 640000 - Select 64000 - Set 0

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/927686049231155210/message.jxl

Early practice #3 I seem to have issues escaping green yellow black

Squeeze is hard to tame

eyy looks good to me

for what it is

but I think I'm getting the hang of conditional logic and properties

which is an absolute win in my book

btw so far I'm loving this, thanks for creating the predictor in JXL haha <@!794205442175402004>

generative art always seemed a bit too inaccesible to me and this is just ideal

wow this one is remarkably 3D

What if we could have a cropping tag for JXL art so we could hide that?

jxl has cropping in the bitstream

https://jxl-art.surma.technology/?zcode=jZDNDoIwEITvfYp5gU1apMGTBw3GEzH-pGcCVZpIJMJB394FpBZP3mYm37STXbuutE1XYSkOmxOUMK5kp1UkdtZdq26Q20de2_29hQRpJc5Nm9fNzTIu3AUFVqwAli-WkiVAyEDqI4-2Q6T1yBSeYfP0pucMlNd9h8aSf1pPKPssaE781_eAoTkzppSlnJIK4mGtASW_GdSf5XT2zTQnlsFe0xcXMpxshgvbEhSHKRKm3g

FramePos can be used in the jxl art tool to reposition the frame w.r.t. the canvas

Oh so that could be used to hide that then

**weatherman115** _“pseudo-3d”_ 2022 image/jxl 38 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMDTg4spMU6hUsFMwM7bkUtBV8AtXMIIJmRoaQoV04WIGXApAlh9MFiStoGtqaARmOpalO%2BbkgNToKoQrGAIA

because publish function didnt work for me AGAIN

Bitdepth 16 Upsample 4 Width 1024 Height 1024 RCT 6 if c > 1 if |W| > 0 - AvgW+N 500000 - Weighted 1000000000 if x > 0 - Weighted 70000000 if |N| > 5 - Set 500000000 - Set 900000

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/933871029430915082/message.jxl

returned after a break, did something kewl I think

looks best with Upsample 8

Likely if you use huge numbers like that, you end up producing an out-of-spec bitstream that has no guaranteed decode result

I have to check how infranview decodes it

But so far its consistent

Well currently only one jxl decoder really exists, since everything uses libjxl

libjxl is the golden standard then ;)

time to add it to the spec

the spec defines things as if infinite precision can be implemented, but it also says that int32_t suffices to represent modular buffers

(without relying on overflow arithmetic)

if at some later stage, we want to extend the spec to allow higher bit depths (to use it to store doubles losslessly, say), then it will not be good if we already define things to happen with overflow arithmetic in int32_t

i.e. for now, bitstreams that exceed int32_t are just unspecified

Does this mean that the current (decoder) implementation doesn't actually support a fully featured jxl image?

no

the current decoder does support the full current spec

it's just that _if_ (big if) we would at some point in the future _extend_ the spec to allow > 32-bit images (which is a very big if, since it is hard to imagine actual use cases where _that_ kind of precision is available/useful), then the current decoder might be producing a different result than a future decoder that does implement that new extended spec, on images like these that are undefined in the current spec

Ah, so the spec is limited to 32 bits, but in theory you could do a 48, or 64 bit image with most of the existing mechanisms still working.

Like a JXL-XL format which is a superset of JXL.

either way gonna keep abusing jxl till I can't for very nice results

<@!794205442175402004> a suggestion if you do intend on expanding the spec, use integer sign extension, Ie if the signing bit is set, clear it, then postpend the next 32bits atop. that way legacy decoders can still decode images that are <=INT32_MAXVALUE

the only issue would be undefined behaviour if the image is above that threshold

even in an extended spec, likely we'll want to keep it true that <=32-bit images can be decoded without requiring 64-bit buffers

if you don't, it would cause a large amount of disruption between early adopters and late adopters

wherein, some platforms/apps would support one format or the other, usually not both

images that do stuff like `Weighted 1000000000` can probably overflow even 64-bit so it'll likely remain out-of-spec even in a theoretical future extended spec (which is probably not even going to happen in the first place)

given how this channel died a bit, thought I'd share what I ended up using it for! cover art for a track coming up from me :)

post processed the og jxl result to death, applied some textures, my own logo and track title

gave the track title text a bit more of distinct texture by baking a grayscaled version of the jxl pattern into it

planing to use JXL generated stuff for all of my covers when self releasing comin forward

it will certainly create a distinct thing about them hah

<@!794205442175402004> btw the code for JXL art you put out is fully open source under a non restrictive license, right?

**\_wb\_** _“Spotlight”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOQKcg5RMOTiykxTSFawA7IUFIDMCiDTAMhUUNBVCAcLQli6UHm%2FcF0%2FJCV%2B4QrGCDVGXAA%3D

Jxl_from_tree is part of libjxl which is BSD-3 licensed

oh I mean the algos for the art themselves haha

not jxl_from_tree

What algos?

dunno what to call em

just what gets you the art

Ah you mean the trees themselves?

YES!

Yeah you can consider anything I produced CC0, as in: do whatever you want with it

<@!171274876991176705> ``` Copyright (c) the JPEG XL Project Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ```

right, might wanna use em maybe in the future in a modified form for my own stuff hah

In short, you only need to hold a licence for any code. creations using the software should then be under CC0 licencing.

If you use some jxl art I made and modify it, no need to credit me

tbh I learned that gimp ISNT GPU accelerated at all, atleast with Radeon GPUs while working on this

actual pain when I had to wait an hour for something to render out finally

hmm

If you use something exactly like I made it, you can still do whatever you want with it but if it's a titled piece by me or by someone else I think it's nice to acknowledge the original author

also this is very cool and reminds me of the light coming out of a prism

<@!794205442175402004> maybe we could think about implementing an OpenCL GPU tool specifically for generating images from handcrafted streams. something like a converter from handcrafted to VarDCT. as simply said most of the handcrafted streams i've come across take upwards of 500ms to decode, some even being as bad as 30+seconds.

**\_wb\_** _“At bitdepth 5 I now use this as my phone wallpaper”_ 2022 image/jxl 29 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKLixNTa1K5QrPTAHyjUzNuDxSM9MzShRMDY24QguKE3MLclIVLLi4MtMUkhXsgDqAjHAgw9CAS1chOLVEAUSHKxjCeVwA

Yeah modular decode of a single large group can be pretty slow

Converting to vardct will make it a lot larger though in filesize

> 30+seconds So there are worse things than my spline abuse. "warble" took 69s on my system with old djxl, but veluca's optimizations cut decode time by 66%.

"spontaneous rupture"

Made during last compo. Unfortunately, latest djxl will not decode it.

APNG preview

Yes, i've had 1 image take roughly 2mins, given it was running in the browser.

Oh, well try opening the above anim in a browser. O_O

Had to get rid of it from my test data because i cant be asked to sit around for 2mins waiting for an image to load

Chrome stumbles for a while, even after ~~decoding all frames~~ looping through the image, the animation is not stable for some time. (E: I guess it's a bad assumption that everything is decoded when the image loops.)

Im using a wasm build. The idea was if native jxl support wasnt there i would convert the images using client wasm.

And i got that running with acceptable speeds, the only issues are with handcrafted bitstreams especially large ones where you'd get either a ram overrun or it would take forever. Much slower in most cases to just downloading a VarDCT version.

But that is the trade off for those images, size for speed.

Oh God is this just spline abuse

fuck those poor splines

So decode is faster if the image is encoded with cjxl? Can you point to a representative example of such an image?

I used imagemagik to make most of the images, then got my hands on a few hand coded ones. But yes using VarDCT is faster to decode then handcrafted bitstreams. Just get an image encode it then compare the decoding to the handcrafted image on say jpegxl.io

The VarDCT image will ve many magnitudes larger but will take in the ball park 30-50ms to decode

Well, VarDCT is just generally much faster than modular.

The handcrafted one which is only 117 bytes from jpegxl.io will take 500ms

All streams from jxl_from_tree use modular encoding.

Yes but for the web in some cases it will be better to use VarDCT as downloading an extra 50kB is nothing.

I'd guess modular vs modular whether handcrafted or encoder crafted is similar speed.

So having an easy way to convert from modular to VarDCT would be pretty good

Although it would depend on encoding tools used by encoder.

For example a good use case outside of the web would be compiled textures. Ship with modular then decompress to VarDCT

well that's not very different from converting any random png to jxl 😛

And maybe cache smaller but complex textures so you can remove the decoding times.

I know so far the best i can think of is just decoding then recoding

yeah I doubt there's much more you can do

maybe preserve splines

I was thinking of more of a progressive encode, im not too sure on how modular looks under the hood, but if you could generate a region and then pass that onto the encoder while generating the next region, that would be significantly faster then doing a full decode and recode. Provided you have more then 1 thread.

alt for reasons

Challenge: reverse-engineer the JXL art above.

I mean I said what I did to the previous ver before haha

but I guess one can try and reverse engineer what I did to the og image to get it all post processed

Ah, I had overlooked the link to the original and hadn't looked closely enough to notice the similarity.

**\_wb\_** _“Another phone wallpaper”_ 2022 image/jxl 38 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0qaGRlweqZnpGSUKhgZGJlyhBcWJuQU5qQpGXEHOIQpGllxcmWkKyQp2CoZcCgpAZkBRahmQZ2RgAOQrKOgqBKeWKOgaw7mOZemOOTkw1eFApbpGSHJ%2B2n6uCrqGSHqNLA24AA%3D%3D

Good

**\_wb\_** _“Yet another phone wallpaper”_ 2022 image/jxl 61 bytes https://jxl-art.surma.technology/?zcode=ZY%2FLCsIwEEX38xV3XwpJSaArQUVwFYoPshYb24BCqaHf76SVNOju5nBn5mTnQ%2BuG0EMKsr7loGVFR%2Be7PjCrFF2H9%2B01PB0UnfYXSCL%2FwB0bCAK%2BUXKcH00zuomBEmJGQImzCyhlAlmrSnDGllGpMhanbT67LsxrCxHJgZcfxjFq%2FUjUmdV26mxhUC%2BfMPG0Tiuiif4rs4rOkSnMgYVpvSCj6gc%3D

**\_wb\_** _“Synthwave Rain”_ 2022 image/jxl 38 bytes https://jxl-art.surma.technology/?zcode=XY7NCsIwEITv%2BxTzAoGkLdiTEEXsScQfclYS20CEkIaCb%2B8arEKP3zfDzm58ti7mATWdthcoMt4yVStJnfP9kNG0kq5xvD1jcGiI%2FANm32ENSQDDMblJ38ddSuwUO0BAT70OoVRK6cBZW%2BCTGogZOHt9b%2F3Ssussv%2FSXZ5fnQcN9UdOiLKqlUURv

**Razor54672** *"A Maze of Broken Shards"* 2022 image/jxl 39 bytes > Changed some parameters from Jon Sneyers' "*Another phone wallpaper*" https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0qaGRlweqZnpGSUKhgZGJlyhBcWJuQU5qQpGXEHOIQpG5lxcmWkKyQp2CoZcCgpAZkBRahmIZ2oA5Cso6CoEp5Yo6BqZwLiOZemOOTkKxhDV4UClukZIcn7afq5AESS9RoYGXAA

ohhh fuuuuck this is pretty!!

**\_wb\_** _“A New Style”_ 2022 image/jxl 39 bytes https://jxl-art.surma.technology/?zcode=ZYw9CwIxEET7%2FRXTSyCbi4iNoCJYBfGD1OKtdwGFcIb7%2Fa5cCtFu3sxjNqm0kkuPOR23ZzDF1H6IHe0ldX0BW%2Bfpkl%2FXZ36ICpTuuGEFS4DGwyCj0lIJMDhJgWH7RVzFqJZb1GE9dnEWIkwzqboHE3b19sfxf5Wn6dvSGw%3D%3D

Experimenting with something that does _not_ rely on the weighted predictor or its MA tree property to produce interesting patterns

**\_wb\_** _“A New Style 2”_ 2022 image/jxl 36 bytes https://jxl-art.surma.technology/?zcode=XYm9CoAgFEb3%2BxTfHoJaUlNQETTdIYL7Apq6NUjPn65t52fNxYenJEx0bhd6kuyrOWPpCDmmAqPtQJRvCGZYpwlQYKheN6ydFe91NWtreaN0LFDG%2FYoZiT4%3D

**\_wb\_** _“A 42-byter”_ 2022 image/jxl 42 bytes https://jxl-art.surma.technology/?zcode=RYzBCsIwEAXv%2BxXvLoEkWNGLUEX0JCLKnquJbcCWkIbi57sFW2%2Fzdobdhex8zA2Mpuv%2BBlMQBye7MJZOPtRNFmWXdI991ca3hyUKLzyxhSFA8COoBQEFFj2R%2BnkeU63%2FibLTEntJfigf%2FSGl%2Bc1YHVPlgu8yVpv5Vg41L86MNX0B

**\_wb\_** _“Stalactites or something ”_ 2022 image/jxl 35 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKcg5RMOQKz0wB8kwNjbg8UjPTM0oUDA2MTLhCC4oTcwtyUoEKuDLTFJIV7IAsBQVdheDUEgVjAyATKBoOEgWxQRKOZel%2B2n7hCrqmEBGgvJ%2BunytQCYQP0ZyTmgzUDxeAaTLkAgA%3D

**\_wb\_** _“Random or regular?”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=RckxC4MwGITh%2FX7F7SVgvupaUCk4ZShK5oIxBhQCBn%2B%2FiYvbPe91Ic0uppU1fv3IN2yYsxotGFzwa6KupMYUj%2F8eN0cBwkLDD5WALFuZb2aVRSq2pzevXO77CZZKo9BSGlw%3D

**\_wb\_** _“Strange lines”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=VcuxCoMwFIXh%2FTzF2SWQe9FVsEXolEGUzIJRAxUCDT5%2Fk9Hx%2B%2BF%2FxbyFlE8KpvdMCx%2B3ok4UnxCPM1OstljSb73SN1ABxJ2OPY1YkBXGjcVVpOFwH64pxegj%2BDKg0lPU4g8%3D

**\_wb\_** _“Peace”_ 2022 image/jxl 190 bytes https://jxl-art.surma.technology/?zcode=7ZVRS8MwEMff8ynuXSqXJmnXF2HKwKeBTtjzsN0W0Towk%2BmnN13S9ExRJ30RaUvhf%2F9crtdfr%2FRSm7LamS1M2O3VHSBjS13akCMiu670Zmsgs5Itdo%2B6rm72q9ro95XRz%2FW0fNi%2FmKeqNpCGBAb24AiDzj9WZFiNRPpOEKTCoLniRDs%2FVdhcwRdWz%2BrSkx0BfwvYwg2AleigqoL4Nkeg07JwegR8IuC8mU4PLydTm4kOak6mvMmXnwD%2Fb8LnYkAVP8MEn4h0mFuugqa%2BIK9Eej2iP328i6zjPYl0w9glKdUF7UqrW%2FpF1qOv13CAi%2BOfFMAGbzZovyUfSh8ejXtrtCFAAovK9OJURht4nJDGW4Qz%2FLJSrpkDubtvhlRuVhXSStPXzfxsPoOE98xlZ9KmfVWBP3SMXz7Bbx7xAw%3D%3D

wait YOU CAN USE SPLINE TO WRITE LETTERS LIKE THIS? IT NEVER HIT ME!

**_wb_ / Korro** _“Strange lines [Edit]”_ 2022 image/jxl 28 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKcg5RMOAKz0wB8gwNDAy4PFIz0zNKIOzQguLE3IKcVKA6IMhMU%2FBTsFPQNeNSUACxdf1cgVwDIE9BQVfBsSzdTxsoomuEIhCuoGvIBeKGK5gCAA%3D%3D

i like that number of bytes lol

**\_wb\_** _“Wuthering Dithering”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOYKz0wB0uZmFlweqZnpGSUKhgZGJlxBziEKhqZcXJlpCskKdgoGXAoKQGY4kGlkDGQrKOgq%2BLkq6MI5jmXpftpAEUMuEC84tQRoMgA%3D

**\_wb\_** _“Wuthering Dithering 2”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOQKz0wB0uZmFlweqZnpGSUKhgZGJlxBziFAOa7MNIVwBTsFI2MuBQVdBT9XBV0o07Es3U8byDfkAgA%3D

**\_wb\_** _“Wuthering No-Dithering”_ 2022 image/jxl 29 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKz0wB0uZmFlweqZnpGSUKhgZGJlxcmWkK4Qp2CkbGXAoKugp%2Brgq6UKZjWbqfNpBvyAUA

The dithering ones you should see losslessly, zooming in

**\_wb\_** _“The AI is trying to learn to write Arabic, failing so far.”_ 2022 image/jxl 29 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKz0wB0qaGRlweqZnpGSUKhgZGJlxcmWkKfgp2CiZcCgq6Cn7hCrrGBmCmY1m6nzaQb8gFAA%3D%3D

**\_wb\_** _“Erosion and shadows”_ 2022 image/jxl 31 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOYKz0wB0qaGRlweqZnpGSUKhgZGJlyhBcWJuQU5qQomXEHOIQqGplxcmWkKfgp2ChZcCgq6Co5l6eHafuEKuoYGQD5IStfPFSgL4iHLG6PxdY25AA%3D%3D

**\_wb\_** _“Dark phone background”_ 2022 image/jxl 33 bytes https://jxl-art.surma.technology/?zcode=VYoxCoQwEEX7OcW%2FwEAiibCNxVbbi6QWndXALmTZ2Hh6xyiC1bz3%2FjxjHiXlGY5CHPV6Z%2BglcZozHrWhLv37b%2FoIKmp%2Fi8gqRPGNAQ0sAYpB0SkCrMy24NnZFzucQ0n2TMd%2FdbNr3GVnRisZhjY%3D

**\_wb\_** _“Magnificent Magnification”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=LYuxCoMwGIT3e4p7gUAMseDi4NRdSmZpfk1AIWI66NObtJ3uu%2Fu4IWYvKQcauOhLtlbjKXEJmd1D45WOaUur0GLcPyKXAHHmmz2bCmcBa6Dovh%2Fx1CCLcEVUJBVHyVTmXxwr%2FUaNGw%3D%3D

**\_wb\_** _“Yet another dark phone wallpaper”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOUKz0wB0SYGXB6pmekZJQqWZgZcoQXFibkFOakKJlzBhaWpqVWpXEHOIQqGplxcmWkKyQp2CgZcCgpAZjiQaQlkKijoKgSnlijoGhpAeY5l6X7afq4KhlwgXjiQBgA%3D

Hi! I've stumbled over jxl-art yesterday and really like the minimalism of writing predictor trees for generating art. I thought that S-expressions might be particularly suitable for writing predictor trees, so I built a little mode/tool - I called it sjxl - inside Emacs for that. It's basically a small Lisp-like templating/DSL on top of the syntax used by `jxl_from_tree`. This also enables the procedural generation of predictor trees in Elisp. Header expressions are also supported, e.g. ``` (rct 0) (bitdepth 3) (squeeze) ``` I'm currently cleaning it up a bit, I will put it on sourcehut and maybe it's useful to someone who uses Emacs and wants to create jxt-art 🙂

nice!

sick dude

**\_wb\_** _“The Atrocities of War”_ 2022 image/jxl 43 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMDTgCnIOUTA05eLKTFNIVrBTMOBSUAAyK6BMBQVdhXAFQzhL1xAiHw6XB3Iq4RyInG54uK5fuLZfeDiSBFyboYGRMVwMZKpjWbofULGCrgWKsHtRYkpmal4J1HZkta4ItWBHmcKcCjQFbDwA

**\_wb\_** _“No idea what this is”_ 2022 image/jxl 42 bytes https://jxl-art.surma.technology/?zcode=PY1NCwIhFEX371fcfTxIa6BVUDG0k%2BgD10NaCRViMr8%2FHZ6z85x7vW8fsvMxv9DR%2BXCFIhtcJaXpFn%2FDJ7491kThgTu2JQbK85T82KckAmBcfIbuBHbj0y6MBUvdliJvprASmyqWE8%2F5SgnLgJkHmjymwQX%2FzWiy9XqwlsvlTxn6Aw%3D%3D

**\_wb\_** _“Again no idea what this is”_ 2022 image/jxl 35 bytes https://jxl-art.surma.technology/?zcode=VYo9C8JAEET7%2BRXThwUvubSCiu0VfrC1kFUPFE6MKfLrXaIR7N57M%2Bvcd1b6KxvsNgeGFpo71zbUOJbn6V5uxoj942U2GgAyn6lcUqLzZEnS1sNi8t%2FefJUUroZLqvwk4T9qlZRzm29KqfEJzhFv

If any Emacs person wants to play around with it, I just pushed it to sourcehut: https://git.sr.ht/~mntns/sjxl

**\_wb\_** _“Digitalizing Figments”_ 2022 image/jxl 33 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOYKz0wB0qYmBlweqZnpGSUKlmYGXKEFxYm5BTmpCkZcwYWlqalVqVxBziEKBlxcmWkKlQp2CiZGXAoKugrhYC2pKUAZBQWgVDJQyhDIBHPCgRxdIzAPpNaxLN1P289VQdcQLhScWqIAUQBhA6UA

directly inspired by the emacs plugin + obviously surma's jxl-art https://embed.moe/jxl_from_tree?tree=H4sIAAAAAAAAA%2B3QsQrCMBCA4f2eIi%2BgXNokl6yC4F7EWWiwgVoC5v3R3AV06FbHkuX%2Bg8vwnVIZYy6T0g6u%2BXV%2F5jkqA7c0fnYdIlxiekyFRxjynJYIRuGWB5uu%2F3F%2FtBt%2F6FD1CAaVRXA8e541cuhOykg5Kc91XsbGuGt%2BNYk1A2sSawbRJNEMokmiGUSTds11Ta2ZU%2FfsWctLVdGalZTbtHatvfTOuspqhZWE1QorNVbbWKmx2sZKjdX%2Bsh7UEIvCN%2Fvf0eR%2BBQAA

Nice!

finally continued the svg to splines

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/954003863382392832/out.jxl

Neat! Going to put it on github?

I wonder if it would be doable to have thick splines instead of outlines for the text, probably quite non-trivial to do that I guess...

Yeah, gonna put it on gh along with a blogpost on how I approached it

best I can think of for text is eroding until it's a single pixel

turns out centerline of a polygon is a whole other research topic

**\_wb\_** _“Yet another phone wallpaper”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsODiCs9MATJMTQy4PFIz0zNKFCzNDLhCC4oTcwtyUhWMuIKcQxSMubgy0xT8FOwUDLgUFHQVHMvSw7X9whV0DYFcoExAUWqZa1ERVB6kwr0oMSUzNa9EQdcIKgLRo2BoZM4FAA%3D%3D

**\_wb\_** _“Emergent Chaos”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOYKz0wB0qYmBlweqZnpGSUKlmYGXKEFxYm5BTmpCkZcQc4hCsZmXFyZaQp%2BCnYKplwKCroK4Qq6xoZglmNZup%2B2n6uCIRcA

**\_wb\_** _“Funky chocolate bar”_ 2022 image/jxl 28 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOYKz0wB0oZGFlweqZnpGSUKRqZmXKEFxYm5BTmpChZcQc4hCoYGXMGFpampValcXJlpCpUKdgrGhlwKCroKwaklCrpGcKYRFxcA

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/958696996833730671/jennifer.jxl

<https://github.com/wwww-wwww/spline>

how does one obtain `jxl_from_tree`, is that in one of the examples?

I believe it should be in `tools/` after a libjxl build if you set the correct build option, but I don't remember which.

Something like jpegxl_enable_devtools

Pretty cool how the traditional divide between vector and raster is getting blurred here

<@!288069412857315328> That's great. Do you have more examples, incl. the source SVGs?

i don't really have any other svgs

there's the jxl architecture one

svg2jxl JPEG_XL_codec_architecture.svg test.txt -s 1.45 -e 1.4 -b 4 -t 0.3 -tc 1

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/958967319428751370/test.jxl

24kb ! wonder what's the size of the equivalent svg? For this simple case, svg could heavily reuse components..

the jpeg_xl_codec_architecture.svg is 672kb

there seems to be a lot of invisible and unnecessary components in the svg

the svg could use some optimizing

Jeez, good thing Google slides is not a SVG editor 🤣

When talking about SVGs I never know if you should be talk about the uncompressed or the gzipped size, as on the web they are almost always gzipped in transit

Or even brotli'd

Compressed size is fair imo, though I am not sure how convenient it is to use svg.gz for storage and interchange too

Yeah, I think inkscape is the only program I regularly use that can open svgz files.

Thinking on it.. since xml is mostly uncompressed boilerplate, I'd say yes. Jxl splines can't be further compressed right? Ex: relative coords, grouped transforms.. maybe instancing like patches?

you *can* put splines on a patch frame, then copy them in multiple places

should work especially well for text

it would have the side effect of making also the initial coordinates relative (ish)

no grouped transforms though (unless you count upscaling and traslation xD)

also if the thingy is monochrome you can create multiple shades out of a single grayscale set ~cheaply

Multiple shades would be done how? Blend with kMul on a frame that is solid color?

Then it would also be possible to change the color to any gradient cheaply, since at high enough bitdepth, the Gradient predictor predicts gradients perfectly

(you can compute the gradient in XYB and set the XYB quantizers such that the delta between adjacent pixels is exactly integer, and then it basically becomes as cheap as a solid color)

basically

does it? (clamping...)

Clamping is not going to happen on a smooth gradient

Ah or does it

Anyway, the residuals don't need to be zero, if they're always the same that's also fine

Maybe we should have added a non-clamped gradient predictor too

Then again, probably Weighted can converge to that already

**jjido** _“Golden matrix”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOYKcg5RMDbjCs9MAXLNTQ24MtMU%2FBTsFEy5FBR0FcIVdA0NwCzHsnQ%2FbT9XBQsA

Can you use spline to draw Spirograph-like pictures? Are there colours beside black? How to optimise for size?

**\_wb\_** _“Splines example”_ 2022 image/jxl 99 bytes https://jxl-art.surma.technology/?zcode=pdFBCsIwEAXQfU4xF2hJ0jaNG8GKB9C60GUxESMaC043nt6qUymzs%2BYT8hbhMyFVQOdbPIEVm%2BUWpNjtKyHq9hKiX3dNxPBoMNziwp27O159RNByuCCgX%2FKTVA36NdSSTC4YlYyjJnUoSGRa%2FD1KofRrv50z52TDbMgZc0YumUuyZtZky2zJilmRZ%2BRVdPS%2FIhzhAPP%2BTQnUHr%2BnkfIJ

Here's an example. Unfortunately the jxlart page is still using pretty old code, which means the spline rendering is very slow

Here I am using XYB colorspace, you can also use RGB

The spline gets added to the background, so positive Y values make it brighter, negative make it darker

X has a small range so you need to use small coeffs for it. It's roughly the red-green chroma, while B is yellow-blue.

Both the color and the stroke width can vary along the curve. They are given by 32 DCT coefficients, i.e. the first one is the average value and the rest of the coeffs add cosine waves of increasing frequency to that average value

**\_wb\_** _“Splines example 2”_ 2022 image/jxl 72 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKcg5RMOCKiHTiCs9MAYoYGRhweaRmpmeUgJlcwQU5mXmpgaWJeSWZVYklmfl5jilZpcUlual5IBUwBVwKQGCgYKBnCCLJhTBTKICGcJeYUuwSY8pcomcKNsXUAIjALEMEE8gyRBKFs80NFIyhTAMUJlAG4iYUJlCBa14KNAq4MtMUkhXsgI7XVQhOLYHTFgYGAA%3D%3D

A smaller one is perhaps easier to play with

Splines can self-intersect: that just means those pixels get added to more than once

The thickness is not really thickness but more like a blur radius.

> How to optimise for size? idk, but there's this https://discord.com/channels/794206087879852103/824000991891554375/889236679326572565

Also I think the B in splines is effectively Y-B because the global chroma from luma is applied

The curve goes through all the control points and uses centripetal catmull-rom interpolation

**jjido** _“Lovebirds”_ 2022 image/jxl 73 bytes https://jxl-art.surma.technology/?zcode=zZFNDoIwEIX3c4q5AMlQKeDGRI3Gnb8Ja2KrjJFCoGw8vVPkBLoxzbRf3jQvkzcFG19hTCqBneV75T8M5%2FbJzh6H0nl%2BlZ4btzSPofe1dR5pagOiRvrliAP9gUOOUUwULinR8i99Ek2Snw44F79UaaFMaEZBU0J6pERIfsDGmSlK2HZlbQ9NL1aR0insO5asx%2Bgxg9P6gjGs2BvbjgsDvuEVFyJGWMjU4RkXaI2M8gY%3D

I don't understand what I am doing, but that may be for the best! <:kekw:808717074305122316>

I like the use of `Weighted` here.

**jjido** _“Lovebirds 2”_ 2022 image/jxl 66 bytes https://jxl-art.surma.technology/?zcode=zZDBCsIwEETv%2BYr5gcK2NDS9CCqeRSt4LibalRqLbi9%2BvZvgF%2BhFwk4eE5gs000jx7Cb%2Byj86oXvcemv81NuIQrIdPnZABb0y9EE%2BoMEh6IkSqKjnvsyp7aE1iZqNc5WVqlRqih5qqgzqcIpbaL%2FNGm2D9Zqc9NozH59QGlWLD5MMqAkw2ecsFCzwFGXTFfgyyDB689v

Kinda a yin Yang type of thing

Shaved a few bytes

**jjido** _“The Fire-Eater”_ 2022 image/jxl 71 bytes https://jxl-art.surma.technology/?zcode=zVBBCsJADLznFfOBQnZ1qb0IKp5FK3gu7mpXdC2aXny92erBs14kMEwmyQSm7s4xhXXfJImPRuI1zfypv8slJAFTPYwJMKMS%2FEupB%2F%2BBwwRF6WCttoYZjlX5xmesxxVnVmUb65SVyuygKeaNj71l8u8saXWLGu6QNSxtFlsYS%2FMoPnTSwlE8YI8pDBXYvTDEYyvB6%2BMn

How do you use the embed bot on the mobile discord app?

**\_wb\_** _“JXL logo (with alpha)”_ 2022 image/jxl 65 bytes https://jxl-art.surma.technology/?zcode=hY4xC8IwEIX3%2BxVvl0IaU9Mugorg5KBCZrHVBBw6ZNB%2Fb6hpONOCQ%2BDuey8fZ1zrLRoh6NC5h%2FVQlaDT7gJBW%2Bfbrg%2FpkjbP3l6J3B03rEMEhPEdx7RIWQ3rAF4BKFVHwFCTEFDgaLCIloTCK4nte1aZ0WSNzBo%2F1FLRmJqkj%2BFKK%2FbZoCj%2FnW3YhakkpWJwomJN%2FVucGllXZHjW%2B8XnzkPTOAn6AA%3D%3D

Nice, but why do you call it "JXL logo"?

JXL? we're considering the transparent areas to form J and L shapes offseting an X shape between. Logo? for funsies.

Maybe it takes a bit too much imagination to see a J and L in the transparent > and <

https://jxl-art.surma.technology/?zcode=nZGxCsIwEIb3e4rbpXBNr8Yugorg5KBCZrHVBhw6ZNC3N9Y0JE11cAjcfffnv8tF6dq0WBHBrtG31iCXBIfNCQnW2tRNZ6sFrO5dewbQV7zg0pYQbfh0oU-EKPvUg0IOoEcPi-ZEHiFmeGwMyoA4GXMVwLdwr3CGFEGnLSjGvXqbqNNuvtfizwEstCeHr50nzJLZImd3YSEYhqryDYYVSg4uK8xy-Dl8aBGIhODRYyKrQCk5WWTsGGjHO5_0jT_jExG8AA

That does help quite a bit to make the J and L easier to see, and I also like that now the nontransparent parts are connected...

<:Xjxl:822166843313225758> another version <:Xjxl:822166843313225758>

Here i see

Is it planned to decide on a jxl tree art logo for 1.0?

it wasn't, but that's a nice idea 🙂

rounded version (not sure if that is nicely possible with jxl tree)

bicolor version

**\_wb\_** _“Another JXL logo”_ 2022 image/jxl 77 bytes https://jxl-art.surma.technology/?zcode=dVG9CsIwEN7vKW6XQC41tVkEFcHJQYXOotUGHDpk0Lc3lKReYjoE7r6%2FuyOtvbseSaolHDr77B1qUnDaXVDC1rp7N3haweY19FcA%2B8Abrj2F6MtPKKemIjO2I%2FD2gCYZAAbRBCEKPLa4QJlC%2Fv1Evt8zSSEmU2SpwWB03E1gi4LSuMZo5m7Z%2BCio0rVZxOxxeRQTkknhQiRXq1VGlKKZoa7%2BmJkJzCQLVJwTPl6BwHPnUDQz2pGkGmIt4Qs%3D

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/962299630165565460/art_14.jxl

more variations:

I like if there are many arrow heads pointing towards the center. This suggests good compression. 😄

I think I prefer if you only see the J-X-L on second sight and think it's fine to not immediately realize the three letters. https://jxl-art.surma.technology/?zcode=nVLLCsIwELzvV-xdCmnS50VQUTyJqNBzsdUGFIv2oH9v2qY1L0EsBDazs7szm2a8aCpMiQ_rkp-rBoOQwG5xQAJz3hRlLbIMZpe6ymF1z6_l9vZAzxdp4Cc84lREiCJ8yXC8UBp21xFgcSCBDnoKKBo57efhvmwwVhBJazUhqsRNhhPUQcmlypSRvbTY9rRhVpD-KUCA4jD4OtkxwdKmdZYFSZrAkM3Q17vFoVrcWgpNS7FmqSdFv5jMNDefFUfU2KX8FUy47-ExB2y-tNLe1-Taxu0CK2GvwioijpRrOS7RfUTgDQ

Btw, when will font support be added to JXL. ^^

Isn't spline enough for that

Not too fan of right-angle "J" but I think the 3rd design works quite well.

the 3rd one is close to an old idea I had.

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/963806000249471036/jxl.jxl

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/963807773441798254/x.jxl

maybe something like that? :)

the angles are 1:1 and 1:2 pixels, don't know how well that work as jxl art

It looks like you draw the whole [4-points Catmull–Rom splines](https://link.springer.com/article/10.1007/s42979-021-00770-x/figures/2), whereas there should be only P1-P2 fragment drawn. Can't you just remove fragments P0-P1 and P3-P4 (_mustaches_)?

in jxl? no idea

and at the same time in jxl there's also mirroring

When the (in-bitstream) control points are a,b,c,d,e, if I understand correctly (<@604964375924834314> can confirm because he designed this part of jxl), it will add virtual control points b' and d' (b' being b mirrored around a, d' is d mirrored around e) to get the sequence b',a,b,c,d,e,d', and then it paints the splines in the usual way: a-b is drawn using (b',a,b,c) as control points, b-c is drawn using (a,b,c,d), c-d is drawn using (b,c,d,e) and d-e is drawn using (c,d,e,d').

<:galaxybrain:821831336372338729>

that’s right, from what I remember it seemed to make sense to do that to get less overhead (fewer control points are needed) and more intuitive behavior (the spline passes through all the supplied control points)

I think I did realize that it would put some constraint on the determination of appropriate control points but thought “eh, we’ll figure it out”

<@288069412857315328> in your svg2jxl script you convert Bezier curves into Catmull–Rom splines by sampling points and optimizing them (https://grass.moe/splines), but can't you just use the transformation matrix from https://link.springer.com/article/10.1007/s42979-021-00770-x#Equ16 to get exactly matching points P0-P3 and only draw points P1-P2, removing the _mustaches_?

Another question: how to make filled polygons/circles/rectangles/other shapes using JXL Art?

Rectangles are easy, specific classes of other polygons are easy. Polygons in general are hard.

At least with MA trees. Just filling with splines could be workable depending on goals.

if c > 1 if x > 924 - NE + 0 if x > 424 if y > 924 - NE + 0 if y > 424 - Set 255 - NE + 0 - NE + 0 if c > 0 if x > 762 - NE + 0 if x > 262 if y > 762 - NE + 0 if y > 262 - Set 255 - NE + 0 - NE + 0 if x > 600 - NE + 0 if x > 100 if y > 600 - NE + 0 if y > 100 - Set 255 - NE + 0 - NE + 0

https://embed.moe/https://cdn.discordapp.com/attachments/824000991891554375/967518643854409738/message.jxl

wait ...

**who knows** _“build your own polygons”_ 2022 image/jxl 75 bytes https://jxl-art.surma.technology/?zcode=y0xTSFawUzDkUgCCzDSFCiDH0sgEzAUBXQU%2FVwVtBQNkeRMkeaBQJZoWDG1I6kww1AWnligYmZpitxDOyYQ4E8UZ5mZGeJ1phCQPtR5ZCz5nGmGoI9qZIJvNDLCLGxrAHViJpAybByqRlGO6AK4axgAA

one of the very first things I made when the tool was released

So this is RCT 1 for some reason.

I don't think it's possible to not draw the points. And they can't simply be removed since that'll just turn it into a straight line

<@263300458888691714> Thank you! However, it would be easier if the **if** statement supported the **<** operator.

You can just write if A < B - X - Y as if A > B-1 - Y - X

I am working on converting filled shapes from SVG to JXL splines using modified svg2jxl by <@288069412857315328> and here are my preliminary results: https://tinyurl.com/4efnedyu (JXL Art link). The spline JXL is 1.5KB, whereas original JXL is 13.1KB. I am filling the shapes using 5 scaled thick splines, so there are inaccuracies on irregular shapes. Do you have any better ideas how to fill the shapes from SVG?

i think the best option would be to slice the shape

Do you mean fill shapes by drawing straight lines (stripes) inside them? But what about edges? There would be visible _stairs_.

yes, straight lines, and ideally the lines would be thick enough and gap small enough that it wont show

and i guess it would be topped off with the outline

found this <https://wiki.evilmadscientist.com/Creating_filled_regions>

OK, but it would require a lot of lines, wouldn't it impact the file size significantly?

Sharing <@685944681955328025>'s article in this channel too: https://medium.com/@denisbredelet/jxl-art-a-talk-with-jon-sneyers-7e9fe2dd1a4a

Thanks!

Very nice interview.

prevBitdepth 8 Width 512 Height 1024 Upsample 2 RCT 28 if c > 1 if Prev > 110 - Set -240 - AvgAll 2 if W > -24 - AvgN+NE -1 - Set 222 pprev prev-err pprev-err

**\_wb\_** _“Cosmic background radiation”_ 2022 image/jxl 31 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKz0wB0oYGRiZcHqmZ6RklEHZoQXFibkFOKlBFkHOIgrEZF1dmmkK4gp2CrimXgoKugntRYkpmal6Jgq4RkA%2BU8wPJGQPZINlwsFGpKRBZFBETLgA%3D

**\_wb\_** _“Hell is starting to freeze over”_ 2022 image/jxl 37 bytes https://jxl-art.surma.technology/?zcode=TY4xCgIxFET7f4q5QCDBjZBGWC202kKU1Iv57n6IEjSIxzebTWH3Zt4Us5ccOOUZRpOXUMB2mk4s05zhtpqu6T0%2BUmR0dD5cYCyR3HHDDpqAgt%2BGgIKHaTRAmdX74pVt9fE1BuFnXm31w%2BI3NS2L%2FjP1Mf43vp7hAOfoBw%3D%3D

https://embed.moe/jxl_from_tree?tree=H4sIAAAAAAAAAwvPTCnJUDA0MODySM1MzygBM50yS1JSC4DiFlyhBcWJuQU5qQpGXMEFOZl5qVyGCgaUQC6KdFNDv54phSYYGSgYGXCZW4JICwMoaQwWMQbLAknXvBRoeI0GG9QEYwMFE2AgGSiYgdlmYLYJclBx6SoEp5YAlQIAFGE2q5YCAAA%3D don't remember if i've asked before, but is it still possible to change how splines render w.r.t. blending?

for example when the splines overlap itself and even in corners and bends

No, they always add

What is the practical purpose of splines in a raster format? Doesn't it just wastefully make the format more complex by adding excessively-limited functionality that is rarely of use and belongs in a different format?

Good question, I guess only time will tell

That's fair. I didn’t mean to sound as harsh or judgmental as that came out :)

Curved thin lines are expensive for both DCT and normal lossless raster methods. Splines were added in the format to have some cheap way to encode them.

But making an encoder that actually uses them is very nontrivial and hasn't been done yet.

it can be used to preserve detail on edges when using strong compression

In theory

I'm curious about the potential of a painting app encoding strokes with splines.

i can just use layers to delete the overlaps <:bigBrain:873478803555483719>

https://embed.moe/auto.gif?q=https%3A%2F%2Fcdn.discordapp.com%2Fattachments%2F824000991891554375%2F978468940386824242%2Fblend.jxl

i love jxl

**Greencube** _“Binary trees”_ 2022 image/jxl 31 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOIKz0wB0oYGRiZcHqmZ6RklEHaQc4iCMRdXZppCuIKdgq4Bl4KCroJ7UWJKZmpeiYKuEZAPlPMDyoGkQJLBqSBxUxg3HGxYaoqCoZkZFwA%3D

**Greencube** _“Halal”_ 2022 image/jxl 34 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOQKz0wB0QZGJlweqZnpGSUQdpBziIIxl39RZmpeSWJJZn6egikXV2aaQriCnYKuoYEBl4KCroJ7UWIKSIGCrjGQD5T1A8oaguRAssGpQAlDSzMoNxxsemqKgpGpKRcA

**Greencube** _“Golden Bridge”_ 2022 image/jxl 37 bytes https://jxl-art.surma.technology/?zcode=TY5BC8IwDIXv%2BRW5SyEtTDx5UFBPTlTouazRBXQbNf8f082DEMh74XuP7EQzT9qjhyi5biKCE8uz10Vf93cM0BbhQZPKOOAGDiW9%2BTJ%2B0JENgDww4hadDwSI5jpz3qTDG7%2B4U1yF2R1LyrXI0AU8G7iuoT%2FWhab5XeL8CGfLE30B

**\_wb\_** _“Untitled”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0qYmBlweqZnpGSUKlmYGXKEFxYm5BTmpCkZcQc4hCsamXFyZaQoBRallCnYKBlwKCroKjmXp4dp%2B4Qq6hkAuUDIcKgOV84PLIQRcFcyMuQA%3D

**\_wb\_** _“Untitled”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0qYmBlweqZnpGSUKlmYGXKEFxYm5BTmpCkZcQc4hCiZGXFyZaQoBRallCnYKBlwKCroKjmXp4dp%2B4Qq6hkAuUDIcKgOSA4oaQZlAZX7afq4KZsZcAA%3D%3D

Sunlit Xylophone?

**\_wb\_** _“Pink Triangles”_ 2022 image/jxl 33 bytes https://jxl-art.surma.technology/?zcode=PYqxCsJAEET7%2FYrp5SBZI1oJKgGrEyRydTBnsmDioYvf74YLVvPmzRxFu5h0wI6CdJZcFXSO0g%2BKcr2hW%2Fq0Y3pG26%2BnBsx0eUuctFV5TdgSyQPB%2BYA9CgIcPFxpYPpubsZsM83v5ZqHAMf%2Fcvj2fuVrVEw%2F

**\_wb\_** _“Untitled”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0oYGRiZcHqmZ6RklEHZoQXFibkFOqoIhV5BziIIxl39RZmpeSWJJZn4eUIwrM00hXNcvXMFOwYBLQUFXwbEs3U8byNc1BHJBklAZkBxQ1AjKhChzVTAyMuICAA%3D%3D

**\_wb\_** _“Cyberpunk Moods”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKz0wB0qYmBlweqZnpGSUKlmYGXKEFxYm5BTmpCkZcQc4hCoamXP5Fmal5JYklmfl5CoZcwYWlqalVqVxcmWkK4bp%2B4Qp2CgZcCgq6Co5l6X7aQL6uIZALkgTK6BoB2SBJqDBCnauCMRcA

**\_wb\_** _“Cyberpunk Moods (alternative colors)”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKz0wB0qYmBlweqZnpGSUKlmYGXKEFxYm5BTmpCkZcQc4hCsZc%2FkWZqXkliSWZ%2BXkKhlzBhaWpqVWpXFyZaQrhun7hCnYKBlwKCroKjmXpftpAvq4hkAuSBMroGgHZIEmoMEKdK9BgAA%3D%3D

**\_wb\_** _“Impressionist Hyacinths”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKz0wB0obGplweqZnpGSUKRiYGXKEFxYm5BTmpChZcQc4hCoaGXP5Fmal5JYklmfl5CoZcwYWlqalVqVxcmWkK4bp%2B4Qp2CgZcCgq6Co5l6X7aQL6uIZALkgTK6BoB2SBJqDBCnauCERcA

**\_wb\_** _“Untitled”_ 2022 image/jxl 28 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOUKz0wB0SYGXB6pmekZJQqWZgZcoQXFibkFOakKRlxBziEKJlz%2BRZmpeSWJJZn5eQqGXMGFpampValcXJlpCuEKdgq6xlwKCroKjmXpftp%2Brgq6hmBucGoJ0HwA

**\_wb\_** _“Kryptonite Refinery”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=Lci7DoJAEIXhfp7ivMAmLmCwspCGzoRLtiYyyCSAi4wNT%2B%2BQUJ3%2FfA%2FRnqOOyChIb%2BvTK5Us71GRZBdq49bNcWLcqCoaeHp%2BhRftVD6LvXr9Me9MJAMC7nCeAGfpcgvDl%2BFhh9asyM8Opn8%3D

**\_wb\_** _“(also looks nice in other color schemes like this one)”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=LcixDoJAEEXR%2Fn3F%2B4FNWIVgZaGNnYlgtiYyyiQKqwyNX%2B%2BQWN2bc1DrJdvAEkl7b9xWOIk%2BBuOmLHDNc%2FfKT%2BEOl2PLWOH8URmtM51GRjTvReQrgN6ZuGeIIINvqH0cb46rrdqIsf5%2Fcv0B

**\_wb\_** _“(or this one)”_ 2022 image/jxl 31 bytes https://jxl-art.surma.technology/?zcode=LcixDoJAEEXR%2Fn3F%2B4FNXEGwstDGzkQkWxMZZRLFBcfGr3dIrO7N2av1km1giaS9NxYbHEXvg3FdrtDmd%2FfMD%2BEW58OFRYXTrDJaZ%2FoaGdFMH5GvAHpj4o4hggy%2BofZxvDoutmgjxvr%2FyfUH

**\_wb\_** _“Sierpinskian Interference”_ 2022 image/jxl 31 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOMKz0wB0qYmBlweqZnpGSUKlmYGXKEFxYm5BTmpCkZcQc4hCsZc%2FkWZqXkliSWZ%2BXkKhlzBhaWpqVWpXFyZaQrJCnZAEQUFIDMcyDQAMhUUdIFsXQsoMzi1BGgORNCUCwA%3D

Imagine a phone wallpaper gallery with 100 backgrounds in 4 kilobytes...

**\_wb\_** _“Glitch in the matrix”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOYKz0wB0kbmBlweqZnpGSUKJhYGXKEFxYm5BTmpChZcQc4hCiZc%2FkWZqXkliSWZ%2BXkKhlxcmWkKfgp2CgZcCgq6Co5l6X7afq4KukZALlAmHCoDkgtX0DWEMoEqjLkA

**\_wb\_** _“Minimal pride flag”_ 2022 image/jxl 47 bytes https://jxl-art.surma.technology/?zcode=C3IOUTDgcsosSUktKMlQMOIKz0wB0oYmJlweqZnpGSUKlmZcoQXFibkFOakKhlxcmWkKlQp2CmbGXAoKULa5JZAN5iUDeQZgDpxrCOUqKOgqBKeWAG1A5cOUI8sSZ5IxGt%2BQC91cFI3I1kEdbmKOaoMBkW7FUA41z9AULgIXMzZEEsN0OjbL0K1D6AIA

Probably could shave off a bit more using a 0-color palette instead, but that's not exposed in jxl_from_tree

0-color palette?

with delta palette?

(or default entries)

Just default entries, no deltas needed

Not sure if it would help much, can skip the branching on channel but the indices of the right default colors are probably not so small numbers

**\_wb\_** _“Weighted Squeeze 0”_ 2022 image/jxl 28 bytes https://jxl-art.surma.technology/?zcode=C3IOUTDmcsosSUktKMkAMsMzU4C0oZEFl0dqZnpGiYKRqRlXaEFxYm5BTqqCBVdwYWlqalUqF1dmmkK4gp2CriGXgoIukKlrBGGAdaWmKBhwAQA%3D

**\_wb\_** _“Weighted Squeeze 1”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=C3IOUTDmcsosSUktKMkAMsMzU4C0oZEFl0dqZnpGiYKRqRlXaEFxYm5BTqqCBVdwYWlqalUqF1dmmkK4gp2CriGXgoIukKlrBGGAdaWmKBhyAQA%3D

**\_wb\_** _“Weighted Squeeze 2”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=C3IOUTDmcsosSUktKMkAMsMzU4C0oZEFl0dqZnpGiYKRqRlXaEFxYm5BTqqCBVdwYWlqalUqF1dmmkK4gp2CriGXgoIukKlrBGGAdaWmKBhxAQA%3D

**\_wb\_** _“Weighted Squeeze 3”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=C3IOUTDmcsosSUktKMkAMsMzU4C0oZEFl0dqZnpGiYKRqRlXaEFxYm5BTqqCBVdwYWlqalUqF1dmmkK4gp2CriGXgoIukKlrBGGAdaWmAI0CAA%3D%3D

**\_wb\_** _“Red Triangulation ”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMDTgCi0oTswtyElVMOIKz0wBipmam3F5pGamZ5QApY1MuIKcQ0DquDLTFJIV7BQMuRQUdBXCwTRQKFzXLxwoqgviggX8gCIIAYRaCBuoGCqjqxCcmpOaDLSECwA%3D

**\_wb\_** _“To XOR or not to XOR”_ 2022 image/jxl 31 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMDTgCnIOUTDmCi0oTswtyElVMOLiykxTSFawUzDgUlAAMsN1%2FcKBPF1DIBcs4AcUQQgoKOgqhCsg2EDFBlwQZnBqTmpyCVgOqK0CaiREA1Q3iGnEBQA%3D

**\_wb\_** _“Inexplicable shapes”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOYKcg4BkuGZKUCeobEpl0dqZnpGiYKRiQFXaEFxYm5BTqqCBZd%2FUWZqXkliSWZ%2BnoI5F1dmmkK4rl%2B4gp2CAZeCApDnB%2BRCeQoKugrhcJZjWbqfNlClrqERF4gfnJqTmgw0ngsA

Seriously, I would never have guessed that such weird shapes would emerge

From such simple predictors

This is no weighted predictor stuff, just simple predictors

it took me a while to realize that this one also has `Orientation 7`, so it emerges from the bottom-right corner

this is the closed-up version before upscaling, the antialiasing effect from predictors seems to trigger a sort of chaos

**\_wb\_** _“Halloween Candy Honeycomb”_ 2022 image/jxl 36 bytes https://jxl-art.surma.technology/?zcode=PY67CsJAEEX7%2BYrbSyC72YiVoDZWCj7YOrhjMhDjooP4%2BY6L2N1zOAyzFk2cdcCcDpsTHEVJRq5pacvSDwofajrnZ3fLI2NB%2B4fwpJ3KfbKa5IqIJYInoMKRFVXb2Db%2FNl%2FbLHAxcAW%2BXSynOcH%2F1erVx9kOgX6FvUAf

**\_wb\_** _“Modular Leather Sofa”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=LYy7CoNAEEX7%2BYrbi7DrRkgViDZWEfJga4mjDvhY4pDvz0DszrkXTiXac9IJJd3rJ7yjKL2pDyU1LOOkKE6OXmnvljQzztR%2BhFftVLYVnkgGRFwQPAE5HqzIQ2F87M7wf8z8ttah1%2B8Ys1u0wA8%3D

**\_wb\_** _“Wiggly Lines”_ 2022 image/jxl 30 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOQKcg5RMOAKz0wB8YxNuTxSM9MzShSMTAy4QguKE3MLclIVLLj8izJT80oSSzLz84B6uDLTFMIV7BTMuRQUdBWCU0sUdC2BTKioAZAJEncvSkwB6QJqgAg4lqX7afu5KhhxAQA%3D

Out of curiosity, which features of JPEG XL are used in JXL Art?

mostly modular mode

I ask because I'm trying to figure out which features to implement first if I were to write a decoder :o

I'm considering writing a decoder and potentially checking one with jxl art first

JXL arts mostly use MA tree prediction with zero residual, some use RCT and frame blending, a handful use splines

I personally found that the zero residual (every symbol is zero before prediction) didn't really help me, as you still need to parse the entropy distribution which is more or less a requirement for ICC and TOC anyway

in the other words if you already have an entropy decoder you are not far from handling JXL arts (except for weighted predictors 😉

I do already have a working entropy decoder, yea

I was wondering what to implement next

**Calloway Sutton** _“Automata”_ 2022 image/jxl 47 bytes https://jxl-art.surma.technology/?zcode=cy%2FKLy0IzshMK1Ew5grPTCnJUDA1NObySM1MzyhRMDQwMuFyyixJSS0ASlhwcWWmKVQq2CkYcCkoAJl%2BUCaEE64L4usaggUgQrp%2BrnAlIKCrEJxagsE3MjUlqAehBtUUhMUGGGbAnULIELyasLsEqKECqNrUEKIc1XyYRgA%3D

I'm coming back to this, and I'm curious: are comments in a tree possible?

I've wanted to "save" some very nicely working values this way

make an issue for it

i also wanted that

You can do /* foo */

:O

Just need to make sure the /* and */ are surrounded by whitespace and don't occur in the middle of a 'statement'

So something like this should be fine: ``` if W > 0 /* blah blah */ - W - 1 /* bloh bloh */ - Set 100 /* bluh bluh */ ```

But something like this will not work: ``` if W /* blah blah */ > 0 ... ```

ah sick

Nice birthday gift, I guess 😉 (I haven't looked into this channel for *quite* a while)

I really like some (if not most) of those images. So that brings me to the question: Can we share them? By default the answer would be no (assuming they are copyrightable), so imho it would be great if the authors could license them (preferably under a creative commons license).

I don't know if this has been discussed before.

I know <@794205442175402004> doesn't mind based on past experience, but a first-person confirmation from him that his images have no copyright would probably make you feel better

that said, I Am Not A Lawyer but I believe sharing something in a public forum without declaring a copyright can relinquish it

Not a lawyer either but a politician specialising in copyright law and that's sadly not how it works in most jurisdictions. If no copyright is desired the best option would be to license the works as "Creative Commons Zero 1.0". There's a tool for that: https://creativecommons.org/choose/zero/ Releasing a work into the public domain is actually impossible in countries like Germany (where I'm from) except by dying 70 years ago.

I live in the United States where public domain is a thing tho

so that's where I'm informing my info from

Jon's statements: https://discord.com/channels/794206087879852103/824000991891554375/906848944909336586 https://discord.com/channels/794206087879852103/824000991891554375/943962455548243988

Well ok, I'll just take this as an explicit license under *CC-0 1.0*. Thank you very much.

I wouldn't mind if the year/title/author/image format/filesize info gets preserved, but it's optional

https://en.wikipedia.org/wiki/Copyright#Registration > In all countries where the Berne Convention standards apply, copyright is automatic, and need not be obtained through official registration with any government office. Once an idea has been reduced to tangible form, for example by securing it in a fixed medium (such as a drawing, sheet music, photograph, a videotape, or a computer file), the copyright holder is entitled to enforce his or her exclusive rights.[26] However, while registration is not needed to exercise copyright, in jurisdictions where the laws provide for registration, it serves as _prima facie_ evidence of a valid copyright and enables the copyright holder to seek statutory damages and attorney's fees.[39] (In the US, registering after an infringement only enables one to receive actual damages and lost profits.)

copyright is automatic means all you have to do is say the work is copyrighted, and it is

I don't believe it happens if you don't say the work is copyrighted

it does

you don't have to do anything

specifically the Berne convention mentions the following: > Article 2 (2) It shall, however, be a matter for legislation in the countries of the Union to prescribe that works in general or any specified categories of works shall not be protected unless they have been fixed in some material form.

in the other words, as soon as works are "fixed in some material form" they begin to fall under the scope of the Berne convention

What is a material form though? I suppose a book that only exists in your head is not covered by copyright, but I'd argue that for digital works, it's covered by copyright regardless of it being distributed via physical media or electronically

yeah, I think it's a matter of interpretation and what constitutes a "material form" is up to debate, but I guess that clause alone is sufficient to show that the initial copyright assignment is automatic, regardless of the intent of who "fixed" the work into a "material form" somehow.

the parenthesis in the wikipedia article says “or a computer file”

Would that the brain a computer and a thought a file.

Computers are physical (media).

If data in a computer's RAM wouldn't count then what about the save data on gameboy cartridges kept only alive by small battery? (RIP all my pokemon...)

But I guess this discussion has next to nothing to do with jxl-art and should be moved to the philosophy/offtopic channel.

Human brains are also physical, and something that is just an idea in your head does have some electro-chemical materialization too. I suppose for copyright what really matters though is that it can be copied :)

I'm not a German citizen. It doesn't make sense to me that I would be protected by German copyright law or whatever other laws Germany has. If Germany wants to be stupid, maybe it's better to release things into the public domain instead of CC0 just so Germany can be inconvenienced by it's own stupid laws. Otherwise there wouldn't be an incentive for people to change stupid laws.

Force people to shoot themselves in the foot by their own stupidity

A fool in his ways will soon become wise.

I think the CC0 license is needed not just in Germany if you want to be sure it's really 'public domain' - equivalent.

It's not just Germany. And I wouldn't call it stupidity. It's more of a difference in philosophy between American *copyright* and European *author's rights*. And citzenship is kind of strangely irrelevant. If someone cares enough they can sue you even from another jurisdiction. Kim Dotcom has been charged with copyright infringement by the US even though he never set foot there and the American Project Gutenberg has beed sued by a Germany company. International copyright law is a mess and the Creative Commons project provides some of the best solutions for it.

That's still foolishness, if German law is designed to protect Americans against German citizens.

As far as I know there is no such thing as "international copyright law" aside from specific treaties between particular countries.

Each country has it's own laws and some of them sign specific treaties with eachother regarding copyright protection and other protectionist policies

But if an American wants to release something under public domain, and Germany wants to punish its citizens for using the American's work, that's the foolishness of Germany to place "protecting" American business interest over the interests of its own citizens

That DOES sound stupid to me and like something that ought to be changed

I'll answer in <#806898911091753051>

**Anonymous** _“Unnamed piece”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=y0xTSFawUzDgykxT8AMyTEGMcDBDV8GxLN0xJ0dBV8EQyAlX0FYwMjAAsvzgrODUEgUDAA%3D%3D

**\_wb\_** _“Summer abstractions”_ 2022 image/jxl 28 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKLixNTa1K5QpyDgHyuDLTFPwU7BR0DQ24dBUcy9Idc3IUdBWMgJxwBW0FoCgA

**\_wb\_** _“Summer abstractions (without Squeeze)”_ 2022 image/jxl 27 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOHiCnIOAVGZaQp%2BCnYKuoYGXLoKjmXpjjk5CroKRkBOuIK2AlAUAA%3D%3D

**\_wb\_** _“Wallpaper”_ 2022 image/jxl 35 bytes https://jxl-art.surma.technology/?zcode=JYzBCoMwEETv%2BxVzLwFttdhLIS2Cp1BKS84tphpIIcTg9zvqaWfmPfbmc%2B9iHlGJ9T1veaqlc34YM45VIe84ff4xODTyvL9oif%2Fhkdysv1ObEq4oBFDQ86BDgCrZaBiCM%2BOKLFSzRe6W%2B2UrKzG7vxd%2BMAfTopYF

**\_wb\_** _“Melting Glacier in CGA mode 4 palette 1”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOEKz0wB0qYmBlweqZnpGSUKlmYGXKEFxYm5BTmpCkZcQc4hCsZcXJlpCgFFqWUKdgqGRly6Cn4KhiAhPxDfmEtBQVchXEHXCMxwLEv30%2FZzBWoFAA%3D%3D

https://2022.inercia.pt/index.php?page=Competitions

JXL art compo

Max 512 bytes

Will be shown at 1920x1080, but can be up to 4K

Still only

Nice one!

**\_wb\_** _“Something something fire”_ 2022 image/jxl 33 bytes https://jxl-art.surma.technology/?zcode=TYo9C8IwGIT3%2BxU3V0LT2sa6CCpipw5%2BkFna1zZQIWAQf74ZQnG65567gwuD%2BDCxgXVDzLrSaMWNU%2BDWaORZ8uVm8VWjkeW4%2B%2Ffj5WdhicvxxrUB3JM9dyxARvxG1BFJRUtVLJh2e27%2FHvvP2K26E%2BvUrzJLH6gMfg%3D%3D

**\_wb\_** _“Halftoning exercise”_ 2022 image/jxl 42 bytes https://jxl-art.surma.technology/?zcode=PY5BC4JAEIXv8yvePRZ2V9P1ElREnjxk4Tl01AWDhZZ%2Bf2Oap3nvzcebOfnYcYgjMmp8J3OfairZD2NEkek1tPkWpk7TI7yfrzAxHN3Od9iCyPdocYAhQGQjUhnrxAEK1UXcqmuOMDZfuEq4RK%2Bb5neAuz8791xLIRZgRo6fodpJW2K2qOaJ2wglT3wB

**\_wb\_** _“Y checkerboard on CoCg gradient with 8x upsampling”_ 2022 image/jxl 37 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOUKz0wB0mbGXB6pmekZJSBWaEFxYm5BTqqCBVeQc4iCIRdXZppCsoKdggGXggKUaQhkgjmVUHEQ0FXwU9A1hHOCU0sUjOEKK1AUhmNVCFQWDlcGUWQE44AUWRhwAQA%3D

The edges are kind of interesting

**\_wb\_** _“Sierpinski Meteor Apocalypse (oil on canvas)”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOcKcg5RMDTlCi0oTswtyElVsOAKz0wByhgaWXB5pGamZ5SAmVyZaQrJCnYKBiBGBZihqxCuoGsIpgxBouG6fuFgCQUFIM8PyIXyFBR0gVygIjgTJKqrEJyak5oMNJ4LAA%3D%3D

**\_wb\_** _“Sierpinski-ish thing in 22 bytes”_ 2022 image/jxl 22 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0kamZlweqZnpGSVgJldmmkK4rl%2B4gp2CAZeCgq4CkGkIZgSn5qQmlwA5AA%3D%3D

**\_wb\_** _“Sierpinski-ish thing in 21 bytes”_ 2022 image/jxl 21 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0kamZlweqZnpGSVgJldmmkK4rl%2B4gp2CAZeCgq5COJQOTs1JTS5RMOQCAA%3D%3D

**\_wb\_** _“Red, Green and Blue”_ 2022 image/jxl 26 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0qYmXB6pmekZJQqWZlzBhaWpqVWpXKEFxYm5BTmpQFVBziEKBlxcmWkKAUWpZY5JxQp2QL6Cgq5COFhbaoqCriEq35ALAA%3D%3D

**\_wb\_** _“Something striped”_ 2022 image/jxl 42 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQsOAKz0wB0kbmBlweqZnpGSUKJhYGXKEFxYm5BTmpQPkg5xAFI0sursw0hYCAotQyBTsFEyMuBQUgPxzINgAyFRR0gWxdQyNzKCc4tUTByNQUogqqCabQsSw9XNsPpBwsADVG19gIzIWq8AOrQAjBDAQA

**\_wb\_** _“Sunset in Paradise”_ 2022 image/jxl 62 bytes https://jxl-art.surma.technology/?zcode=bVDLDoIwELz3K%2FZuSFqEwslEjcoJjY%2F0TKRCE3kEGqN%2F70KRYrSXzs7ObGe7UjqVtc4hJEKleDPqeiSSKss18ICTS90mRX2XwMi%2BUbLUiVZVCT45rs%2FIbZukkIeqBQoOo5QQdYMrLLADgPCJkCMNeBwQPW0QNYJOa9qD2hRTdYdPUoPj0VH5QqUfDm2sxS6aeDvH8pHFs3gD7g8nMKl1dpPmbBR9MnM%2BUtNpTviHtkFNlq8k%2FSb9d8rUPmy3Ym5A3g%3D%3D

**\_wb\_** _“Disintegration Or Genesis?”_ 2022 image/jxl 44 bytes https://jxl-art.surma.technology/?zcode=XY9LC8IwEITv%2ByvmLoFU22ovgoraUxUf5FxsbAP2QRtE%2F73bRiqYS2ZnvxnYtbGZbmyBBSmT8R%2BFkmJt8sIi8CVdmy4tm4eGT4fW6Mqm1tQV5nTaXODRrk1Lfaw7SEgic8cNS1Zf4ZHAWVs2ALZeww78BBQvneoBEXhTx7z7mHQUj2ofDz2Ag1fPPJkkW8z%2BHAUxHTOcCH%2FA0B9F46yG43TGrR8%3D

**\_wb\_** _“Colored Aurora”_ 2022 image/jxl 48 bytes https://jxl-art.surma.technology/?zcode=ZY1LC8IwEITv%2BRVzl0DSB%2FYkqKg9VbFKzqVd20BftEH035sWrKXuZXdmPmZ32mTUmgIBUzqz21kLFpLOCwMvEOze9knVlmTzc6epNonRTQ3JrvsbpM%2BOXVLRpekhIBjTD0TYwPUFAzhiKik14NIVg2HT1KbDOQk5ilG%2Bp2wYbpvkTMVkixxP%2FPjXglf%2FvHT97zN1Cmc8x%2FaZR6voAM9ZWArceh8%3D

<@794205442175402004> there was a particular JXL art that was used in an interview on medium, this one: https://miro.medium.com/max/1192/1*w_kkdlMXTHrciCU8U_Ieaw.png do you have the JXL file for it?

https://jxl-art.surma.technology/?zcode=jVNNT8MwDL3nV%2Fi8KZqTtgMuSDABO6CCNqScKxraCLVFbYa2f4%2FTD5Z2FeIWP%2BfZz8%2FJvbGp%2FrI5CGTKpHSQGF6zrTZZbgmUIdtt3kCwl9ro0ibWVCVcscc6KfRr1QAPEIFLRMaY%2BYB3uAVkAKsFbPK6KhJYrCjsM4KObZBRILsIgMNeW%2BAR9jHlj5QPh7hFFFeKQC5%2BQUdUl8CZ1dUlfbNd%2By7%2BdaoGckIXiBNd62jMWUIw4fAb7D14PngOnFz7jkup%2FecJkjKFojqQraZsunv%2FEOrceNoSFIxGv%2FvO4mXs9EQeTpdjxWNnXYToJc6UBzpFk0xbR7RC9dFqT%2Bcgsx%2FDlMZezjB0dm3XOOpLtZ3NY6h1zbPa%2BaOTc7XeA4EiGu9L4IwvYt4XyWZnl8NGdrSOqih189cq3CMcP4D2p%2BjUaZm%2BHem%2FHdXtYJYaTpi0qh8%3D

thank you

**\_wb\_** _“Gold Shark Scales (close-up)”_ 2022 image/jxl 32 bytes https://jxl-art.surma.technology/?zcode=NcnLCsIwEIXh%2FTzF2UsgNfWyElQUV1G8kHWwYzvQS2gHn98Iujof59%2BJVpy0QUlBqryFW9CJpW4U89LSI02xSy1jTedRuNeoMvQo6Lq%2Fwy3pOMaOL8MEC0skL3hscgUyw4%2BAwfZd%2B5k%2FwPwPH2AcfXXjlp%2BKFX0A

anyone going to submit something to https://2022.inercia.pt/index.php?page=Competitions ?

is the deadline near?

No, the demoparty starts on Nov 4 so I suppose that's the deadline

But I need to have 3 confirmed participants to be sure that the compo will happen

I am kind of hoping someone will produce new kinds of crafted bitstreams besides what can be done with jxl_from_tree

if you zoom in close enough you can see the individual pixels are actually gradients

Nov 4 is the deadline indeed. Who is going to submit one or more images?

512 bytes is the limit, which should be plenty

k, I'll try

I'll have one at least and will try to assemble/hype up the sizecoders in the other discord 🙂 A few should pick up the challenge. As for myself, i can do more than my old sierpinski in <32 bytes 😉

<@436097739391107072>

https://youtu.be/FIG3I8Sp2qQ

Thanks for joining us 🙂 i hope we hyped up enough artists/sizecoders to have a worthwhile competition at Inercia 🙂

I hope so too!

This is so cool

Really looking forward to the compo, I'll submit a couple things for sure 🙂

Do we have any sample JXL HDR pictures?

<@604964375924834314> probably has some nice examples 🙂 For the jxl art compo, I assume things will be shown in SDR (probably using a beamer or big tv?), but <@143359398830407680> is the one to ask that

we'll show the compo with a 1080p projector, no HDR support i believe, but will double check, always nice to have more HDR targeted releases though, for people who have supporting monitors to enjoy. future proofing and such.

hmm, specs says it supports HDR! good to know!

Most of the images in the Medium interview were from _wb_ or mine (often derived from existing images though). I am happy to put all my images under Creative Commons license. I will check the images from other posters to ask permission.

<@228116142185512960> if you feel like updating https://jxl-art.surma.technology/ to a more recent git version of libjxl, feel free to do that 🙂 The spline rendering is very slow in the version you have there now, and some recent additions to jxl_from_tree are not there yet: Noise, EPF, Gaborish, DeltaPalette, XYBFactors.

I see you “if you feel like” and raise you (or anyone who fancies it!) a “PRs welcome!”

I currently don’t have Docker on my laptop, and while it’s not necessary to build the JXL wasm, I currently don’t have the time to jump into it

Fair enough. Does anyone feel like making an update PR?

PR: https://github.com/surma/jxl-art/pull/8 not sure how to test whether the version is actually 0.7 now though

Thanks a bunch <@559329656122376202>! Appeciate it. Merged and deployed 🙂

I don't think this changed things. One notable change is that the RCT numbering changed, it's now like it is in the bitstream (so RCT x in old jxl_from_tree inputs should become RCT x-2 (and RCT 1 should become RCT 6).

I submitted an entry to https://2022.inercia.pt/

trying to make something for the inercia compo!

I'm on my way to learn about predictors and stuff

wb, your examples are so resourceful!

**0b5vr** _“Rule 30”_ 2022 image/jxl 40 bytes https://jxl-art.surma.technology/?zcode=c8osSUktKMlQMOQKz0wB0qaGRlweqZnpGSUKRqZmXFyZaQqVCnYKBlwKCkCmX7iuH5QH4ev6uQL5uoZgAQUFXYXg1BIFVB5CMUQzXDEW%2Fah6cJloCHFMBVCnkakpzHgI14wLmznIpsBkAA%3D%3D

yee, I've reached to output the simple Rule 30 so far

I guess I must know how the cell automaton tastes in such a way to get to the next step

ok I think I got an actual banger

see you at inercia ;)

Hello all, I'm learning about JPEG XL for participate on the next Inercia Demoparty ! Where can I learn more about the properties and predictors ?

I checked already the https://jxl-art.surma.technology/wtf.html documentation, but where can I learn more details how that predictors work?

Besides the spec and the libjxl source code, there isn't really anything

Most of the predictors are pretty straightforward. Only Weighted is very, very complicated

I think these ones are the more hard to understand: Select, Gradient, Weighted

Well, W+N-NW is what we call Gradient (if the image is locally a smooth gradient, this predictor will predict it correctly)

Select picks W or N, whichever is closest to the gradient

(Clamped)Gradient is the gradient, clamped to min(N,W)..max(N,W)

Weighted is a pretty complicated stateful predictor that is based on 4 subpredictors (which themselves are self-correcting in the sense that they use the local error as part of the prediction), and it uses a weighted sum of these subpredictors with weights based on how well they they are locally performing

Basically I wouldn't bother to try to understand it. I use it in jxl art to produce natural-looking stuff (like clouds) and as basically a pseudorandom number generator (since it is quite chaotic)

for Weighted, which pixels does it gets? all around? (left up?)

I think this misses a clarification - [predictor] +-[offset:int] Gradient the offset will be added/subtracted to the Gradient result?

It has a one-row state and uses pixels from all around (except of course not yet decoded pixels below and on the right on the same row)

The offset gets added to the predicted value and that's the actual 'prediction' — and in jxl art we just have all prediction residuals hardcoded to all zeroes

E.g. what is called `Set` is actually in the spec called the Zero predictor: it's the trivial predictor that just always returns 0

But with the offset it allows you to 'set' a pixel value to any value

I see

do you have more info about the RCT ? - I noticed it was used for color gradients and does it different or compares to XYB, CbYCr ?

RCT basically shuffles R,G,B around, subtracting one channel or the avg of two channels from another, or doing YCoCg-R.

(main difference is that it is reversible so useful in lossless)

Sorry I didn't understood, looks I don't have knowledge of the area 🙂

Other thing confusing, I'm checking some examples, so should the "three" be inside in just one if (then else) other if above will be considered other three and will only propose is while using Alpha.. ?

I don't understand that question

There are 3 channels by default (c=0..2), but if you enable Alpha then you get an alpha channel at c=3

I guess my question is not related to Alpha, If I have two threes (without any other configuration flags) only one, the first, will be used to the output? if - Set - Set // this three below does not have any effect if - Set - Set

Ah yes, it parses just one tree and ignores anything that comes after

**\_wb\_** _“RCT 0 (just RGB)”_ 2022 image/jxl 58 bytes https://jxl-art.surma.technology/?zcode=XY0xDsIwDEV3n%2BJfoFISGpSJAQaYGCioM2rTNhIVEQQJbo9bmkDZ3n%2F%2BtktXhw5K5IZ21rVdgJaK1i7U1vPA0PZ2ffiic02AosPmCEEnfz%2F3%2FmIhiVyDCismgPHJKBiBDOUoBypsQKa0%2FnSq1OHwSmEo7qeVv6Wx2XJTxXHMaspfs0gmHok3fp1cGpobk88%2BC3oD

The 4 squares have a constant "first channel" value (in this case Red), and go vertically from low to high in second channel (here Green) and horizontally from low to high in third channel (here Blue)

**\_wb\_** _“RCT 1 (YCoCg, i.e. 'luma', blue-orange, purple-green)”_ 2022 image/jxl 59 bytes https://jxl-art.surma.technology/?zcode=XY0xDsIwDEV3n%2BJfoFISGpSJAQaYGCioM2rTNhIVEQQJbo9bmkDZ3n%2F%2BtktXhw5K5IZ21rVdgJaK1i7U1vPA0PZ2ffiic02AosPmCEknfz%2F3%2FmIZyTWosGICGJ%2BMghHIUI5yoMIGZErrT6dKHQ6vFIbiflr5WxqbLTdVHMespvw1i2TikXjj18mlobkx%2BeyzoDc%3D

**\_wb\_** _“RCT 15 (YCoCg on a permutation of RGB)”_ 2022 image/jxl 59 bytes https://jxl-art.surma.technology/?zcode=XY0xDsIwDEV3n%2BJfoFISGpSJAQaYGCioM2rTNhIVEQQJbo9bmkDZ3n%2F%2BtktXhw5K5IZ21rVdgJaK1i7U1vPA0PZ2ffiic02AosPmCKnp5O%2Fn3l8sJJFrUGHFBDA%2BGQUjkKEc5UCFDciU1p9OlTocXikMxf208rc0NltuqjiOWU35axbJxCPxxq%2BTS0NzY%2FLZZ0Fv

**\_wb\_** _“RCT 9 (GBR)”_ 2022 image/jxl 59 bytes https://jxl-art.surma.technology/?zcode=XY0xDsIwDEV3n%2BJfoFISGhQWBhhgYqCgzqhN20ggIggS3B63NIGyvf%2F8bZeuDh2UyA1trWu7AC0VrVyoreeBoc3t%2BvBF55oARfv1AQs6%2Bvvp4s8Wksg1qLBkAhifjIIRyFAOsqfCBmRK60%2BnSh0OrxT64m5c%2BVsami03VRzHrMb8NbNk4pF449fJuaGpMfnks6A3

Sometimes I got this error, but can't understand why 🙂 can't access property "width", e is null