What are /r/generative's favorite Products & Services?

From 3.5 billion Reddit comments

You can make cool stuff without ‘learning art’, I would start with implementing some of the algorithms here https://www.notion.so/Creative-Code-algorithms-techniques-c5550ef2f7574126bdc77b09ed76651b . Start combining/modifying them, and soon you’ll have something that looks pretty cool!

Sure! The underlying engine is a slightly tweaked implementation of Scott Draves' fractal flame algorithm. It's essentially a tool for sampling from an iterated function system via the chaos game method with the slightly quirky property that at each iteration the entire coordinate system undergoes a randomly sampled linear transformation (i.e. basis shift) before the next randomly sample function is applied.

The way I've set this one up is the functions are defined on (x,y,z) coords, with z defining the colour, but the transformations on the z coordinate are qualitatively different and much smoother than the transformations on (x,y). Most of the interesting dynamics are in the (x,y) subspace.

In addition to the random basis shifts, there are three main classes of transformation function in this system (ignoring minor tweaks to produce cute visual effects). One is a simple dilation, which produces the general feeling of "expansion" in the piece. The second is a simple trigonometric function that produces those sharp-edged arcs that seem to move outwards in the piece (the output of that function falls on a 1d manifold). The third is a messier trigonometric function that forms a 2d vaguely spherical manifold that produces those spherical/edged shapes.

A lot of the nuance of the output comes from the interaction between the different parts, which honestly I got to work by a lot of trial and error! Like, the palette sampling algorithm is a bit of a weird thing where I subsample a small set of shades from an array of 600 colours I like, and then interpolate between that small set to colour the piece. So the palettes produced by this system are sometimes incoherent, but with the weird energy of the pieces it usually kinda works.

I used formulas from this paper

Three coupled oscillators: mode-locking, global bifurcations and toroidal chaos C. Baesens a, J. Guckenheimer b, S. Kim c'1 and R.S. MacKay a

https://sci-hub.do/10.1016/0167-2789(91)90155-3

This really depends on what you want to create, and what language you want to use to create it. (In reality, generative art can be created in any environment, with any language!) A good one to get started in is called Processing. https://processing.org/

There are at least 100k review papers on the topic, from architecture to nanophotonics, but you could start with this one on design research in general, and follow the papers it cites, and the papers that cite it.

Semantic Scholar is your friend https://www.semanticscholar.org/paper/Generative-design%3A-a-paradigm-for-design-research-McCormack-Dorin/4b6fb13c24c63898c7882d96f3beaaae9c6b5e32

Looking forward to see how you modified it. Happy Coding.

You will need to install Processing and Java runtime to open the "*.pde" files. Also you have a folder OUT, that is the output of the generative piece.

Generative Entomology Download

Processing Download

I speed coded up a (crazy slow and horrible) implementation of the Minsky plots over on codepen: https://codepen.io/tsuhre/pen/GOyROJ

It's a pretty naive implementation, but you can play around with the parameters and get some of the patterns described in the article

I'd start by learning some Processing (yes, unfortunately that's what it's called).
https://processing.org/
See the examples and the Getting Started.

You can dive right in and get results online here:
https://editor.p5js.org/
This uses javascript. Personally I use the Python libraries since that's the language I'm more proficient in, but it does require setting up a coding environment on your computer which can be a pain.

This is cool flocking but I can see the lines of the grid. Daniel Shiffman has some great stuff on coding flocking behavior that doesn't have that aspect.

https://natureofcode.com/book/chapter-6-autonomous-agents/

https://processing.org/examples/flocking.html

https://processing.org/tutorials/ is probably the place most people would start.

If you don't might spending a bit of money, I think Matt Pearson's Generative Art book would be excellent.

I'd recommend starting with basic perlin noise. The Coding Train! has really wonderful tutorials, and I happen to really dig their teaching style.

Glitch is a really rad resource for some fun 3D shaders but the principals and structures are what I'd study.

A little noise, a little color, a little cos, a little sin. All these can go a long way. I'd also peruse some github resources if ya can hunt 'em down with some clever googling.

If you have HTML experience, you can learn JavaScript, and then use either HTML canvas or p5.js! Here is a helpful list of some common generative art algorithms. https://www.notion.so/Creative-coding-algorithms-techniques-c5550ef2f7574126bdc77b09ed76651b

Hi!

So, yes. That was exactly my intention here. To create something that appeals to the graphic design aesthetics.

