Kovarust is my attempt at a free Minecraft clone. I'm aiming for it to be a viable replacement for Java Edition eventually. It's written in Rust, and will hopefully be faster and more versatile than the original Minecraft, with as many features actually implemented as plugins as I could manage.

I've redesigned every aspect of this thing about 5 times before it's even compiling, so it'll taking me a while to get it right, but it is progressing.

WIP, but playable

Bounce-a-Meteor is a simple survival game where you need to protect Earth from meteors using giant trampolines mounted on either side of the planet. You need to strategize (or at least try, in the chaos) and smash together meteors, combining them and making them definitely easier to manage with absolutely no downsides whatsoever.

BaM was my first ever (and probably last) game I uploaded to Google Gay Store when I was about 16, and man was that a painful process.
As Unity was all I knew about game dev at the time, that's what I made it in - the game was buggy and weird and the "animations" were a hack-job, but it brought in 5¢ of ad revenue all-time, so it wasn't a complete waste of effort...

Anyway, because Google is Google, the game got taken down for not having a stoopid "pRivAcY PoLIcY" because GOOGLE'S OWN AD PLUGIN collected user data, and then a year later after I fixed that, it just disappeared again for no reason whatsoever.

I eventually decided to ditch both Google and Unity and start remaking BaM on a more usable platform. I was really getting into Processing at the time, and what I came up was a fun game, but APDE's simplistic nature limited my app to a proof-of-concept.
Of course, the next step would be to (again) rewrite on a more usable platform. And, what better platform than barebones Rust, with all its extensive Android support and mature gaming ecosystem? /s

It was definitely a challenge working out the toolchains, but I managed to get an APK compiling, and even a WASM web app. Since BaM is still WIP, I'm only hosting the Android & web version at the moment, but the plan is to put it on F-Droid and collect some spare change from itch.io, sooner rather than later.

Tetris

Back in the good 'ol days before I started learning Rust (and subsequently rendered my PinePhone useless by desoldering its SIM card reader using rustc), I just felt like playing Tetris.

So, in between pretending I was learning how to do loops in java for uni, I ended up making this in a day in C. It's under 400 lines long, so it could be used to dissect and learn programming in C, I guess.
Not that it's especially good code, but still.

Random scripts

A collection of utilities I wrote in zsh for one reason or another.
Note you'll probably have to chmod +x to run these. Also I haven't tested them in bash becuase it's gay and you should be using zsh.

bytecalc is a byte unit converter, that is, working in multiples of 1024.
(fend is good for this and a lot more)

list is a (janky) list iterator - basically, loop over each line in a list and run a command on it. If the command works, remove the line, otherwise keep it to maybe retry later. I use it for mass curling memes and ignoring the URLs with duplicate filenames until after I categorize the previous batch.
NO MEME LEFT BEHIND

dewit is like a user-level version of runit (i.e. a user-service manager) that you can put in your crontab. I use it to run my website.

sc's just my screenshot command, using crud to select a window/area and shotgun to actually get the picture. Then it either copies it to the clipboard or saves it to a file, if one is specified.
I had shotgun & crud listed the wrong way for the longest time. -_-
omfg, a month later I realize I only had crud and crud listed

arg-kit

arg-kit is a featherweight library that helps parse arguments using one of Rust's most versatile and powerful syntaxes: match {}

Do you really need bloated proc macros when collecting arguments can be simplified to a .next()? You have zero indication of what's going on under the hood, so you can't implement your own behaviour.

That is why I don't call it an "argument parser" on its own. Your program parses the arguments, this just helps iterate over it, like so:

let mut argv = std::env::args();
for_args!(argv; {
    arg!(-h | --help) => eprintln!("{HELP_TEXT}"),
    arg!(-v | --value) => do_something(argv.next()?),
    unknown => panic!("Unknown argument {unknown}"),
});

...which expands to:

let mut argv = std::env::args();
while let Some(args) = argv.next() {
    for arg in args.as_arg() {
        match arg {
            Argument::Short("h") |
            Argument::Long("help") =>
                eprintln!("{HELP_TEXT}"),
            Argument::Short("v") |
            Argument::Long("value") =>
                do_something(argv.next()?),
            unknown => panic!("Unknown argument {unknown}"),
        }
    }
}