VoyagerOS - Devlog 7

Alien Registry

The Alien Registry is finally here.

VoyagerOS can now browse user-submitted species as if they were discoveries made by Voyager-9. Alongside the 4 billion procedurally generated species from This Alien Does Not Exist, anyone can now contribute their own interpretations to the registry.

Try it yourself

I want to start building a community registry.

1. Visit the VoyagerOS repository.
2. Draw your alien in the WebOs
3. Follow the README
4. Open a pull request.

I’d love to see how different people imagine the same species and watch the registry grow over time, and try to forgive my bad drawing.

Guide for submitting your .alr : https://github.com/aamosm/VoyagerOS/blob/main/alr/README.md
Project README:
https://github.com/aamosm/VoyagerOS/blob/main/README.md

VoyagerOS - Devlog 6

Alien registry

The biggest addition in this update is the Alien Registry.

VoyagerOS can now browse, search and view procedurally generated alien species from This Alien Does Not Exist as if they were real discoveries stored aboard Voyager-9. Each entry includes its own observations, classification and registry information while remaining tied to its original seed.

The Paint app also allows exporting a custom file (basically a zip with a diff extension) as custom Aliens. I want them to be able to be uploaded to the repo and work like the dinosaur repo of hackclub.

Bringing the projects together

This is the first step towards connecting the two projects into the same universe.

Instead of existing separately, VoyagerOS now has a purpose beyond being an operating system. It acts as the place where alien records can be documented, searched and explored.

Also made themes better.

Next

The registry is only the beginning.

The next step is expanding it with better search, filtering, observations and more tools for exploring discovered species. also allowing user inputted aliens alongside the already 4.something billion ones.

VoyagerOS - Devlog 4

Building the world

This update focused on making VoyagerOS feel like it has a history instead of just an interface.

I introduced the Compact, a shared registry that keeps track of delegates, records, archived documents and historical events. Rather than placing lore in random text files, everything now lives inside the virtual filesystem and can be explored through normal terminal commands.

Dynamic files

One problem I ran into was keeping certain files up to date.

Things like registry records and submission logs shouldn’t be static, so I changed the file viewer and terminal to generate them when they’re opened. Commands like read, grep, stat and the file viewer all use the same underlying data, keeping everything consistent regardless of how it’s accessed.

New system commands

The shell also gained a few new commands including whois, delegates, charter, access and submit.

Instead of being standalone features, they’re connected directly to the registry and filesystem, making the terminal feel more like a real administration tool rather than just a command prompt.

One thing I’ve noticed while building VoyagerOS is that adding content is becoming just as important as adding features.
The very next thing I want to do is add my project “This Alien Does Not Exist” which has procedurally generated aliens, to make a registry. It could be like, aliens recorded till now.

VoyagerOS - Devlog 3

Improving the desktop

This update was mostly about making VoyagerOS feel less like a collection of windows and more like a real desktop.

I expanded the virtual filesystem with proper file operations and added more shell commands like find, grep, stat, df and man. The manual was also rewritten to make the terminal easier to use.

Desktop workflow

The desktop gained right-click context menus, a system monitor and better file management.

Dragging windows and icons also needed a rewrite. The old mouse-based system became unreliable, so I switched it over to Pointer Events, which made dragging much smoother and fixed several issues.

Desktop icon positions are now saved using LocalStorage, so the workspace stays the way you left it.

Small improvements

There were a lot of smaller changes too:

• Better mobile support using 100dvh
• File properties and rename improvements
• Cleaner terminal output
• Improved process information
• General UI polish

Next

The desktop is now in a much better place.

Next I’ll be expanding the ship software itself, adding more applications and filling the filesystem with logs, manuals and mission data.

VoyagerOS - Devlog 2

Desktop environment

VoyagerOS is no longer just a terminal.

The interface now boots into a desktop environment with draggable windows, a taskbar and a cleaner workspace. Multiple applications can stay open at the same time, making the OS feel much closer to a real operating system.

Applications

Several built-in applications have been added to the system.

These include a file explorer, settings panel, media viewer and a simple browser for navigating mounted data. They all share the same window manager and integrate with the rest of the desktop instead of acting as separate pages.

File system

The file explorer now uses a virtual filesystem instead of static content.

Directories can be browsed through the desktop interface, giving VoyagerOS a proper file hierarchy to build future features on.

Interface improvements

A lot of the interface was cleaned up during this update.

The desktop now has a proper wallpaper, improved window styling, better spacing and a more consistent visual style across the operating system. Small changes like these make the whole environment feel much more cohesive.

Observations

Moving from a terminal-only interface to a desktop introduced a lot of state management problems.

Keeping track of active windows, focus order and application state ended up being much more involved than expected, but it also made the rest of the system easier to expand in the future.

Next

The desktop is now in place.

The next step is adding more applications, expanding the filesystem and continuing to make VoyagerOS feel like software that could actually exist aboard Voyager-9 and fixing drag of icons.

VoyagerOS - Devlog 1

The idea

VoyagerOS is an experiment to see how far a browser could be pushed to feel like a real operating system.

The goal isn’t to make another futuristic UI. I wanted it to feel like software that actually belonged on a deep-space probe. Everything is built around a terminal interface where the user interacts with the system through commands instead of buttons and menus.

Building the foundation

The project is built entirely with HTML, CSS and JavaScript.

The first milestone was getting the boot sequence and terminal working. The boot process now transitions into a persistent shell with command history, input parsing and a window manager capable of handling multiple processes at once.

The interface is still simple, but the focus has been on making it feel consistent rather than flashy.