I've been exploring with many possible ways in generative art (from particle systems to controlling light installations with Processing) and sincerely, everything is interesting to me. Here a few samples: https://dribbble.com/shumiski

The process of creation here was:

1. The smile face was created in Illustrator and exported as a png.
2. In Processing I've used sine and cosine to make the movements, then exported as a movie.
3. In Photoshop I've adjusted the looping and added the type.

>Goodness gracious! Great ball of fire!

Hi! I used a javascript library that I wrote (here). I created a codesandbox to see the image source

Yeah keeping things earth-toney can be tough. I have had some success pulling colors off of here https://color.adobe.com/explore .

Another little trick is to do col = sqrt(col) right at the end, after your layers are added. Natural colors are generally closer to white and grey than colors you'll stumble upon in GLSL land, so this changes the curve and leaves the high-intensity components alone while bumping up the lower-intensity components. In that same vein, doing a gamma pass at the end (or at various points in the middle) could help tune the composition.

I'd be curious to hear some others' input on this though, I am not very good at keeping colors natural.

I create a flow field and draw curves through the angles defined by each point in the field for a certain number of steps. The color is derived from a video source - this one, in this case: https://www.pexels.com/video/woman-with-face-paint-holding-flowers-7707747/

I can definitely understand why it might be a bit overwhelming. Those particular posts you mentioned were actually from fairly early on in my learning process as a generative artist, but I already knew how to code. Feb 18 happens to use a frequently used concept called Perlin Noise.

I started using Processing, and I currently use p5.js, which is a javascript port of processing. Dan Shiffman has tutorials in both, and he's a world class educator. His beginners guide is a great choice to start with, but I don't know which language it uses. There are also a lot of tutorials and examples on the Processing website. I haven't watched it myself, but I imagine that Dan's series on the nature of code will also be a fantastic way to write interesting programs. I think a reasonable approach is to use his tutorials to gain an understanding of how code relates to visual/physical concepts and then take inspiration from things you find around you. It's a bumpy road, and you won't initially be super jazzed about the quality of your outputs. The start of my instagram account is actually when I started a 30 day generative art coding challenge. That was only 3-4 months ago. I probably spent 60-70 hours working on code over those 30 days, and it wasn't exactly great at first.

I also started by watching these videos. They won't tell you how to code, but they'll introduce you to some great concepts.

Beyond that, you've just gotta start coding. That's the nature of this particular medium. It sounds daunting, but you'll get there if you follow Dan's tutorials and take it slowly.

Thanks! I'm actually the author of this article. It's great to see people enjoying it and getting it out there (thanks /u/woodrail)!

Jared Tarbell's work is fantastic and has been the inspiration for several pieces of work I've done over on Codepen. Great screensaver!

I made this post just after discovering this subreddit actually, So it's awesome to see it come full circle and make it back over here :)

This video was made using Processing (Programming Language). It's essentially about 1,000 different colored lines traveling randomly, 1 pixel at a time. There is a condition that if a line is headed in the direction of a black color it turns around and heads in the opposite direction. Some of the lines themselves are black, which created the "jellyfish".

Camtasia was used for video editing, and the clips were sped up 700% to 4,000% of the original speed.

Thanks!

I am using love (a 2d Lua game library)

The points are being drawn by a Mesh set to "points" mode (i.e, think of a wireframe mesh but only drawing the vertices instead of the lines). Using a custom vertex/fragment shader I can draw dots of different sizes (i.e, I can assign each vertex a "size" value as well as a position). The positions are being modified on the CPU just using some simplex noise, and I am also inverting (new_x = y, new_y = x) the points inside the circle in the middle.

Lemme know if that makes any sense :^)

more on my Instagram: mostly_patrick

It started as a codepen, which is still controllable, it just doesn't produce quite as sophisticated results.

https://codepen.io/nikochaffin/pen/XgVqxw

Producing a controllable bot that does this kind of stuff is conceivable, though. Especially if people are interested in seeing that. :)

Fuck ya I have favorite sites :

movie palettes

colour lovers

It works through the words in each of the books.

Each word is represented by an arc:

• The arc's radius is the length of the word.
• The length of arc is the popularity of the word within the book.
• The saturation of the arc colour is where the word falls on a list of most popular words (according to the Moby Words frequency list)
• Each sentence gets a new hue, so colour change means a new sentence.

Each arc gradually falls down the Z axis as it gets further away from the current book position.

