nether VS love

As for what I'm working on, it's nothing special at the moment, but you can see it here.

I've published the benchmark code just in case someone would like to take a look. Its code is a hammered version of the original code, so you are likely to find things that don't make a lot of sense in the benchmark version, like my use of atomics which are there to allow multiple iterators to coexist and work in parallel.

I've been rewriting both the math and rasterization code that I'm using in this project for quite some time, because the original (published) code is very naive and slow, consuming 9% of CPU time of the 4 Raspberry Pi cores at 1800MHz to display a single perspective-correct triangle on the screen at 60fps. The problem is that, while rewriting the code, I noticed that my new version will not work with my work-stealing async executor because I require tasks to have the Send trait, and just like in the original code, I'm sharing a mutable frame buffer between all the tasks which is accessed through a mutable pointer, a problem which I accidentally worked around by implementing the Send and Sync traits for the video driver's type which wraps the pointer, potentially hiding undefined behavior in the process.

I'm working on a bare metal project for the Raspberry Pi 4 that is not exactly an operating system but has a lot in common with a traditional kernel. At the moment this project is nothing more than a graphics library stub and is already pretty slow, so following advice that I got on the Raspberry Pi forums I benchmarked it and was negatively impressed by the numbers, especially the fill rate numbers, where I didn't expect any problems since that's just writing to a small tile in memory and at least in theory I should be hitting the L1 cache all the time.

I'm trying to build a bare metal game completely from scratch and without third-party crates on a Raspberry Pi, which although not a perfect platform because many things aren't properly documented, is good enough for me since at least when the documentation falters there's always the officially supported Linux kernel to source information from. If I was starting today I'd just be building a kernel though, because I'm not sure I'll be able to complete this project for performance reasons, but I'm still enjoying the challenge of squeezing out as much performance as I can out of the Pi.

I'm actually trying to make a bare metal game for the Pi 4 from scratch without acceleration. I'm not sure I'm going to succeed considering that ARMv8A doesn't have vectorized floating point or even commodities like non-vectorized floating point modulo or trigonometric functions, but on the other hand people made full 3D games with no acceleration targeting 100MHz Pentium machines, so if I fail that's going to be because I'm not good enough for this. So far I'm successfully rendering at 60fps at the official touchscreen's standard resolution, but that's just a single perspective correct untextured triangle without any lighting applied to it.

Feeling quite accomplished at the moment, since I've just finished pushing to GitHub an initial implementation of a 3D graphics renderer as part of a very ambitious personal project despite my total blindness, when half a decade ago I never even thought I was capable of coding blind.

A public version of this project is available on GitHub, though that's missing the math library, graphics renderer, and scene tree that I've been working on for the last month, a huge commit that will essentially double the number of lines of code of the project as it lays the foundation for building the game engine.

I'm building a very ambitious and equally useless project because I have nothing else to do. My project is a mix of a kind of operating system kernel, game engine, and ultimately a game itself targeting a bare metal Raspberry Pi 4. The kernel part is pretty much done, with only an audio driver missing, so now I'm working on a huge milestone which will be adding some gesture recognizers (already implemented in my local repository), building a simple 3D software renderer (working on it now), implementing a basic 3D scene tree (to be done), and laying the foundation for an Entity Component System architecture (also to be done). Since part of the reason why I'm doing this is learning, I'm implementing everything from scratch in Rust and assembly without any third-party code, so please do not suggest using libraries.

I've built a few games with my son over the years. The fun part for us was all about fast iteration, and then laughing at the bugs together.

There are some other recommendations here for how to approach 3d, and he is specifically asking for 3d -- but I want to put in one more pitch for 2d: the fun-to-tedium ratio can be much higher.

I wonder if you could spend some time prototyping some of his ideas in LÖVE https://love2d.org/ -- if you show him the smallest sketch of something working, he might have an idea about what to add next.

Many years ago, on a flight, we went from 0 to game before we landed (with no experience).

* When a cell is born it randomly takes on the color of one of its (3) parents.

To try it out:

1. Install LÖVE for your device from https://love2d.org (~5MB and open source). (iOS requires building from source on a Mac, or installing the third-party Love2D Studio: https://love2d-studio.marknoteapp.com)

2. Install my Lua Carousel from https://akkartik.itch.io/carousel (~100KB). It includes all its source code and can be edited live on a computer as it runs.

3. Copy the ~100 lines of code from the bottom of https://akkartik.itch.io/carousel/devlog/651711/new-version-after-9-days and paste them into Lua Carousel.

Probably the most important piece of software we'll be playing around with is a game engine called LÖVE. Lua is well known around developer circles as being a good scripting language when it comes to making games, and this engine is one of the more popular. I'll be going through installation at the end of this post.

I got it – these are the steps I took:

1. Download Love from https://love2d.org/

libGDX is great, but I can understand if it's not for some people. This also applies to love2d, raylib and Monogame

You don't need to use git if you don't want to. Try downloading the 0.10.2 source directly here (the file you want is love-0.10.2-linux-src.tar.gz); I see you've tried this already but try again just to see what happens. Extract it to a directory (e.g. love-0.10.2-linux-src) and then run:

Love2d (MIT/C++/Lua) https://github.com/love2d/love

- Löve (doesn't have a separate page, but showcases a few games at the bottom of the page): https://love2d.org

The game, Wasp Escape, was built using the open-source Löve 2D game library for Lua.

love2d (lua) is a productive, fun, good docs, and most importantly proven / field-tested 2d game library, with easy to learn fast to compile and fast to run language - lua. while lua might not have a lot of features as python, the big bonus is that its much more focused language, which is important because otherwise you can get easily distracted on bells and whistles that other programming languages provide, i know that from experience