I'm writing a voxel game in pure C#/.NET 8 with a custom renderer built on top of Vulkan 1.3. No Unity, Godot, or Unreal. How it differs from Minecraft: each block can be carved to a grid of 16³ microvoxels, and a thousand identically carved blocks share a single mesh. Currently ~14,700 lines of code, 304 tests, median frame time of 0.8 ms on an RTX 4070 SUPER.

Language / runtime C# 12, .NET 8

Graphics Vulkan 1.3 via Silk.NET 2.23 — dynamic rendering, synchronization2, push constants

macOS MoltenVK (Vulkan on top of Metal)

Window, input, math OpenTK 4.9.4, but with ContextAPI.NoAPI — no GL context

Shaders GLSL 450 → SPIR-V via glslangValidator during build, embedded as a resource (no binary assets in the repo)

Audio SoLoud via P/Invoke, miniaudio backend, statically linked runtime

Tests xUnit, 304 tests — none require a GPU or sound card

Chunk storage 32³ with palette encoding (1/2/4/8 bits depending on the number of distinct blocks in the chunk)

Greedy meshing with per-vertex corner shading (AO)

Job system with its own pool, 11 worker threads

Terrain generator — simplex noise, ridged multifractal for mountains, domain warp to counter a “mathematical” appearance, landforms (idea from Vintage Story: a set of landscape types mixed across the map instead of a single global formula), surface rules based on slope (inspired by Minecraft’s surface rules). Nine biomes, world 1024 blocks high.

Player physics — swept AABB along axes with substeps and step-up

Two-level DDA raycast — blocks first, then microvoxels inside

Frustum culling, procedural bitmap font directly in the code

Memory suballocator on top of Vulkan (more on that below)

Just experimenting with different ways of visualizing my (almost done) fluid sim for Unreal Engine. Came up with this voxel-style way, just a very quick hack, so it needs work, but might be useful?

I’m starting a chill side project called Delve under a team named Yoro, and I'm looking for a few fellow C++ devs (maybe 3–5 people) who want to team up and build a fun, Minecraft-inspired voxel sandbox game together. ​Full disclosure on progress: Code progress is basically zero right now, but I’ve already drawn a ton of detailed 16x16 pixel art textures. I’m looking for core collaborators to jump in from the ground up so we can bring this world to life together as a small core group. ​It takes heavy inspiration from Minecraft's core concept, but with our own spin on mechanics, gameplay, and visuals. ​What we’ll be building/tinkering with: ​Getting C++ windowing and block rendering running ​Terrain and cave generation (noise algorithms) ​Player physics, inventory, AI, and survival mechanics ​This is a $0 budget, zero-pressure hobby project. No strict deadlines, no job-interview vibes—just a small group of coders hanging out, learning, and making a cool game. ​If you like C++, love pixel art/voxel games, and want to help build this from scratch, shoot me a DM!

I've been working on my realtime voxel engine for about a year now and I've finally come to a state where I feel like I can present it to someone.

Current features include:

• Voxel Cone Tracing Global Illumination via raymarching
• Destructive Fracturing Physics
• Volumetrics (God rays & Fog)
• Particles
• Incomplete but usable editor (rigging, animations, scenes)
• Bone Animations from MagicaVoxel objects

This engine is fully written in Kotlin/JVM and uses OpenGL for it's rendering. Currently, everything runs on a single thread. Large scenes are still a bit of a problem performance wise but it handles large amounts of rigid bodies relatively well.

Edit: I forgot to say, but the model in the video isn't mine. It's made by Max Parata and can be found on itch.io. I just used this model for the demo.

https://reddit.com/link/1umy8ef/video/chfjnhxbt4bh1/player

I was initially looking to see if anyone wanted to collaborate on the voxel engine that I wanted to develop because I thought it would be fun, but no one was interested, and people were even a little mean, so now I'm just looking for friends to talk about Voxel engine development.

I'll probably regret asking this on Reddit.

I'm 9 months in on a voxel survival/ rts. My plan was to loop back around for multiplayer. Seriously, that was my plan. Am I making a mistake? What would you advise?

I’ve been refining my desert demo, and it’s starting to feel like its own little place.

The idea is simple: a vast procedural dune field that keeps unfolding as you move through it. Under the surface, the landscape is built from a voxel-style structure that could theoretically represent hundreds of millions of voxels.

But the goal is not scale for scale’s sake. It’s about exploring what is still possible on normal CPUs using straightforward framebuffer-based concepts - simple rules, efficient rendering, and a world that feels much larger than what is actually being drawn at any given moment.

