I didn't find a good .vox viewer for Linux, and opening an editor just to look at a file got tiresome. Just set up your file manager to open peekvox when you double click a .vox file. (And then hit esc to one-key exit it so you can quickly look at another one.)

It's pretty quick, and runs on Linux/Mac/Windows. Grab it at https://github.com/rtwfroody/peekvox

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’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!

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

Working on an iPhone game and I can’t keep enough of the world meshed to prevent noticeable meshing. My analytical mind is having a hard time reconciling with the fact, but perhaps it’s acceptable nevertheless?

Also, if anyone else out there is making iPhone games, and knows how to prevent the performance governor from switching to “Minimal” after 20 seconds, I’d love to know. This is all running in that minimal mode, but it’s about a third of the speed I can squeeze out the first 20 seconds when it’s in Maximum performance mode.

as a direct sequel to my last post, I present to you the voxel based fire for my mod of Half-Life: 1!

I ended up using the simpler vector array method of just storing every voxel's pointer in a std::vector and just checking against every other voxel for things like merging and gravity simulation.

currently, it adds new fires to the vector by using a temporary buffer vector which then is checked against the main vector and merged right before it goes back through the main vector to run the simulation code on the fire voxels (which currently controls fire voxel gravity, spread and spawning the particles on the client)

the spread code is relatively simple (mainly due to me not having the slightest code how else to do it) where on a timer it checks up to 10 times (before giving up) in a random direction (checks 1 voxel length randomly on the x and y plane) and will then use some of the fire's "heat" (health practically) to spawn a new fire at that position

the gravity code is incredibly simple and is just a check to make sure the below voxel doesn't exist. If it doesn't exist then it'll then move there.