Every single pixel needs to be procedurally generated

https://redd.it/1up0g7c
@proceduralgeneration

Can a Johnson solid be optimised into a nearly fair d26? Looking for simulation help

​

I'm investigating whether the \\*\\*elongated square gyrobicupola (Johnson solid J37)\\*\\* can be modified into a reasonably fair 26-sided die.

I've already spent quite a while looking at the numbering problem. The 26 faces fall into symmetry classes, and I've produced a numbering that equalises the average value of each class and balances the numbers as well as I can. I think the numbering is now "good enough" that the remaining bias will be dominated by the geometry rather than the numbering.

The question I'm interested in is purely geometric.

Imagine starting with a cube of side length \\*\\*1\\*\\* and constructing the shape by making a sequence of cuts.

The parameters would be something like:

\\* depth of the edge cuts,

\\* depth of the vertex cuts,

\\* angle of the vertex cuts,

\\* and possibly (if necessary) allowing the upper and lower vertex cuts to use different angles, giving a total of up to \\*\\*five variables\\*\\*.

The goal is to find whether there is a region in this parameter space that minimises bias and produces the fairest possible d26.

I'm \\*\\*not\\*\\* expecting a perfectly fair die—I'd just like to know whether an optimum exists, and roughly what those dimensions would be.

Ideally I'd like have a helpful person run a large number of rigid-body simulations (Blender, Bullet, MuJoCo, PhysX, Unity, custom code—whatever is appropriate), varying the parameters across the search space and recording the landing frequencies for each face.

Questions:

\\* Has anyone attempted something similar?

\\* If you have experience with rigid-body simulation or procedural geometry, would you be interested in helping investigate it?

https://redd.it/1upapyh
@proceduralgeneration

Gas giant map generator

I'm working on this (vibe coded) procedural gas giant generator: https://github.com/bloknayrb/gas-giant

Free, if anyone wants to try it out!

https://redd.it/1upi1ia
@proceduralgeneration

This is one of the dungeons in Core Keeper. How do I implement procedural generation for a dungeon like this?

https://preview.redd.it/q65wiphx7rbh1.png?width=435&format=png&auto=webp&s=ad3b92ef87673698d690c10117470cd9c2dbc251

As you can see in the screenshot, there's a boss room right in the center, surrounded by pre-made rooms that are placed throughout the map, along with some treasure rooms hidden in between.

How can I design a procedural generation algorithm to achieve this kind of layout? Any advice or specific algorithms you'd recommend?

https://redd.it/1upn4sk
@proceduralgeneration

Persian Carpets Pattern
https://www.reddit.com/gallery/1up4u3d

https://redd.it/1upnpk7
@proceduralgeneration

Simulating Procedural Ponds in my Micro Voxel Engine (Devlog #4)
https://youtu.be/ZxfV7su168U?is=MRBmKPHKWgQnM-21

https://redd.it/1upoiw5
@proceduralgeneration

I tried to recreate the planet from Project Hail Mary in Blender

https://redd.it/1uppr8q
@proceduralgeneration

Programmatic logo design for the ML shop
/r/logodesign/comments/1upsb71/programmatic_logo_design_for_the_ml_shop/

https://redd.it/1upsbrj
@proceduralgeneration

Space Jellyfish - particles and vector fields.
https://redd.it/1uptxmp
@proceduralgeneration

Procedural Neutron Star (Magnetar) animation with Blender EEVEE

https://redd.it/1upwvfg
@proceduralgeneration

Mandelbrot CLI: Renderer with Perturbation Theory
https://redd.it/1upz72e
@proceduralgeneration

Tested LLMs for pixel art generation via HTML output — unexpected coherent results across model families D

I ran an informal test that yielded some completely unexpected results. I asked several LLMs (GPT-4o, Claude Sonnet 4.6, Gemini Flash) to generate pixel art tilesets as HTML output, where each table cell corresponds to a single pixel. I fully expected incoherent output. Instead, all three models produced coherent tilesets with consistent palettes, seamless tileable edges, and themed variations on the very first try.
This is interesting because diffusion-based pixel art generation (even with custom LoRAs) typically struggles to maintain palette consistency across tiles or produce truly seamless edges, since each tile is generated in isolation. LLMs generating HTML seem to plan the entire tileset as a single, coherent whole and respect hard constraints (palette, tile size, theme) much better than diffusion models.
I'm sharing this because I think it's an under-explored LLM capability that the image research community might be overlooking. I've attached sample images generated using the exact same prompt across three different model architectures.
An important clarification: these outputs are not standalone, usable pixel art. Real pixel art requires human intent, an artistic touch, and decision-making that no model possesses.
Questions I'm curious to get feedback on from the community:
Has anyone explored using LLM-based structured outputs (HTML, SVG, canvas) for pixel art or other grid-based media?
Why do hard constraints seem to work better here compared to diffusion? Is it the full-tileset planning, or something deeper regarding grid representations?
Any known edge cases where this approach fails in funny or spectacular ways?
Happy to share the exact prompt if anyone wants to replicate this. Not selling anything, just trying to understand if this is a known phenomenon or worth investigating further. All the assets in the photo (not the character and hammer tho) are created with this method

https://redd.it/1uq7ci3
@proceduralgeneration