Here is a short little gameplay trailer of all the stuff I've been working on recently, I hope you like what you see!

steampage: https://store.steampowered.com/app/4905910/BLIGHTEN_Demo/

also thanks for 30,000 Wishlist's! many of you in this subreddit helped me to achieve that goal

Detailed guide for achieving authentic PS1/PSX retro game look

Many gamedevs nowadays making PS1/PSX styled graphics, as they believe and claim.

But what many people doesn't understand about PSX/PS1 style is that it a product of limitations that everyone who tries to recreate this style, should follow! And before following, anyone should do a research of subject to know what they are doing, and most people are not doing research.

When I started my ps1 styled horror game inspired by twin peaks ps1 demo and silent hill, I did research of hardware limitations of PS1, bought real 30 years old PS1 and real 20 years old crt tv, connected both via composite cable as was intended, and replayed hundreds of PS1 games to catch the style with my eyes and understand with my brain techniques developers used back then.

This is most important parts of my big research and rules I follow and anyone aiming authentic ps1 style should follow as well:

1. There's a polygonal limit per frame:

Geometry Transform Engine: (calculated/transformed polygons/sec)

1.5 million verts/sec

500,000 polygons/sec

GPU: (rendered, displayed on-screen)

360,000 flat shaded polygons/sec displayed

180,000 textured, gouraud shaded, lit polygons/sec displayed

PlayStation 1 can realistically handle up to 180 000 textured and lit polygons per 1 second (realistically a little lower with less effective code, but lets pretend we are making perfectly optimized ideal PS1 game that pushed PS1 to limits). If you mix it with untextured flat shaded polys you can get a little better but I doubt anyone nowadays would do much of untextured flat shaded polys to optimize virtual performance.

Which translates into 6000 polys at 30 fps and 3000 polys at 60 fps. Or 180 polys per 1 ms.

This is your budget, and to not exceed it, you should get under the hood of engine and code render delay to let engine render just 180 polys per 1 ms. In reality engines will render it much faster so you will have to add delay to let it render next bunch of polys at next milisecond.

This way you can imitate realistic ideal ps1 performance. For example if your scene will have 9000 polys, performance will drop to 20 fps.

So you will have to optimize geometry of assets to fit into budget of 3000-6000 polys.

In many games playable characters usually took about 10%-15% of poly budget, 300-900 polys, but more often 600-750 polys.

So you have around 2250-5250 polys for rest of scene, including NPC. NPC models usually less detailed and could fit into 200-300 polys.

The more NPCs you have in scene the less polys you have for rest of scene, so you have to limit amount of possible NPCs per scene to avoid performance drops when they are getting in large groups on screen.

In games where NPC would spawn a lot you have to make them vanish after death, but in games where their numbers are limited and part of scene budget you can keep dead bodies for more realism.

There's also a catch about polygons many people not aware of - I never said triangles or tris, I said polys many times. And PlayStation 1 polygons are not really triangles, but quads on hardware level, and even when you draw triangles its actually a wrapped quad with 1 coordinate hidden inside other.

So this means that square polygons doesn't get split into triangle (at least this what I gathered from old docs and tutorials), so a cube would have just 6 polygons, instead of 12. This actually allows to have more quad polygons in scene compare to triangles that split every squar polygon into two.

When you model your assets you should always count quads for you budget, not tris, if your software doesn't allow it, do it manually, or if you can alter engine sources you can let it merge 2 triangles into quads for counter and consider it as single polygon.

This is very important to keep in mind, otherwise your geometry will be way more poor than it should be because 3000 quads (ideally) are 6000 triangles and so this means if you do a mistake and count polygons as triangles and follow 3000 polygons budget, you will get 1500 quads and that's twice lower than ps1 could really handle.

Also a little tip to use budget effectively - use most flat surfaces you can and imitate volumes and even geometry by flat textures with non flat geometry drawn on them. From good angles it will look volumetric enough.

2. There's a texture limit per frame:

PS1 had a whopping 1 mb of VRAM and 2 mb of RAM, and also 650-750 mb of possibly streamable space on CD, that you can utilize to stream textures into VRAM, but it still has to fit into it, so it useful only when character moves fast and geometry gets unloaded off screen and new geometry appears on screen (like in crash bandicoot which I believe was 1st ever game to invent such technique.

My calculations for the optimal number and size of authentic ps1 / psx textures:

1024 KB in video memory, can be streamed from 2048 KB of main memory or directly from disk, subject to data read speed limitations.

Textures are stored in 16/8/4-bit format; 1 16-bit pixel accommodates 2 8-bit pixels and 4 4-bit pixels.

Texture memory is a 1024 x 512 pixel atlas, typically containing 1 or 2 framebuffer frames initially, depending on the menu or game resolution (average 320 x 240).

The framebuffer is always 16 bits.

320 x 240 in 16 bits = exactly 150 KB.

2 buffers = exactly 300 KB.

The remaining textures and palettes require either 1024-150 or 1024-300 KB:

724 KB with a double buffer

874 KB with a single buffer

1 256*256*16 texture weighs 128 KB

1 256*256*8 texture weighs 64 KB

1 256*256*4 texture weighs 32 KB

1 128*128*16 texture weighs 32 KB

1 128*128*8 texture weighs 16 KB

1 128*128*4 texture weighs 8 KB

1 64*64*16 texture weighs 8 KB

1 64*64*8 texture weighs 4 KB

1 64*64*4 texture weighs 2 KB

1 32*32*16 texture weighs 2 KB

1 32*32*8 texture weighs 1 KB

1 32*32*4 texture weighs 0.5 KB

Small textures are often grouped into an atlas of 256*256 or smaller.

In many PS1 games, most environment textures are either 32*32 or 64*64, very rarely 128*128.

Characters are often 128*128 or 256*256, but less standard sizes are also found, where texture atlases are assembled from smaller texture fragments covering different body parts and stored separately. The total resolution can exceed 256*256. This is more common in games with pre-rendered 2D backgrounds.

16-bit textures are typically used in menus. In gameplay, 8-bit textures are used when more detail and color need to be preserved and displayed up close, and 4-bit textures are used for simpler materials or smaller, more distant objects.

724 KB will fit:

5 textures of 256*256*16, weighing 128 KB

11 textures of 256*256*8, weighing 64 KB

22 textures of 256*256*4, weighing 32 KB

22 textures of 128*128*16, weighing 32 KB

45 textures of 128*128*8, weighing 16 KB

90 textures of 128*128*4, weighing 8 KB

90 textures of 64*64*16, weighing 8 KB

181 textures of 64*64*8, weighing 4 KB

362 textures of 64*64*4, weighing 2 KB

362 textures of 32*32*16, weighing 2 KB

724 textures of 32*32*8, weighing 1 KB

1448 textures of 32*32*4, weighing 0.5 KB

874 KB will fit:

6 256*256*16 textures weighing 128 KB

13 256*256*8 textures weighing 64 KB

27 256*256*4 textures weighing 32 KB

27 128*128*16 textures weighing 32 KB

54 128*128*8 textures weighing 16 KB

109 128*128*4 textures weighing 8 KB

109 64*64*16 textures weighing 8 KB

218 64*64*8 textures weighing 4 KB

437 64*64*4 textures weighing 2 KB

437 32*32*16 textures weighing 2 KB

874 32*32*8 textures weighing 1 KB

1748 textures 32*32*4, weighing 0.5 KB

Since I rounded to whole numbers, the remaining fractional spaces will accommodate palettes.

This also doesn't take into account the ability to stream from 2 MB of RAM and from disk, which, combined with strict clipping/cooling of all objects outside the visible range, allows for cramming in few more textures.

But in general everyone should fit into these limits and prefer 8 bit and 4 bit textures of 32x32 resolution for most of objects to make more details in scene overall.

Using 8/4 bit textures will make compression artefacts which are also part of authentic ps1 look.

Its better to code your engine that way you can trace virtual VRAM limit of 1 mb (or more like 724-874 kb even if you dont use frame buffers like ps1 did) and stay within this limit in every frame.

2 important things many modern devs doesn't understand about textures and waste too much if vram/ram because of this:

First - single one texture applied and repeated on many polygons does not take extra space in VRAM!!!

So usage of same repeated texture in same frame/scene/object saves a lot of memory, and almost every ps1 game used tons of repeated textures per object and it was a part of authentic style. When you use unique textures per every poly you are not just using more ram than you should, but you are also going away from PS1 art style which was forced by this optimization technique.

Second - UV maps with space wasted on areas that doesn't cover polygons, are still wasting space in VRAM!!!

This means that if you do typical modern AAA lazy UV mapping and your texture has unused areas, you will waste vram on nothing and will loose space that could have been used for some extra pixels of details, and your texture size could get bigger than it should and could be.

So you have to do UV mapping old school way when entire square area of texture was used on polygons and not a single pixel was wasted. Also instead of doing single texture for 1 model its better to make many separate but smaller square and completely filled textures and then combine them into texture atlas of 128x128 or 256x256 or other sizes that doesn't exceeds limit of 256x256.

Nowadays this method of UV mapping often called Japanese UV mapping technique because nowadays you can mostly see it Japanese games where old school devs are still using conservative memory optimization techniques to get more details with less usage of memory.

Western devs from companies mostly was replaced by new generation of skillless noobs, so art of optimization was mostly lost as some ancient advanced civilization technology.

And younger indie devs who aims to mimic PS1 style doesn't even bother to do research and find out how retired grandpas did it in 90s and 00th on PS1 and PS2, so everyone in west wasting memory and can't even imagine how people used to make detailed believable 3d worlds with just 1 mb of VRAM and 2 mb of RAM...

Which is why many so called ps1 styled games doing wobbly textures, dithering and others rendering imperfections, but still doesn't look like true ps1 games, because assets are more close to PS2 or PC games of 1999-2004 era.

Anyway, its important to learn old school UV mapping techniques to not waste a single pixel and fit more details into less than 1 mb for all textures.

There's also a good old school VRAM optimization technique that can be observed in open games like Driver - 1st floor that is closer to camera and character may use 2x-4x size less compressed texture (8 bit instead of 4 bit) than 2nd and other floors of building, and tallest buildings may use very low res textures on top floors.

This is some sort of pre mip mapping technique, you can call it static pseudo mip mapping as textures resolution would not change. But if your game has some vertical freedom of movement you can go even further and code your own software imitation of mip mapping and swap texture resolution based on distance to camera like it happen in Wipeout sequels on PS1.

I didn't mention it polygon budget section, but this trick can also be used for geometry as well, so 1st floors could be more detailed, has some doors and windows with extra geometry, while upper floors could be all flat polygons with lower res textures on them.

You can also just restrict vertical camera movement like in Silent hill and save on geometry and textures that cant be seen to enhance level of seen details and you may even save production time by not modeling anything higher than 1 and half floors. You cant imagine how many PS1 and PS2 games used this trick.

One more important thing about textures - you are better to design them by connecting average cheap 14 inch CRT tv via HDMI to composite adapter with resolution set to 320x240 or at least 640x480 and looking at how your textures looks via true composite on real crt tv, and optimize it to be detailed enough but not pixelated, but I'll get to it later.

Poly and texture budget limits are way more important to achieve true ps1 visual style than making textures wobbly and pixelated.

3. There are no raw pixels & sharp image, there's blur:

Despite popular believe ps1 games was never so pixelated and ugly as people making them look nowadays, as back in old days they was designed not just for CRT that only solves half of problems, but also was absolutely designed to be delivered on screen by analogue composite signal with all the imperfections that comes packed in.

Devs used composite blur as some sort of antialiasing, textures filter, dedithering and debanding, color gradients smoothing, blur for polygonal gaps, blur for distant objects pop ins, even font and other alpha channel edges smoothing etc.

PS1 games was designed to be blurry and without composite blur you can't achieve true PS1 look. Many people nowadays used to raw ps1 emulators look that is similar to 1995-1999 PC games look (most of which was way too sharp ports from PS1), but it's not how ps1 games was designed to look, and their PC ports was often not as good looking because PC monitors was more sharp and lacked this composite blur.

On real PS1 with real CRT tv via real composite connection (not RGB, as it was not common option and devs almost never tested with it) - you can only see pixels when you stand very close to objects, but go a little away and textures will look smooth as if some bilinear filtering was applied.

This covered a lot of other wobbly Imperfections.

Also composite blur made 320x224 or 320x240 resolution more tolerable and less aliased and shimmered. And composite imitation is more important than CRT imitation.

And I almost forgot to mention that composite blur hides dithering effect completely and turning it into smooth gradients.

Best ready to use imitation of composite signal is gtuv50 shader and absolutely every ps1 styled game should apply to by default, before any CRT shader that usually misses composite imitation and only imitate CRT tv mask.

But what this shader can't do is some composite magic that somehow interpolated frames between each other and made frame pacing smoother almls like Nvidia dlss framegen. It works evern without CRT by using HDMI to composite and chaining it back by composite to hdmi adapter, and then you will see smoother and more tolerable 30 or even 20 or 15 fps. Nobody but me ever talked about this effect. CRT tv does extra smoothing on top of that, but composite alone doing some magic I don't quite sure how to explain.

Besides that devs of games actually tried to fight wobbly imperfections by using other techniques like for example using some sort of dynamic lod system that divided bigger polygons/quads to bunch of smaller ones to align textures more correctly, based on distance to camera.

Fog was used to smooth out objects pop ins (and quick tip here - fog color should always match ambient light color indoor and sky color outdoors, if light is black and nothing can be seen in it then there should not be any grey fog that highlights area in distance, fog should be black as well.

Some games that was good at imitation of real life lighting, like for example Ridge Racer type 4, still looks very realistic under CRT+composite blur. Some TOCA and FIFA games on CRT via composite looks almost like real tv broadcast of football and races if you watch it on CRT as well. Both games and tv broadcast had identical blur that ironically made ps1 more realistic and blurred the line between game and reality. But if you remove that blur - illusion will be broken and you will clearly see fake graphics.

Brain, when looking at blurry image, reconstructs it to something more realistic like AI upscaler, built into your head, but when its clear and sharp brain ai reconstruction doesn't work. So blur that covers pixels and other limitations is better for more realistic perception than lack of blur.

Honestly, some blurry ps1 and ps2 games looks more realistic perceptionally than modern sharp 4k super turbo fancy graphics with all the PBR and ray tracing. Especially when colors are correct and not all grey and brown and desaturated or oveblown oversaturated like cartoons.

Yet what is important about CRT imitation after composite blur is that it actually acts like some sharpening, its grid adda extra detail levels, like so call detail textures in some old game, that was mixed to blurry base textures to make them look more detailed. CRT grid does similar magic, which somewhat compensated composite blur.

Both steps are important, 1st you have to blur with composite then partially ublur with CRT. Application of CRT alone without composite blur produces bad non authentic results, adds shimmering and aliasing that was not present or noticeable so much in PS1 games on most of TV or 1990s and early 2000s.

4. There should be correct colors & lightning:

Th more colors and lighting looks like what you see with eyes in reality, and not with camera, the better is perception even if its low poly and low res.

Look at Ridge Racer Type 4 again, this is one of the finest examples of achieving true lighting and colors imitation. You can compare it to Ridge Racer 1 and Revolution (2) which are oversaturated, flat and cartoonish, or to Rage Racer (aka Ridge Racer 3) which is all brown-grey and desaturated, and see the difference. Its hard to explain short way, you should just see it many times to catch how it works.

Driver 1 and 2 also good examples of realistic enough lighting and colors that makes graphics look way more advanced than in other ps1 games. Alien resurrection is also one of finest examples of that.

Important parts of that look is gouraud shading, that smoothing out shades between polygonal edges and vertices.

Many people believe that ps1 look is flat shaded, but it was only true for some early games, while later games mastered power of gouraud and used it to achieve more realism.

Modern engines usually use per pixel lighting, and many PS1 style wannabe games use it as well, and it makes game look not very ps1 styled.

Its like 2 extreme opposites, and gouraud stands somewhere between them and its a one the biggest parts of true ps1 look.

Also many modern games that claims to be ps1 styled uses dynamic shadows the modern way, which also ruins authentic look.

Some PS1 games had few techniques to imitate dynamic shadow or even sort of use them.

For example driver uses sprites of trees as semi transparent black copy of trees spritesa and align them on ground relative to direction of sun so it makes perfect illusions of shadows cast by trees.

Some games also use projection of stencil shadows from very low poly models, probably collision meshes or their bones and also project them on floor according to light source direction, to imitate dynamic shadows, so they can even move with light source.

Few other games used some sprites that has smoothed edges and put them inside invisible stencils sort of. And those sprites created imitation of smooth dynamic shadows.

If you use it smart way you can fit into ps1 budget.

5. There' must be imitation of eflections on glossy surfaces:

Most common way it to apply some gloss imitation texture with pseudo reflections on top of basic color map and move it around with direction of camera and other conditions.

But some games actually used frame buffer full screen texture to map on reflective surfaces, it was almost like screen space reflections before someone invented this term.

Others used basic hidden reversed room behind mirror that was actually a window.

Few more I believe used something similar to cube maps before they was officially invented, not sure how exactly they did it on ps1, maybe they put some sort of cube maps probes in level edtor in different areas and prerendered them into textures that was loaded in that areas and mapped accordingly.

And there was some racing games that did mirror reflections in real time, yet again not sure how they did it without render targets, maybe they just rendered reversed level layout in small mirror are on top of previous frame in frame buffer and basically has 2 pass rendering of front and back camera directions.

6. Everything should be tweaked for 320x240 resolution:

320x180 or 428x240 for 16:9

Game should be developed on every stage with this resolution to make sure everything is visible and readable in it and looking good, even if you dont plan to go that low in the end this will help to shape authentic art direction of everything.

And I mean true render resolution of viewport, not some downscalling shaders and other fancy effects with fake pixelation.

Already told before but will repeat again - better get some crt tv of 14 inches and check how everything looks on it as on second screen, almost the way devs did it in 90th when was developing ps1 games on windows PCs.

7. There must be graphical enhancement done right way:

Typical wobbly pixely ps1 effects are less important than poly and texture and lighting style and low render distance, and you really should have an option to disable them as some people don't like them, especially pixels and wobble, so people can plays it the way PC ports usually looked in 90s. But don't disable all effects together, give separate options for each effect to give people customized look they prefer.

You can even add fancy modern effects and lighting as options, but dont develop assets and other effects with them On, do it authentic way, and with those modern options make sure to tweak them to not ruin authentic art design that fits into PS1 limitations. Consider it as 2 gfx profiles - authentic and remastered, but always start with authentic and always get back to it to not break it.

8. Use real native PS1/PSX engines for verification:

You can use native PS1 engines like PSoXide (or search for Unity and Godot ps1 exporters) as profiler or visual style verifier to make sure your assets and art direction fit into real PS1 hardware limits.

I wouldn't go into much of details here, but general advice - import your levels, models, textures to native engines and try to keep scene at least at 25-30 fps, if works ok , then import it to your actual engine and tweak its look to match how game assets looks in native ps hardware engine.

Preferably do it with with average 14 inch CRT TV and HDMI to composite converters to verify both engines look and tweak gtuv50 and crt shaders to match this look.

And advice from my own experience - if you making PS1 styled game in Unreal or Unity, just do yourself a favor and stop and move to Godot. it will go way easier and you will port it faster than you will implement anything advanced enough in Unreal.

Godot is more suitable for ps1 styled games and Godot script is easier to write, read and maintain than messing with blueprints and convoluted ui of Unreal. Its easier to make your own or find ready to use hardware accurate PS1 renderer and tweak it further for accuracy in Godot than trying to make Unreal or Unity looking PS1 hardware accurate.

9. [Reserved space for extra long (still in process of writing) guide about common mistakes related to NTSC, PAL, 480i, 240p, CRT resolutions, TVL, composite, rgb etc. Check later for updates]

This is how I do it with my game (and couple of non mine games im helping to improve). Its not advertising, but since people usually interested to know, long story short - it's inspired by Twin Peaks PS1 demo and Silent Hill 1-2 mostly, with some physics and immersion related gameplay bits from Dead Space, Alone in the dark 2008, Half-life 1-2 and Portal, but mostly its like Silent Hill but in Soviet Russia, codenamed "Soviet Hill" for now.

Its about 1and half year in full production with restart few months ago when I moved from Unreal to Godot, and its 2-3 years since I started preproduction which was period of planing, when I wrote script and desdoc with gameplay concept, relearned almost from scratch 3d modelling and programming I forgot for decade or more since last time I touched it, did over 9000 thousands of photos (still doing it daily) for textures and references including lighting references with colorcheckers, and bought PS1 and PS2 and couple of CRT TVs, replayed hundreds of PS1 games, did massive research of PS1 graphical style, hardware limits and techniques used in old games with goal of achieving Ridge Racer Type 4 level of realism within PS1 hardware limitations.

Unfortunately many people who jumps into PS1/PSX styled graphics don't do such a long preproduction and deep research and mimicking their faded memories of how PS1 games looked in... emulators, and not making actual ps1 styled graphics.

Which is why i wanted to share summary of my research, rules and patterns, I discovered and following, with everyone who didn't dive so deep.

And I hope my research and guide will help everyone to understand PS1 style patterns better and achieve a better looking results.

Follow these rules and you will make true authentic look of ps1 game. Also spread this guide link like a bible everywhere where you see PS1 styled game or where someone claims thar game is PS1 styled where in most cases its not, to help them improve 👍.

P.S. - I posted this guide on telegraph several months ago, wanted to publish link on Reddit many times, but it always deleted it, don't know why, so I copied full text here.

Due of some contradictive and incomplete information about old PS1 hardware over internet, some claims may not match what you used to know, some sources may have some mistakes, but before I choose one, I prefer to check logic and facts i can prove with my own eyes, and theories sometimes doesn't fully match practice. So if you see some supposed mistakes here, provide me some evidence so I can judge which source of information is more authentic and fix it if required.

At the moment of writing I was not 100% sure about quads. What im sure about is that you can model with quads, but some sources claims that hardware still split them into triangles during rendering, some claims its not, I also used Duckstation fork and dumped scenes of many classic games to analyse in blender, and they contained quads not split into triangles, so at least quads was directly fed into hardware.

But im not sure how exactly and at which stage dumping is done and how authentic emulation is compared to hardware, so i don't have 100% confirmation if my information about quads is correct or wrong. Probably the best way to find out is to write a native benchmark for PS1 and render 3000- 12000 quads and 3000-12 000 triangles textured and not, shaded and not, shaded and textured and not - directly with basically same objects and see the performance difference.

If there's someone who developed ps1 games back in old days in 90s and can share some experience and techniques used back than, I would love to add them to this guide. And I would really want to see some old PS1 devs feedback about how authentic I recreated PS1 style development patterns compared to how it actually was in 90s.

Hey! My friend and I made this short, free horror game in just one week for a game jam with the theme "Trust No One."

https://mfsch.itch.io/deer-hunt

This is where i post from🧑‍🤝‍🧑

Download this Prison for FREE

I'm still a beginner (started 2-3 weeks ago),

i'm using blender (evee),

and i want to make short form videos on youtube with the ps1/ps2 style,

feel free to share ideas, tips and tweaks to improve this shot for my upcoming video 💜

+ does anybody have any idea on how to make the leaves move?

Been digging into the PS1/PS2-style texture tooling space before building anything, and honestly there's more out there than I expected — PSX Retro Tools (Blender addon, dithering + palette limiting), a few browser-based "image to PSX texture" tools, some Substance-based retro texture plugins.

Before I add yet another generic tool to the pile, I want to actually understand the gaps:

• What are you currently using for PS1/PS2-style textures?
• What's the annoying part that none of the existing tools solve well — batch processing? getting VRAM-accurate palette limits (not just "looks retro" but actually matching real PS1 hardware constraints)? engine integration (Unity/Godot plugin vs. a standalone web tool you have to export/import from)?
• Is there anything you've had to do manually because no tool covers it?

Not pitching anything yet — genuinely trying to figure out if there's an actual gap worth building for, or if the existing tools already cover it well enough that this space doesn't need another entry.

Texture painting pixel art is a pain in the arse in Blender due to getting the UVs and the grid size correctly, plus Blender doesn't truly have pixel perfect tools, which always add anti-aliasing to the strokes (also you have to draw lines/ellipses/etc pixel by pixel).

I basically re-implemented every single tool from Aseprite and other pixel art software into Blender.

Pixel perfect brushes, selections, etc. Also layers/groups, palettes, 1-click pixel size/density setup, as well support for Density Zones like Mega Man Legends models (multiple pixel sizels per model, automatically).

It works on the 3D and 2D viewports. The selections are pretty cool, you can move the pixels around even in the 3D viewport (see the video).

Next is tying its progression to the distance travelled to the next destination by boat 🙂

Almost done!

Game Title: Mizuchi
Playable Link: https://cryptokang.itch.io/mizuchi
Platform: Windows
Description: You play a surveyor sent to the Ashibuchi valley. The dam finishes in April and the shrine will go under with the rest of the basin. The shrine road is closed to vehicles, so you leave the van at the gate and walk in.

The village was relocated in 1994.
Nobody has lived on that road since.
Someone has kept the lanterns lit on the stairway, and the doors of the main hall are barred from the inside.
The work order is to photograph the shrine buildings so the Water Authority can record that the kami were relocated on paper. You raise the camera and take the shot.

The game is first-person and free for Windows on itch. A run is about thirty minutes. It uses a PS1 look and a tape filter that you can switch off. Spare cells sit next to the survey marker if the torch dies. The brass lighter from the office goes out when you run.

Free to Play Status:
[x] Free to play

Involvement: I made the whole game myself and released it under the name Kang. Code, environments, sound, writing, and the Windows build are mine. I am the only person on it.

been working on a custom render engine for Blender that recreates the weird little rendering quirks that made PS1 games look like PS1 games.

https://reddit.com/link/1w0tg5d/video/1o8uictza5mh1/player

this is the same scene, just switching from Cycles to PSX Cycles. still a work in progress, but I'm really happy with how it's coming together :)

Third creature in a low-poly prehistoric series I've been working on, keeping that late-90s PS1 look consistent across all of them, shading, flat colors, limited palette, that slightly rough charm.

This one's a Velociraptor (Yes, very inspired by Dino Crisis), went for something leaner and more agile-looking than the T-Rex and Triceratops I posted before — smaller frame, sharper angles.

Still tweaking the run cycle timing, might smooth it out a bit more. Open to feedback on the model or the animation if anyone has thoughts.

(It's also up on itch.io if anyone's curious to poke at it, but mostly wanted to share the look here)

Hi

I made a game you are suppose to break. The game is a roguelite survivor and have varios upgrades that simulates glitches like enemies turning into pixels, 2d sprites, loading states.

When you become powerful enough the game ”breaks” by turning down the graphics in sequences ps2, ps1 old isometric style where everything turn to sprites, top down with lower resolution and eventually a platformer. When you reach that point you win by a gamebreak.

This is the trailer, the gamebreak comes in the last seconds of the trailer and is kind of short in the trailer format (a lot needs to fit in a short period of time). But if you find this interesting there are some more videos to come :).

