u/MaximusDunton

I’ve been experimenting with reimagining the old 1986 Commodore 64 game “Mafia” into a modern stylized cyberpunk anime sandbox world while preserving the original gameplay structure and city layout.

The original game was surprisingly ambitious for its time. It had districts, subway and train travel, casinos, robberies, bribery, gang hiring, and open ended progression. I always loved the sandbox feeling of it because the city itself felt like a living system you could freely interact with.

Instead of going for dark Blade Runner style cyberpunk, I tried a more colorful and readable “playable city” direction inspired by modern anime urban games. The focus was on strong district identity, atmospheric city life, clean visual readability, stylized futuristic urbanism, and a more social open world vibe instead of grimdark noir.

I attached the original C64 images together with several reinterpretations using a consistent visual style system.

I’d honestly love feedback specifically about the vibe and direction. Does this feel like a good modern evolution of the original Mafia atmosphere, or does it drift too far away from the original sandbox feeling?

I have been experimenting with a hybrid renderer inside my self-developed BASIC interpreter that combines cinematic imagery, realtime Unicode rain effects and ambient audio entirely inside the terminal.

The layered rain moves independently over the static city background to create a strange retro-futuristic atmosphere somewhere between old demo scenes, terminal graphics and cyberpunk visuals.

Still highly experimental, but I really love the mood this direction is starting to create.

I've been experimenting with realtime graphics rendering inside Kitty terminal and ended up with two very different visual aesthetics generated from the same rendering system. One uses high resolution image rendering while the other uses low resolution Unicode halfblock rendering.

What interests me is that the lower resolution version does not simply feel like a degraded version. It creates a very different atmosphere and abstraction level. The high resolution renderer feels cinematic and immersive while the lower resolution version feels much more stylized and almost dreamlike.

Most of the work unexpectedly turned into exploring the behavior and limitations of terminal rendering itself. Things like dirty cell rendering, image placement, terminal cell alignment, scaling artifacts and mixing Unicode rendering with image layers became part of the creative process.

Right now I am experimenting with combining both approaches together. Using detailed terminal image rendering for static scenes and lower resolution Unicode rendering for realtime effects like rain, particles and overlays.

I am curious how people in the generative art space feel about the directions, and what would be optimal.

I've been experimenting with realtime terminal rendering inside Kitty and ended up with two completely different visual styles. One uses a high resolution hybrid Kitty graphics renderer with dirty cell updates and adaptive redraws, while the other uses low resolution Unicode halfblock rendering.

What surprised me is that the lower resolution version does not just feel like a technically worse version. It feels like a completely different artistic medium. The high resolution renderer feels cinematic and immersive while the lower resolution version feels much more stylized and retro.

Most of the work unexpectedly turned into solving rendering problems instead of drawing graphics. Things like terminal cell alignment, dirty tile rendering, image placement behavior, scaling artifacts and mixing Unicode rendering with Kitty graphics turned out to be far more complicated than I expected.

Right now I am experimenting with combining both approaches together. Using Kitty rendering for detailed static backgrounds and Unicode rendering for realtime effects like rain and overlays.

Now I am honestly unsure which direction is more interesting creatively. Pushing terminals toward high resolution realtime rendering or embracing the aesthetics and limitations of lower resolution text graphics.

Curious what the demoscene community thinks about this.

I have been experimenting with a small retro-inspired BASIC runtime called ORBIS and recently focused heavily on terminal rendering performance and fullscreen graphics.

Instead of using SDL or OpenGL, the renderer works directly inside modern terminals using ANSI truecolor escape sequences, Unicode halfblocks and software framebuffers. Initially I expected terminal graphics to be far too slow for realtime animation, but after implementing fullscreen streaming frame output and dirty-cell rendering the results became surprisingly smooth under GPU accelerated terminals like Kitty.

At the moment I have working demos for scrolling panoramas, snowfall simulation, classic fire effects, neon fireworks and simple sprite animation. One of the most interesting discoveries was how dramatically rendering performance changes depending on update strategy. Sparse scenes benefit heavily from dirty rendering while fullscreen scrolling performs much better when generating one giant contiguous frame stream instead of many small cursor updates.

The runtime itself is built around Cosmopolitan portability, so the same executable can run across Linux, Windows, macOS, x86_64 and ARM64 systems with very little platform-specific handling.

This originally started as a fun retro computing experiment, but modern terminals turned out to be much more capable for realtime graphics than I expected. Right now I am mostly focused on polishing the renderer, improving documentation and creating more demos before sharing public preview builds.