I did another version later on that removed stop words but I couldn't think of anything good to put after "done_now" in the title :P It did a better job of comparing word complexity in each of the books though.

I thought I'd add a bit more detail here: if you have the money to spend on this, and don't mind a smaller form factor, my suggestion would be to grab a 9.7" Android tablet with a retina display (you want to look for one with a 2560x1600 display).

Add some matting and a neat frame and figure some way to wire it up cleanly.

Now you have a nice empty "painting". Next, you want to write a custom Android app to display your artwork, which shouldn't be too difficult.

The next step is to adjust screen luminance based on ambient light. This is where I got stuck. One approach is to interface with the on-board ambient light sensor and adjust screen brightness programmatically. This doesn't adjust color temperature unfortunately. The only way to do that appears to be using built-in Android's night mode over which you don't have much control, or rooting your phone and writing custom code like what f.lux does.

Hope that helps!

I have no idea if it's any good but I just saw this on Twitter just now that recommends "Generative Design" by Bohnacker (amazon).

https://www.amazon.co.uk/gp/product/B07TVHRYBB/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&psc=1

This takes a digital signal from the Arduino between 0 and 255 and converts it into a PWM signal (using the motor's 12 DC power supply) for the motor. Easier to use than I'm making it sound :)

Thanks for checking it out! :D I've open sourced the project: https://github.com/Anemy/concentric And I've posted a couple of my favorites on dribbble: https://dribbble.com/Scotsley

AMA!

Also - apologies for it not being so mobile friendly yet, I'm debugging that currently.

i was also thinking of starting just with pixel arrays. how do you bring the pixels to the screen and to image files?

i found this article about graphics libraries (https://www.notion.so/Rust-Graphics-68b4ae434e1f440db70d8f31689c6967#de26d88267684c5dabb316cf1bd6e726) but it all looks pretty complex to setup and handle.

https://www.shutterstock.com/image-vector/colorful-textured-dense-micro-terrazzo-seamless-1436797166?src=efW0Sx27eZ0puZzEG9tAhg-2-90&studio=1

I think this is a decent book for beginners. It’s better if you know some programming going in

Generative Design: Visualize, Program, and Create with JavaScript in p5.js https://www.amazon.com/dp/1616897589/ref=cm_sw_r_cp_api_glt_fabc_1ERFE27ZF19HAHSKZTHV

If you choose a dot at the center of the tile and a some angle to draw a line with, can't you just solve the line equation at the tile walls?

E.g. say you want to draw a line in a tile with theta and tiles are width units wide. Then by the sine rule you have the line equation (x * sin(theta))/(sin(pi/2 - theta)) which you can solve at x = width/2 and x = -width/2 to get the clipped line points.

Example

Ok I see. Perhaps with round stroke cap ( https://processing.org/reference/strokeCap_.html ) and 80% transparency ?

Anyway new one are great, and first one also. The squares give a crystalline look. An other option is drawing hexagons ( 6 sided circles )

There's a function that you can use to set your shader. You can call different shaders or set different uniforms in between shapes that you draw. This tutorial is a hit lengthy, but it's actually an incredible tutorial on the graphics pipeline.

https://processing.org/tutorials/pshader/

There’s a lot of generative art tools here Generative Art Links.

Processing seems to be the most popular and there’s a lot of tutorials, videos for it.

So I dont know what kind of background you have.

Learning programming would be the best start. Depending on your language theyll have libraries for making graphics.

There's a specialized system called Processing that is geared towards quickly making generative style graphics.

Explanation of system: The basic explanation - The points are run through a modified Chaiken-curve algorithm every tick.

The modifications: (p1 - first point p2- second point) 1) Instead of finding the midpoint between any point then the next point it finds the midpoint between any point then the point 2 after for the x and, 3 after for the y. 2) The midpoint formula has been modified to place the new point, half the length of the distance between p1 and p2, behind p2. 3) After each time the Chaiken algorithm has been applied the new "Chaiken points" are substituted for the old ones.

