Shara & Theriona
Theriona
Hey Shara, I’ve been experimenting with code that turns mathematical sequences into swirling patterns—think algorithmic design could be a cool intersection for us?
Shara
Sounds interesting. What language are you working with, and what kind of sequences are you mapping to the patterns? I'd like to see the prototype and maybe help optimize the rendering loop.
Theriona
I’m doing it in Processing, the Java‑based sketching language—it lets me treat code like a fabric canvas. I’ve been mapping prime numbers into color gradients and Fibonacci spirals into line thickness, so the patterns feel organically chaotic. The prototype is a little rough, the rendering loop is a bit jittery when the frame rate drops, so any tips on smoothing the draw() cycle would be welcome—especially if it keeps the code clean but not overly minimal.
Shara
Nice setup. A couple quick things that usually help with jitter in Processing: set a fixed frameRate early on—e.g. frameRate(60)—so draw() always runs at the same cadence, then use smooth() to turn on anti‑aliasing. For the color gradient, instead of recalculating the whole lookup table each frame, compute it once in setup() and reuse the array. If line thickness changes a lot, store the values in a float[] and interpolate with lerp() so the transition is linear rather than abrupt. Finally, if the drawing logic is heavy, move the math to a separate thread or a background thread and only call loadPixels()/updatePixels() inside the main thread. That keeps the UI thread free and reduces frame drops. Give those a shot and see if the loop steadies up.
Theriona
Thanks for the tip—setting a fixed frameRate and using smooth() is a good start, but I still feel like the patterns look a bit flat if the palette isn’t vibrant. Maybe we should precompute a more dynamic color wheel that shifts hue based on the iteration count, so the gradient feels alive. Also, threading the math is clever, but I’m worried about synchronizing the pixel updates; I need to keep the visual flow unbroken. Let’s try that and see if the jitter disappears—if not, I’ll dig deeper into the code fabric.
Shara
Sure thing. Build a small color wheel array in setup()—say 360 entries—then for each frame pick the hue index based on frameCount modulo 360. Use lerpColor to blend between adjacent hues so the palette shifts smoothly. For the pixel updates, keep the heavy math in a background thread but push the results into a shared PGraphics buffer; then in draw() just call image() on that buffer. Wrap the buffer writes in a synchronized block or use a volatile reference so the UI thread never reads partially updated data. That keeps the visual flow steady while still letting the math run in parallel. Give it a go and see if the jitter eases up.