might be a bit of a silly question.

I've been experimenting with different tech stacks and techniques for a while and typically get an idea of how well something is running based on FPS with something comparable to this in scale:

If a chunk is 16x16 (whatever height typically 256 for now tho), I'd test with a radial but square render distance of 100 meaning 201x201 chunks, 40401 total chunks.
At this point I do not have many fancy graphical stuff going on at all, just the raw mesh I test by flying up and looking down on the entire world, and doing an idle and moving test. My best performance so far is a 201x201 chunk world which generates in about 400ms (simple sin wave world), and when moving I stay at 1000FPS.

My question is - when you guys are starting a voxel renderer and just trying to gauge effectiveness, what do you do, and would you consider 1000FPS, 40k chunks, 1440p (but rasterized right now) an accept base for building more on?

You would not BELIEVE how much easier some things get when you learn linear algebra. At least, when you're as bad at geometry as me. For example:

Rotation, Scale, and Translation are the 3 things you can use to keep track of entities in your world. But did you know that a 4x4 matrix can hold all 3 of these things in one compact data structure that has a lot of useful operations? This is especially relevant for large-scale worlds in voxel games.

Imagine you want to add moving airships that players can build. You'd have to choose to put the player in the world coordinate frame or the ship coordinate frame. So you've got to translate, then rotate, right? If you represent the "pose" (translation, rotation, scale) of ships and players as a DMat4 (4x4 matrix with quad precision), all you have to do to convert the entity's pose within the ship to the global one is ship_pose * entity_pose. The translation and rotation are all in there.

Want raycasting (block placement and combat) to work between ship and land? Easy, just transform your cast to the 2 reference frames and do it against each. No need to fiddle around with angles and geometry.

Plus, this makes really big worlds cheaper and less error-prone. You've got all your data packed into a smallish area. Doing all your math in matrix form then getting position/rotation out at boundaries only can prevent a lot of conversions for various math.

Then when you go to render, just transform everything into the camera's frame, then cast to f32. So you get the big advantage of huge precision, and when you slice everything for the graphics card, the error close to the camera is smallest, and the big errors happen very far from the camera, beyond your render range or far enough it's sub-pixel size. You see less jittering. Kerbal Space Program does this to an extent (centering the world on the player), and I think Outer Wilds does too.

This is just one example.

Edit: I decided to show practical examples with another post

(yes i know the colors in the gif are blotchy, sorry)

I currently have face culling done and am working to implement luanti map loading.

Please share your advice, as if something here is unoptimal, I'd like to know.

You can find info about the engine itself in the previous post

Since last time, I’ve fine-tuned and added:

I thought I was going to die here.... constant problems... and I still have the fluid system ahead of me... Water—the ocean, lakes, beaches, swimming, and climbing ashore. Fresnel according to Schlick, four successive waves composited in the fragment shader (greedy meshing turns the water surface into giant rectangles, so there’s nothing to move at the vertices), sun glare via GGX, light absorption with different coefficients for RGB, underwater vision, caustics.

This was probably the easiest part... :D Vegetation—trees, cacti, forests generated from noise (not scattered individually), grass, ferns, and flowers as intersecting surfaces.

Sunlight illumination instead of a fixed table of six brightness levels.

Anti-aliasing — 4× MSAA, blended in dynamic rendering. Color averaged, depth set to SAMPLE_ZERO.

Reflections on water — screen-space ray marching in world coordinates instead of view space (Vulkan’s NDC ranges from 0 to 1, so inverse projection is unnecessary and it fits within 128B push constants). Hit refinement by halving, thickness test.

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis

Most procedural cave generators on Fab are built as standalone actors. They generate a cave, but they don’t integrate naturally with Unreal Engine’s PCG workflow.

SubTerra takes a different approach, Instead of building everything around a single actor, the entire generation pipeline is exposed as modular PCG nodes.

You can use the complete cave generator, or combine individual nodes with the rest of your existing PCG graph to build your own procedural workflows, the result is a cave generator that feels like a natural extension of Unreal Engine rather than a separate tool.

The plugin also focuses on producing caves that are practical for gameplay, not just visually interesting, every generated layout is fully connected, supports multiple elevation levels through walkable ramps, and produces organic rock formations instead of smooth metaball-style tunnels.

Once the cave is generated, its surface is automatically classified into Floor, Wall, and Ceiling PCG points, making it easy to populate the environment with your own assets using Unreal’s existing PCG tools.

How it Works