How dose it turn random points into a uniform system? The base for this project was to create a self organizing circle by recursively applying the Chaikin algorithm to random points.(Similar project: https://scratch.mit.edu/projects/174943353/) It succeeded in making the circle uniform however the circle contracted too much. A more in depth look at how this creates a 3d uniform system coming soon(maybe?) How dose it create a system of moving points? Because the midpoint is being found in between points that are not next to each-other the position is shifted over 1 for the x and 2 for the y every tick.

More in depth post about the technique coming soon (maybe?)

From Project desc.

IMO the main reason i like this project is how the colors don't fade in uniform and you can get a hint at the process just by looking at when the colors change.

Brief explanation (more in depth in scratch page): Each "flame" is a circle that was morphed then run through a Chaikin-curve algorithm. The number of times the process is repeated is changed with each circle along with other variables.

Scratch page not recommended to use as it takes a long time to render.

java converted still take around 2-3 minutes to render but considerably faster.

Try and create something that already exists and then play around with it, create something new. Learn how to make stuff that you like and then you will get more ideas along the way.

There was a good (FreeCodeCamp article that was just published)[https://www.freecodecamp.org/news/the-secret-to-unlimited-project-ideas/] on their website out about coming up with ideas and, while its more about coding projects in general than geneative art, the main principle still applies.

It’s a program you can use to make live wallpapers fro your PC desktop. I just found out about it recently and it’s really cool. You can find hundreds of community made wallpapers or make your own if you have programming skills. I’ve made a few wallpapers with Unity3D but I really want to make something like what you have done but with OpenGL. I’m not exactly sure what all is supported but you might be able to adapt this to be a live desktop wallpaper.

https://www.wallpaperengine.io

Thanks! I actually generated it on http://colormind.io. I might try my hand at my own color GAN in the future. That would enable me to plug it directly into my code and possibly walk through the color space. Until then, this site does a great job.

Although all of the pallets I've grabbed from there look good, I still find that certain pallets are better for certain applications.

The greenscreen feature for Zoom calls is a fun way to personalize the remote work experience. My preference is for backgrounds that *could* be real -- it's not as fun for me if the background shows a field of view that would be physically impossible for a typical webcam.

I found one that I liked of a virtual "office" background with some cool art in the background, and I thought, this would be even better if it showed off some generative art instead.

So I made a couple featuring (with permission) the art of /u/red_blue_yellow. I've taken liberties with the size of the prints to satisfy my OCD for making things align. So in real life, the square prints shown in the first background are proportionally larger, and the orange print on the right in the second background is much smaller than the others.

(The background in the first one is attribution-required; it's from https://www.freepik.com/free-photo/wall-tv-living-room-with-white-walls_8799580.htm.)

This is created using the Geometric plugin I created for Figma, a UI designing tool. I hope it can be used by illustrators in their workflow to create complex shapes or even UI designers when seeking to go beyond usual shapes.

Have you seen canvas-sketch?

My tool is very simple for now. I'm developing it in and for Kotlin programming language. (Just because I'm very proficient in it and I enjoy programming with Kotlin a lot). In current implementation my sketch is creating sequence of drawing commands and sending them to launched server (than renders it). That's kinda poor-man's hot-reload for now. I'm gonna implement file-watching soon and maybe will use embedded compiler.

My framework is aimed for static-art mostly so I'm focusing on useful DSLs and tooling now to be able to sketch declaratively and tweak sketches in-process easily.

val spacing = when {
    depth.isRoot -> 16
    depth.isPreFinal -> 4
    else -> 2
}

withGrid(2 x 2, space = canvasRect.withPadding(32), spacing = spacing) { rect ->
    drawDivision(rect, depth.goDeeper())
}

Not truly a maze, per se...this code makes use of some special HTML5 characters called entities. (Full List here).

Thanks for checking this out! If you can figure out what's stopping this from rendering in IE I'll gold you.

Third-party tools can help:

• Up to 10 posts can be scheduled using Buffer Publish free account.
• Hopper is a paid product dedicated to instagram posting.

Otherwise, quite a few open source projects reverse-engineered instagram's private API, and can be used as a base to program your own automated posting routine...

You can download the game for Android: https://play.google.com/store/apps/details?id=com.rtr.rtr
Comet movement controls the fine pitch, frequency cutoff and volume. Switching to another orbit changes the chord.

> i was going to make it into a phone app but it ended up being way too laggy.

Been there. Actually made an app and it is kinda piggy

So I tried to make the color transitions a bit smoother...

I also made an app for android for those special times in public transport when you simply must pretend you're getting orders from outer space.

source

Kmizera Beta Inkless Pen Silver Made of Anodized Aluminium Everlasting Newest https://www.amazon.com/dp/B071QXPHFN/ref=cm_sw_r_cp_apa_1kTmBbAQETFH0

I've not tried it nor ever actually handled one so I have no idea how they feel or what but it's gotta be better than a pen, right?