By
@aamosm
An Algorithm inspired by This Person Doesn't Exist. Every refresh reveals a procedurally generated alien species that has never been seen before. Share discoveries by seed and explore an effectively endless universe of unique extraterrestrial life.
@aamosm
on
This Alien Does Not Exist
1h 35m 41s logged
I’ve spent a lot of time making the generator produce creatures that make more biological sense.
Instead of every value being generated independently, more of the genome is now constrained by the rest of the creature. Large heads need thicker necks, heavier creatures get proportionally stronger limbs, tails are limited by body size, and posture now affects how the whole body is built rather than just changing a few numbers.
I also added several posture types like upright, forward-leaning, arched, slouched and coiled. They all change the way the spine, shoulders, hips and tail are generated, which makes creatures feel much less repetitive.
I finally started building the registry side of the project.
Every creature already stores a deterministic generation trace, but now that information is actually being used.
Each alien gets converted into physical and behavioural vectors which can be compared against every other creature. The registry can now find the most similar alien based on body structure, behaviour, or an overall weighted similarity score.
I also spent quite a while refining the comparison logic so it isn’t just comparing raw numbers anymore. Behaviour vectors are aligned automatically, similarity is calculated using both Euclidean distance and cosine similarity, and the weighting system is much more stable now.
This is eventually going to power species grouping, reverse lookups and the registry website I’m planning.
The information panel also got a pretty big upgrade.
Instead of only showing generated facts like diet or locomotion, the engine now generates observations written from the perspective of an automated survey system.
These aren’t random sentences. They come directly from the generated anatomy and registry values, so every observation is deterministic for that seed.
The idea is to make every creature feel less like a render and more like something that has actually been catalogued.
The website changed quite a bit too.
The biggest headache was making the information panel scale as more systems were added. It was becoming difficult to navigate once the registry and observations were included.
I ended up reorganising everything into collapsible sections, improved the responsive layout, added seed copying, better sharing, smarter canvas padding for different body shapes, and cleaned up a lot of the navigation code.
It feels much easier to explore creatures now instead of just generating one and moving on.
The renderer is still the weakest part of the project.
Large body parts can still merge together because everything is rendered as one continuous SDF surface. The next thing I want to work on is adding proper depth ordering and occlusion so limbs, necks and snouts separate naturally when they overlap.
After that, it’ll be time to start building the online registry.
@aamosm
on
This Alien Does Not Exist
1h 1m 24s logged
changed from Doesn’t to Does Not
One thing I’ve wanted for a while was for every alien to be more than just an image.
The engine now keeps track of every important random value it uses while generating a creature. Things like body proportions, head shape, limbs and colours are all recorded as they’re generated.
That means a seed doesn’t just recreate the same alien, it recreates the exact decisions that built it. It’ll also make future updates a lot easier without changing existing creatures.
I also wanted to work on the WebOS mission, so this is the first step towards that. The plan is to build a space-themed registry where every alien can have its own record.
With the generation trace in place, I started building the registry system.
Instead of only showing the final creature, the engine now derives extra information from how it was generated. Things like curiosity, watchfulness and a physical signature are calculated from the generation process itself.
Eventually I want to use this for things like:
Since everything comes from the seed, it’ll always stay consistent.
I also spent some time improving how creatures look.
Skin patterns are now a lot more varied instead of just making parts of the body darker. Different aliens can have different coloured markings, and the patterns themselves have more variation.
The information panel also shows a few more generated traits now, like mouth type, pigment, tail type and mass.
It’s a small change, but it makes the creatures feel more like actual entries in a database.
The next thing I want to tackle is depth.
Right now everything exists on the same layer, so thicker body parts can swallow smaller ones. A large torso can hide the legs, and a long snout can blend into the neck.
I’m going to experiment with giving different body parts their own depth so overlapping features stay separate while keeping everything fully procedural.
@aamosm
on
This Alien Does Not Exist
1h 38m 55s logged
This time and more was mostly spent improving the renderer and cleaning up the procedural generation pipeline. It wasn’t the biggest update feature-wise, but it changed a lot behind the scenes.
Skin generation got a complete overhaul. Instead of the old flat patterns, aliens now use layered procedural noise to generate stripes, spots, scales, mottling, and other textures that blend between colours in each creature’s palette. Some of the results look much more organic than before, and every seed feels a little more unique.
Lighting was also improved with a small fill light and softer head illumination to give the creatures a bit more depth while keeping the renderer entirely CPU-based.
Most of the work happened inside the generation pipeline.
Some of the changes include:
The project is much easier to work on now than it was some time ago.
As the generator gets more complex, the weird edge cases become much more obvious.
Some creatures still end up way too large and spill off the canvas. Others become extremely tall or paper thin because several generated traits multiply together in unexpected ways.
Eye placement is another big issue. The generator creates proper eye sockets, but the eyes themselves don’t always end up inside those sockets, so some aliens end up looking like they’re staring from somewhere completely different.
Anatomy is also still very disconnected. Heads, limbs, tails, and bodies are generated mostly independently, which sometimes produces creatures that technically make sense but don’t really feel believable. Fixing that means making the different body parts influence each other instead of each system making decisions on its own.
Those are probably the biggest blockers before I start working on animation.
Next up I’ll be focusing on making the anatomy feel much more coherent, fixing eye placement, improving creature proportions, and stopping the generator from producing those wonderfully cursed aliens that somehow escape the canvas.
@aamosm
on
This Alien Does Not Exist
21m 6s logged
Over the last few commits I ended up rewriting most of the generation pipeline.
The biggest change was moving away from generating “random values” and instead generating a complete genome first. That genome now controls almost every part of the creature, with everything else being derived from it.
The generator now supports multiple body plans, including:
Instead of slightly tweaking the same creature over and over, each body plan changes how the anatomy is constructed.
The anatomy generator received a pretty major overhaul.
Heads are no longer just circles with eyes attached. The generator now produces different head shapes along with procedural mouth types including:
Limbs were also rewritten using FABRIK inverse kinematics, giving them much more natural proportions and poses.
Creatures now generate procedural skin patterns instead of using flat colours.
Depending on the generated genome, the renderer can produce:
These are generated using 2D value noise and blended directly into the renderer.
Eyes ended up becoming their own little project.
Instead of drawing circles on top of the creature, eye positions are snapped onto the creature’s surface using the signed distance field.
The generator also derives eye styles from the creature’s ecology. Predators tend to receive forward-facing slit pupils, while prey species are more likely to have wide-set horizontal pupils.
Facts shown beside each creature are now derived from the generated anatomy instead of being randomly selected.
Things like locomotion, diet and vision are inferred from the creature’s proportions, making the generated information much more consistent.
The website also received a complete polish.
You can still share a single link and anyone opening it will generate the exact same alien.
There’s still a lot I want to improve.
The next big goal is making the creatures feel even more alive with better anatomical variation, richer skin patterns, rendering, and eventually a searchable species registry where every discovered alien has its own permanent page. Infact the species registry will run on a WebOs project. Can’t wait to start making that. Also I’m experimenting with rendering, I might make a new branch on github and use webgl
@aamosm
on
This Alien Does Not Exist
16m 23s logged
A procedural alien generator with Infinite unique aliens.
Live: https://thisaliendoesnotexist.app/
This Alien Does Not Exist generates alien creatures entirely from a numerical seed.
There are no pre-made models, stored creatures, or AI-generated images. Every alien is generated from scratch when you open its seed.
The same seed will always generate the same alien, making every creature permanent and shareable through its own URL.
Actually exactly 4,294,967,296 unique deterministic creatures (2³² seeds) exist.
Seed
000481729513
↓
https://thisaliendoesnotexist.app/000481729513
Opening that URL will always generate the exact same alien.
Seed
↓
Genome
↓
Skeleton
↓
Procedural Rendering
↓
Alien
Each generated genome determines characteristics such as:
These values are used to construct the creature before it is rendered entirely from procedural geometry.
devlgo 4
Also the first time trying it straight scared me. so much was wrong. i had flipped x and y. and now ive gone on to have added eyes too, they were just black dots on a fixed position before. the most they would do is scale for size.
I honestly love the eyes. at some points they look so eerie. and fixed a seed-space bug where different IDs could collide onto the same creature.
@aamosm
on
This Alien Does Not Exist
# This Alien Does Not Exist
A procedural alien generator with Infinite unique aliens.
**Live:** https://thisaliendoesnotexist.app/
---
## About
This Alien Does Not Exist generates alien creatures entirely from a numerical seed.
There are **no pre-made models, stored creatures, or AI-generated images**. Every alien is generated from scratch when you open its seed.
The same seed will always generate the same alien, making every creature permanent and shareable through its own URL.
---
## Features
- Deterministic generation
- Infinite unique creatures*
- Permanent, shareable URLs for every creature
- Generated biological traits
- Browser-based renderer
- No AI or stored assets
Actually exactly 4,294,967,296 unique deterministic creatures (2³² seeds) exist.
---
## Example
```text
Seed
000481729513
```
↓
```text
https://thisaliendoesnotexist.app/000481729513
```
Opening that URL will always generate the exact same alien.
---
## How it Works
```text
Seed
↓
Genome
↓
Skeleton
↓
Procedural Rendering
↓
Alien
```
Each generated genome determines characteristics such as:
- Body shape
- Body mass
- Limb count
- Limb length
- Head size
- Neck length
- Tail length
- Eye count
- Horn count
- Skin colour
These values are used to construct the creature before it is rendered entirely from procedural geometry.
---
My current fav is 607290428588 and 589912791323 (straight up just a worm).
@aamosm
on
This Alien Does Not Exist
1h 5m 28s logged
This Alien Doesn’t Exist - devlog 3
Ive basically ended up with a generator that can make vaguely alien-looking blobs. and previously it made worse looking blobs. at one point even dangerously pointy looking aliens. but this is ready for it’s first ship before i work more on rendering
Everything is stable, if i decide to add something more later on. atleast not all of it will break. one part will and ill have to deal with that. first the genome was a part of the user query but i wanted it to be only based on the seed. Using Mulberry32 as a PRNG you can share the same alien with the same link. that’s one of the main features i wanted.
Legs were by far the hardest part.
I implemented FABRIK (Forward And Backward Reaching Inverse Kinematics) so limbs behave like articulated chains instead of rigid spikes.
Ironically, the IK implementation wasn’t the difficult part.
The problem was procedural target generation.
Another rewrite completely separated generation from rendering.
Instead of one function that immediately draws pixels, the engine now returns a complete procedural asset.
and rendering uses that output
Ive made a website for it too. check it out guys. also my current fav critter is 607290428588
@aamosm
on
This Alien Does Not Exist
36m 19s logged
This Alien Doesn’t Exist - devlog 2
guys. the hell did i create? I pivoted massively from metaballs because they were causing plateaus where due to maths there were like dots on the blob. cuz yk. maths. gotta do that
Anyways, i added proper classifications of animals too based on proportions which i found in a paper whiile searching for apt ways to categorize them and made this. uhhh. meet spiky cthulhu. say hi!
@aamosm
on
This Alien Does Not Exist
50m 7s logged
This Alien Doesn’t Exist - devlog 1
👽
I’ve started working on This Alien Doesn’t Exist, a procedural generator that creates alien lifeforms from a single seed.
The idea was inspired by This Person Does Not Exist, but instead of AI, every creature is generated entirely through code. Enter the same seed, and you’ll always get the exact same alien.
⚙️
So far, I’ve implemented the core generation system. This includes seeded procedural generation, body generation using a spine and signed distance fields (SDFs), procedural limb generation, and basic procedural lighting and coloring.
🧬
One thing I wanted to avoid was stitching together pre-made body parts. Rather than choosing from a library of heads or legs, the generator actually creates the creature’s anatomy from scratch.
The next step is making the creatures much more diverse before moving on to things like eyes, skin, horns, and other anatomical features. Hopefully by then they’ll start looking less like blobs and more like actual alien organisms.