Internet Archive integration

One of the main ideas behind VoyagerOS is that it can mount real data from outside the system.

The first approach was embedding the Internet Archive directly, but it quickly became obvious that it broke the illusion. Logos, navigation bars and the surrounding website made it feel like a browser instead of an operating system.

I scrapped that approach and rebuilt it around the Internet Archive Metadata API instead.

Instead of displaying web pages, VoyagerOS now requests metadata, lets the user choose what to mount, and renders the data inside its own interface. Everything stays inside the OS instead of sending the user to another website.

Current state

At the moment VoyagerOS has:

• A boot sequence
• A persistent terminal
• Command history and parsing
• A native window manager
• Internet Archive integration through the Metadata API
• Dynamic mounting of external data inside the operating system

Next

The next step is expanding the shell itself.

I want to add more system commands, improve the filesystem, introduce more ship subsystems and continue making the environment feel like a real operating system rather than just a terminal running in a browser.

This Alien Does Not Exist - Devlog 8

Better creatures

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.

Similar creature search

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.

Observation engine

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.

UI improvements

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.

Next

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.

This Alien Does Not Exist - Devlog 7

changed from Doesn’t to Does Not

Deterministic generation

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.

Registry

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:

• finding similar creatures
• rarity
• grouping species together
• procedural descriptions
• a searchable registry

Since everything comes from the seed, it’ll always stay consistent.

Rendering

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.

Next

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.

This Alien Doesn’t Exist - Devlog #6

Rendering improvements… and a lot of weird aliens

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.

Under the hood

Most of the work happened inside the generation pipeline.

Some of the changes include:

• Refactoring the rendering code
• Cleaning up URL routing and history handling
• Moving material and pattern logic into dedicated systems
• Removing old experimental code
• Simplifying parts of the generation pipeline

The project is much easier to work on now than it was some time ago.

The problems I’m running into

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.

This Alien Doesn’t Exist - Devlog #5

The generator is finally starting to feel like an actual biology engine.

A complete rewrite

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.

Body plans

The generator now supports multiple body plans, including:

• Quadruped
• Biped
• Serpentine
• Insectoid
• Arachnoid
• Cephalopod
• Radial

Instead of slightly tweaking the same creature over and over, each body plan changes how the anatomy is constructed.

Better anatomy

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:

• Jaws
• Beaks
• Mandibles
• Proboscises
• Filter feeders

Limbs were also rewritten using FABRIK inverse kinematics, giving them much more natural proportions and poses.

Skin generation

Creatures now generate procedural skin patterns instead of using flat colours.

Depending on the generated genome, the renderer can produce:

• Spots
• Stripes
• Mottled patterns

These are generated using 2D value noise and blended directly into the renderer.

Eyes

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.

Smarter traits

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.

Website

The website also received a complete polish.

• Deep linking works correctly.
• The UI has been cleaned up.

You can still share a single link and anyone opening it will generate the exact same alien.

What’s next?

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

didnt know that shipping doesnt follow same formatting 😭 so here ya go. hoepfully it looks better here. this is not just a copy of the ship ive added the changes at the end

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

Seed
000481729513

↓

https://thisaliendoesnotexist.app/000481729513

Opening that URL will always generate the exact same alien.

How it Works

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.

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.

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

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!

Seven Minute Shadow - devlog 6
.
First devlog after trying to ship, there are evident problems with even the v0.1 demo. Whenever someone clicked on try again or would reset the game, the counter in global for mingames would still remain the incremented value. Basically it would not be a new instance. So I hardcoded the values to what they are supposed to be in the beginning. it would also track hearts and if it became 0 once it would carry forward which i had to fix.
The mailman is not supposed to be playable. I probably shouldnt have made it able to move by player but i did just in case but also caused an issue when it didnt remain in animation. so had to fix that crack.
Also there would be errors in the console that while not game breaking would affect performance. it was due to the fov being under 1 after subtraction in tween. had to fix that.
i thought my devlog after ship would be for more feature but ig im stuck on bugs. but ill continue working on this and my other project. still have to implement music, more minigames, and the full storyline.
Anyways, i hope you find demo v0.2 interesting till then.

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.

Seven Minute Shadow - devlog 5
🚀
The demo is finally made! Just got the first playable version shipped out so the core loop is actually testable from start to finish.
🕹️
Spent today officially adding Minigame 2 to the roster. Also had to go back and push a bunch of updates and bug fixes to Minigame 1 so the transition between them flows smoothly without breaking everything.
🏁
Finally connected the GameOver and Win scenes. The win screen right now is a temp one-it grabs your remaining hearts straight from global.gd to show your score. It’s basically ending 0/3: The Demo Ending. The plane still flies but at least the day went good, or something like that. I’ll make it look much better later, but the logic is wired up.
🔬
Now that the demo is out of the way, I’m gonna go way more in-depth into the project. Time to really expand on the actual narrative, stop relying on placeholders, and start building out the rest of the 7 minigames properly.
🤌
what all im gonna add now:
🎵
Music and SFX. I mentioned in an earlier devlog that music would be added way later down the line, well I guess we’re getting there now. Really need those snappy sound effects to make the rapid-fire minigames feel punchy.
🎨
Asset overhaul. My pixel art skills are bad. and i gotta make em again.
📖
The remaining 5 minigames. Getting back to the drawing board to design the rest of the levels to hit that total of 7.
🎭
The real endings. Building out the actual narrative paths so I can replace the temp “Demo Ending” with the real Endings 1, 2, and 3. Gotta make the lore actually matter yk.