This post is in English this time, because the target audience of what I've got to say this time is not limited to those that are able to understand German.
Over the last two (2) years, I've been working on a private side-project I've always referred to as "Jeremy's Art Generator". My recent achievement within that project was a full re-write of the former CoffeeScript code into ECMA-262 6th Edition syntax. While I had to dig through every single line in the whole project manually to not just stupidly transpile the sources, I more and more figured it would be a good idea not to just have a Help that later came with the project, but to also write a post about my motivation behind the project, since I had the feeling most visitors would just confusedly discard what they see and close the window when they first encounter the web application.
Back in 2014, I noticed folks I followed on Twitter had quite a lot of fun posting screenshots of a project made for Ludum Dare 27 in mid-2013, "BECOME A GREAT ARTIST IN JUST 10 SECONDS". One of these folks I also had the pleasure of meeting in person was Jeremy, posting several a day on their Tumblr. Presuming the game jam entry wasn't exactly fitting the definition of "art", I made a promise. Little did I know what I would go through.
And still, I am not exactly satisfied with the toolset and the variety of processors to chose from to generate "art".
But first things first.
Without knowing how "BECOME A GREAT ARTIST IN JUST 10 SECONDS" worked exactly, my approach was to think of the "ideal" art generator as of something that had different more-or-less random processors with several settings to adjust the behavior of each step art was being generated. So I started with a little tech demo to verify whether my modular concept was in fact practical. As soon as that foundation was in good shape, all I had to do was to write more processors and the core application took care of the rest.
The problem was: I wanted and needed as much feedback as possible as early as possible, but the early prototype and what followed looked like... well, you tell me what it looked like.
I'm now pretty sure that one of the reasons people didn't reach out to me as I wished they would was that the application wasn't inviting enough to spend the time necessary to gather adequate impressions.
What you could see is that it was clearly targeted at Jeremy, yet up to the date of writing, I haven't heard much about it from them. I did get valuable feedback, suggestions and bug reports from other close ones, though, and without their help, I may not be writing this post now. (Hello, Thomas, nice you've read this far. I cannot thank you enough for what you did for the project. I hope everybody here appreciates that. <3)
By now, calling the art generator "Jeremy's Art Generator" has become some sort of trademark to the whole project.
So what's the deal? Why keep on working on this project?
Well, every once in a while, I still had a new idea, some inspiration, or some thing I had to experiment with, and while the last months mostly consisted of cleaning up the code and removing processors that didn't work or were not as "crafty" as they should be (rest in peace, "R-G-B"), Jeremy's Art Generator was the perfect place for that, even if it were about how to optimize the code once more.
So I did.
I suppose before I can get people to help me improve or extend or even just correct my typos on the Help, I need users to understand how the project works. My plan was to let the project speak for itself, but I guess that's one of the things I failed at (more room for improvement, I guess). Once again, everything you'll now read here should've been understood just by having a look in the Help, there's just no pictures in there.
Anyway, let me guide you through some of the features.
Let's start with the most simple things here.
As of now, there are four types of processors: Displays, controls, generators and manipulators. In the above picture, there is the Color generator and the only display to date, the Buffer snapshot. What this setup does is simple: The Color generator generates pixels according to its settings, accessible through sliders and other form elements on its card, while the Buffer snapshot takes those generated pixels and displays them. You can add as many displays to your setup as you like if you're interested in what's going on in between your steps.
Because generating the same color for every pixel is less artsy-fartsy as one would need for an "art generator", the Color processor uses special value sliders that yield two values to pick random colors between those two values. Of course, as it is their default setting, dragging both slider knobs to the same value will produce the same value for the channel.
To learn how these settings work, you could either open the built-in Help, which should give you all the information you need to understand what a processor does:
... or play with the sliders, what you should have done anyway a few minutes ago. Create art!
For example, a random, bright red noise between
Different from generators, which just smear more color onto your canvas, are manipulators. Manipulators cannot create colors from nothing (there are rare exceptions, though). They take pixels away, replace them, and modify them, and their result won't be drawn above the last buffer, they replace it.
A good example for that kind of manipulation is the Mirror:
As you may have noticed by now, your results with the same settings may differ from what you see here and even drastically vary every time you change a value. This is because, like I said earlier, processors would be more-or-less random. Your settings and wiggle-waggles on the sliders may control generators and manipulators, but never fully so that you would be able to predict their outcome.
Yet there is a solution for control-freaks among us: Seeded pseudo-random number generators. The idea is that the random number generator has certain values it uses to generate the next requested value, so the same "seed" (starting value) yields the same sequence of random numbers each time the processing is executed.
To control these kind of internal values, the control type of processor is there to serve. This control in particular resets the randomizer start value:
The result of this setup should look exactly the same on every device.
The random numbers generator has been replaced twice since I started working on the project, and every time I have to break existing setups, it hurts, but trust me, when I change existing pieces of the code, it's because I think it's better, more powerful and yields results that look more like art than before.
So if you had setups stashed in your session and they don't look like they haven't before, you have my sincere apology. Try restoring your old stashed setups with the old revisions of the application, which you can open through the commit history.
Oh, yeah, that's right: Every commit ever made and able to compile is available to you, so you can dig deep and try out the early versions if you're up to a development horror show.
If you've been reading and following my overview really carefully, you might have spotted a thing by now. To be frank (not Frank, but I'm sure he's a nice guy), I've been lying to you. There is, in fact, a fifth type of processor: patterns.
Patterns are selected for masks for most processors that either manipulate or generate. And as the name suggests, masks control which parts of the picture are affected by the processors.
Masks can even be masked, if you're that kind of a maniac.
Hopefully, I made some sense and you've got a vague idea of what this is all about.
So, what can you do with this kind of toy? Here are some randomly picked examples from the public gallery, if you haven't checked it out yet:
That brings me to what my goal with this project is: Jeremy's Art Generator is a tool for the people (and you are one of them, too), and it's here to stay.
Over the past months, I realized it's a wonderful project and I'd be better off keeping it alive. But for doing so, I more than ever need your help. So play with it, you've only got ten years left.
Tell me what's wrong. Tell me what you miss. Tell me what you are thinking.
I'm here to help. And I'm glad pushing this project forward and to the limits. This is a public web application for a reason.
Oh, and Jeremy: No hard feelings. <3