Game Title: Land of Ascii

Playable Link: https://oddslice.itch.io/land-of-ascii

Platform: WEB/HTML

Description: There's a fort on a hill and a lake to walk to. The villagers go about their own days; say hello and some of them will ask you a small favour. Stop wherever the view is good and sketch it. Night falls, rain sets in and clears again, and the music and every sound are made in code as you walk.

Half an hour is enough to see the main sights. After that the land is still there whenever you want a calm walk, and each seed builds a different world.

- The whole game is one HTML file of about 1 MB (1,017 KB). No images, no engine, no downloads.

- The world is 2 x 2 km. Walking straight across takes about 8 minutes.

- Every frame is around 40,000 letters, drawn from 28 characters in 617 colours.

- 32 kinds of sound and 3 music tracks, all made in code as you play. There isn't a single recording.

- The default world has nearly 12,000 trees, 58 villagers, 255 animals and 59 buildings.

- The villagers have 329 lines of dialogue between them.

- 27,000 lines of code, with no libraries.

Free to Play Status:

• [ ] Free to play

Involvement: solo dev

Spent about 4 years chipping away at this track generator. First in Unity then ported to Godot 3.6. It also supports intersections and simple highway interchanges. I enjoy sitting back and seeing what it comes up with.

Next step after the dividing cells: each amoeba is a bubble of the same foam rule. Its skin pulls taut and it keeps its area. On top of that its edge reaches out:

- By smell: food gives off a smell that spreads and fades. The edge bulges where the smell is stronger than its own average, so a pseudopod reaches towards food and the back pulls in. In blind mode it wanders at random and only finds food by touching it.

- Eat, grow, divide, starve: what it eats becomes area. Living burns that area away. At twice its size it divides, and starved to a third it dies.

Try it: https://geotyper.github.io/taut/amoeba.html

Every city is uniquely generated from a random seed, based on the QR code requested. Tons of sliders to control the generation rules!

I made this using Blender nodes. You can watch my YT tutorial if you want to make something like that.🙂

The game is about exploring the infinite, endless procedural world of stars, planets, galaxies. The game does not include real planets or real stars or galaxies. Real names can be observed at the home location and names like "Andromeda" or "Milky Way" and the whole solar system. Tho it is possible they will not be in soon updates.

Link: https://astro.ableproman.hu/

The game is inspired by Space Engine, that is only on Steam and is not free. I made this game for people who want open world real scaled worlds to explore and visit throughout the universe for free without downloads.

Graphics are all made with three.js and looks incredible. I am updating until it works perfectly.

It works on desktop and mobile too.

I am ready for any review or feedback of the game!!

(The images are from the actual game from browser!)

Managed to get through a full map playthrough on the Steam Machine now most bugs and glitches have been resolved (C++/OpenGL/GLSL). Final polishing before release (+ a few more candidate maps to clean up and include). It won't sell but I'll continue working on it anyway.

I'm making ground impact effects in Godot, and I draw the crack in polar coordinates in the fragment shader. I take each pixel's angle and radius and measure the distance to the nearest of ten arms. That's the usual polar trick, nothing new. But since it's a distance field, more arms cost basically nothing.

My first arms only bent with one smooth octave of value noise. They looked like tentacles!

Real cracks are mostly straight with kinks. So now each arm gets the slow bend plus a weaker, faster one on top, and I scale the bend up with the radius so the arms leave the center almost straight.

If every arm reaches the rim it's a sea star. I let each one stop somewhere between 62% and 100% of the radius, and one branch peels off part way out.

I also stand the rock shards on that function with the same seed. That way I never get a shard sitting next to a crack.

I ported the function to numpy for the picture. Does anyone have a trick to make the branches look less glued on?

Not that I have built it yet, but any function of space simulation, it is very math involved, especially in higher dimensions. A major discovery though, for obscuring, you only need object A is in front or behind object B, not exactness needed. Also needed is where pixels go, but with the correct rotations, set one function set to another and you have where one pixel goes, repeat for all pixels. The obscuring can use either the integral form over a finite arbitrary number or just derivatives of the original function or both, in many cases just Euclidean distance could work, but not all. The distance function is an integral of a square root of a sum of squares, so avoiding that is awesome. Good luck everyone. X E.

I'm the creator of Cbirds, a 2D/3D bird flock simulator that runs in the terminal, written in C99 and inspired by Craig Reynolds' Boids algorithm. The video is the 3D mode running in Ghostty on macOS.

I started working on the 2D version in September 2025, mostly out of curiosity. I wanted to see whether it was possible to build a real time simulation inside a terminal using the Kitty graphics protocol.

The idea came from two places: antirez's amazing C64 terminal emulator (https://github.com/antirez/c64-kitty), and a lecture from the Foundations of AI course at Politecnico di Milano, where Professor Pier Luca Lanzi was discussing multi agent systems.

I really dislike relying on third party libraries, so I decided to implement everything from scratch in C99. I did get quite a bit of help from coding agents along the way. One interesting thing I ended up building was a custom GIF encoder, which allowed the agents to visually inspect the simulation and check whether their changes were working as intended.

The original 2D simulation is conceptually quite simple, based on the three classic rules from Craig Reynolds' work: alignment, cohesion, and separation.

In 3D each bird only listens to its nearest neighbours, seven by default as real starlings do, instead of everyone within a radius. A pull toward a roost keeps the flock in view, and a slow drift in the air over the roost does the rest: the bands, the splits and the folds in the video all come out of those rules.

From there, the project gradually grew to include:

- A full 3D simulation and renderer, running entirely in the terminal
- Real time tuning of simulation parameters
- The ability to pipe text into Cbirds and watch it fly around (e.g. `cat file.txt | cbirds`)
- Multiple flocks with different colors, with runtime controls to make them merge or avoid each other
- Hawks that chase the birds
- Different rendering techniques, ranging from PNG images displayed through the Kitty graphics protocol to Braille characters
- IPC support that lets birds fly between different terminal windows

What started as a small experiment has turned into a much bigger project than I originally expected.

Some of you may have seen the browser port posted here last week (https://nicobrenner.github.io/flock/). This is the terminal program it started from.

Source: https://github.com/clainstone/cbirds
Command in the video: `cbirds --render kitty --3d --color prism`
Install: `brew install clainstone/tap/cbirds` (also MacPorts, apt and Nix, see the README)