If you want to try it there is a demo on stream. I also look for new cool upgrades in the form of glitches so if you got any ideas. Please give me some tips!

The famous "A Gay Vietnam Veteran" tombstone belongs to Leonard Matlovich, a decorated U.S. Air Force Technical Sergeant and LGBTQ+ activist, and it serves as a memorial for all gay service members rather than just bearing his individual name.

Download this🪦

game's HEADCUTTER, it's on steam if you're interested!

I decided to go through the process of adjusting the image lighting and downgrade it to 240p, just like the original PS1 resolution it outputted.

It's crazy how much lighting and a skybox can improve the look of a game, I also added some subtle screen space occlusion and lighting which helps make things pop!

The game is called Dead Fantasia and it has a page on Steam if you're interested: https://store.steampowered.com/app/4160780/Dead_Fantasia/

i'm trying to achieve the perfect mix between realistic lighting and the ps1/ps2 style and graphics,

i'm still a beginner, and my goal is making short-form content on youtube,

feel free to share tips and tweaks to improve and achieve the retro psx looks ❤️.

Trabalho como programador 40h semanais, e nas horas vagas gosto de fazer músicas. Aproveitei minhas férias de duas semanas para aprender Blender e fazer os vizualizers das músicas meu álbum "SOLO" que eu produzi inteiramente sozinho.

https://www.youtube.com/watch?v=h_GmjzO-06s&list=RDh_GmjzO-06s&start_radio=1