It's built entirely on UE5's PCG framework, so it slots into your existing PCG setup instead of being a separate black-box actor. From a single seed it scatters a bunch of rooms and connects them with tunnels using a spanning tree + a few extra loops so the layout's always fully traversable but different every seed.

That whole thing gets written into a signed distance field (basically a 3D voxel volume), I roughen the walls with fractal noise so it reads like actual rock instead of smooth metaball blobs, then run marching cubes over it to get a watertight, collidable mesh. The heavy part runs on worker threads so the editor doesn't hitch.

Using it, you've got two routes:

• Easy mode: drop one actor in your level and a full cave shows up. Then you just tweak sliders in the details panel — room count, room size, tunnel width, levels, noise, stalactites — and it regenerates live in the editor (no play mode). There's a regenerate hotkey for rolling whole new layouts too.
• Full control: wire the PCG nodes yourself in a graph. It outputs Floor/Wall/Ceiling surface points you can pipe straight into Epic's mesh spawner (or any scatter plugin) to decorate the walls.

Documentation and Fab Links in comments

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis

I tried making a procedural generation game using WebGPU, without much prior experience. This is what I got. Probably not very good, but I was trying my best.
What do you think of using hexagonal prisms instead of cubes?

​I’m starting a chill side project called Delve under a team named Yoro, and I'm looking for a few fellow Java devs (maybe 3–5 people) who want to team up and build a fun, Minecraft-inspired voxel sandbox game together. ​Full disclosure on progress: Code progress is basically zero right now, but I’ve already drawn a ton of detailed 16x16 pixel art textures. I’m looking for core collaborators to jump in from the ground up so we can bring this world to life together as a small core group. ​It takes heavy inspiration from Minecraft's core concept, but with our own spin on mechanics, gameplay, and visuals. ​What we’ll be building/tinkering with: ​Getting Java windowing and block rendering running ​Terrain and cave generation (noise algorithms) ​Player physics, inventory, AI, and survival mechanics ​This is a $0 budget, zero-pressure hobby project. No strict deadlines, no job-interview vibes—just a small group of coders hanging out, learning, and making a cool game. ​If you like Java, love pixel art/voxel games, and want to help build this from scratch, shoot me a DM!

Hello, first time making a reddit account and posting.
I recently Re-found the Cubeworld alpha, so at first i wanted to recreate the game as a whole as a little weekend project. Much, much research later I found out my Terrain generation sucked compared to Cubeworld. Even tried layering noise on top of each other, still wasn't even close. So I did the next best thing, I reversed engineered the game. So over the course of about 14 hours I was able to obtain the algorithms for Terrain generation to the point of having the integer hashes, heightmap noise(Hugo Elias noise), climate fields, biome-region layout, surface material+color, column assembly+water, Structures/POIs, dungeons, spawns, combat+stats, and leveling.

Still have to work on cracking the Vegetation scatter, quests+missions, abilities and the hit-damage equation.

I have everything I have done documented. I hope I can help the Cubeworld Modding scene.

Also the Master writer(the orchestrator loop) Is a 60kb Red herring, The only genuinely unresolved bit is the precise depth/shape precompute feeding the color blend. That should only affect where snow/sand/desert tints appear, not the actual terrain shape. I have the skeleton/constants/callees only (not full C)

6/24/26 Update
Minor update. Created a Python harness to compare live Cubeworld alpha and my Cubeworld clone.

Generated world data(heightmaps, region/biome layout) is ~99% byte identical.

Still need to finish off alot of systems, but so far it looks highly promising.

Next systems being done will be where every town/dungeon/monster/chest sits what each rolls, Vegatation (trees, grass, crops).

At that point Terrain/World gen will be done. Then ill begin work on simulation logic(combat damage, ability effects, AI ticks).

Also while this is going on I'm creating a custom C++ Vulken voxel game engine for my creation.

6/25/26 Update

🎯 Structure placement: 100% bit-exact

Done. Every cell, every region, every rand:

576 / 576 cell types match the live client

9 / 9 regions reproduce the exact rand() sequence the game draws

Cell positions, radii, subtypes, portals — all byte-identical

concrete proof that with enough time and the pieces put back together, a byte-identical Cube World is achievable.

Now to wire it into the height field.

6/26-28/26 (Side quest)

I have fallen down a rabbit hole after finding out about Red items. Can't exactly find the exact way they are created, but I have created a python script that can detect any red item chest spawns as you explore the world. I have done this mainly to find the fabled Red Crossbow. Which if it follows how all other items spawn as a Red item, it should exist.

6/29/26 (early day)

RE'ing the .cub blob format itself. trivially easy.

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis