Prestosilver

Read more

Bugz Bows and Curses is a procedurally generated rougelike revolving around completing Collections. You play as an Ant-ipede with a bow, as you go through levels you gain buffs and get stronger, but the stronger you are, the more likely the AI is to run.

Procedurally generated maps:
Never see the same map twice,

Believable Ai with a fight or flight reflex:
AI that seems to think and react with reasonable actions. as these maps are generated In a fraction of a second every time you play.

2025 07/19

Read more

The G-Mod of Idle games, this allows for easy modding, in python and JSON. Never worry about finishing your current idle game, because this one never ends!

Procedural Generation
The game is formatted as a list of modules, all in a stack, These modules all interact with the ones above. Once you make 10000 currency, you can buy another module. This module will be randomly picked, yet with a seed, you can play the same sequence every time.

Never Ending
Incremental games have always had an end, whether it is because the effort to go on is impossible to put forth, or because the end is predefined, but not with this one. Every module in the base game is designed to allow you to play the game indefinitely.

High Replayability
Play the game with whatever combinations of mods you want. Mods can range from boosts to generators, to Plus-Mode where you can choose the next module.

Easy To Learn Modding System With A Growing API
Don't think there are enough modules in the game, just make another. With a python plugin system and a built-in mod maker, you can do anything you want. It doesn't end there, the majority of what future updates will contribute to the API of the game, making it easier to do what you would like.

2024 07/19

Read more

Click to Lose Minus was a full remake of my first game, It was designed to be less grind.

No, this is not a sequel, it's mostly a rewrite to allow me to add more features in the future. There are notably some changes to help remove the grind that people noticed in the original version. There will also cross-platform releases.

2022 08/23

Read more

Chesker is a chess engine, with pieces from other board games. I plan to expand the game to include more games.
The culmination of as many board games as I could fit into 1 game as possible.
Chesker seemed like a good first project for the new game engine I have been working hangover

- Chess
- Checkers

- P2P multiplayer
- an AI that can play with any custom piece you add
- fully customizable boards and pieces
- more on the way!

2022 08/23

Read more

(This game has a lot of flashing lights, so do not play if you are affected by this)

Have you ever played an incremental game and thought "the numbers are too big", well look no further.

2021 05/21

Read more

I made A container based wayland compositor in zig that uses lua interop for config.

2025 07/18

Read more

I recently had a friend ask me to get some cloud rendering for a now debunked project of theirs. I took it way to far and this is the result.

My first prototype for this was made in unity, I just drew up a small gradient circle and billboarded ~700 sprites. This turned out to be way to slow so I moved to rust because I wanted to learn rust.

I decided to start with rust by writing a simple library to render stuff. Learn opengl Rust Helped with the basics alot. Once I had that done, I just had to convert the unity billboarding to a geom shader. That got me to this point.

I messed with shaders for a while and got a jpeg filter working!

2023 12/09

Read more

A remake of my programming language... again.

// semicolons make more sense

// changed ~ operator to be !
def a: !(5 == 0);

// added the force keyword
// void type is now capitalized for consistancy
force def main: fn[] -> Void;

// replace extfn with extern fn
extern fn printf: fn[] -> Void;

// function parameters are cleaner
def cls: class {
def a: fn[self: *Self] -> Void;
};

// unary ops dont need parenthesis
def b: !!(5 == 0);
- It problaby wouldve been cleaner to use operator overides for Values.
- I couldve combined the Node and Value enums.
- Problaby shouldnt force casting, type infrencing bamba4?
- Comptime & emit expressions have weird syntax sometimes

2023 12/09

Read more

Another programming language.

def printf: extern -> i32;

def main: proc -> i32 {
printf("Hello World!");

return 0;
};
def fib: proc idx -> i32 {
if (idx < 2) {
return idx;
};

return fib(idx - 1) + fib(idx - 2);
};

2023 09/01

Read more

I recently remade budwm for Wayland in Zig.

- Budland is way faster.
- Budland supports any Wayland bar.
- Budland supports a config file.

2023 09/01

Read more

Markup is a PDF document compiler written completely in Nim.

$ nimble install http://github.com/bob16795/markup_nim

$ markup [options] [file1 file2 ...]

Markup has all the basic syntax as Markdown see githubs markdown docs for a reference.

Markup has a document property system that allows you to define a variable and reference it later, an example of a document property section is as follows:
---
Title: This is a document
---
# Title is ()Title() % () is used to refer to

sample text
Markup plugins can be used to define tags in a less confusing way than using doc props. You can define a macro that will be ran when you create a tag with the same name.
body := [propSec | textSec]+
textSec := [textComment |
textList |
codeBlock |
equ |
tag |
textHeading |
textTable |
textLine]+ textParEnd
heading2 := `##` [`(` | `|` | `)` | `{` | `}` | `_` | `+` |
`:` | `;` | `<` | `>` | `!` | text | num |
`-` | `*` | `$` ]+ `\n`
textParEnd := `\n`+
textList := [listLevel3 |
listLevel2 |
listLevel1]+
listLevel3 := `\t\t- ` [`(` | `|` | `)` | `{` | `}` | `_` | `+` |
`:` | `;` | `<` | `>` | `!` | text | num |
`-` | `*` | `$` ]+ `\n`
listLevel2 := `\t- ` [`(` | `|` | `)` | `{` | `}` | `_` | `+` |
`:` | `;` | `<` | `>` | `!` | text | num |
`-` | `*` | `$` ]+ `\n`
listLevel1 := `- ` [`(` | `|` | `)` | `{` | `}` | `_` | `+` |
`:` | `;` | `<` | `>` | `!` | text | num |
`-` | `*` | `$` ]+ `\n`
equ := `$$` [`_` | `*` | `{` | `}` | `!` | `-` | `+` |
`;` | `<` | `>` | `(` | `)` | `=` | text |
num]+ `$$\n`
tag := `<` text [`:` text]? `>\n`
textHeading := [heading3 |
heading2 |
heading1 ]+
heading3 := `###` [`(` | `|` | `)` | `{` | `}` | `_` | `+` |
`:` | `;` | `<` | `>` | `!` | text | num |
`-` | `*` | `$` ]+ `\n`
heading2 := `##` [`(` | `|` | `)` | `{` | `}` | `_` | `+` |
`:` | `;` | `<` | `>` | `!` | text | num |
`-` | `*` | `$` ]+ `\n`
heading1 := `#` [`(` | `|` | `)` | `{` | `}` | `_` | `+` |
`:` | `;` | `<` | `>` | `!` | text | num |
`-` | `*` | `$` ]+ `\n`
comment := `!` .* [`\n` | EOF]
textLine := [bold |
emph |
text ]+ `\n`
propSec := propDiv propLine+ propDiv `\n`*
propDiv := `---\n`
propLine := [`!`? text `|`]? text `:` text `\n`
textTable := tableHeader [tableRow]+
tableHeader := tableRow tableSplit
tableRow := `|` [text `|`]+
tableSplit := `|` [`-`+ `|`]+
emphText := [`_` text `_`] | [`*` text `*`]
boldText := [`__` text `__`] | [`**` text `**`]
codeBlock := `\`\`\`` text? `\n` [text | `\n`] `\`\`\``

2023 09/01

Read more

A remake of my programming language, bamba.

def printf: extfn -> void;

fdef main: proc -> i32 {
printf("Hello World!");

return i32(0);
}
def fib: proc idx[i32] -> i32 {
if (idx < 2) {
return idx;
}

return fib(idx - 1) + fib(idx - 2);
}
def mainBuilderBuilder: proc T -> class {
return class {
def buildMain: proc value[T] -> (fn -> T) {
return fn -> T {
return value;
}
}
}
}

fdef main: mainBuilderBuilder(i32).buildMain(0);

- fdef and extfn are dumb keywords, problaby should split them into modifiers.
- Its obnoxious to use ~(*value) to invert a dereferenced value.

2023 08/07

Read more

Budwm is a DWM mod that focuses on containers.

$ git clone http://github.com/bob16795/budwm
$ cd budwm
$ make install

2022 08/23

Read more

Gin (Game engine In Nim) is a game engine written in Nim, but the more I look back at it, the more I realize it was just a graphics & sound library. Yes it managed the game loop but it didn't manage anything else, resulting in the user essentially writing a whole engine on top of gin.

$ nimble install http://github.com/bob16795/gin
Gin introduces a template, called "Game" which can be used as a game loop.

import gin
import gin/graphics

Game:
var
background: Color # the background color

template Initialize() =
# get the game ready to load
setWindowName("Minimal gin game") # set the window title
setAppName("Minimal") # set the save folder name
setWindowSize(Point(X: 1024, Y: 600)) # set the window size
setDt(16) # set the frame rate to 60 fps
background = initColor(255, 255, 255) #ffffff

template drawLoading(pc: float, status: string): untyped =
# renders the loading screen
clearBuffer(background) # clear the screen

template Setup(): untyped =
# load resources
discard

template Update(dt: cuint) =
# main update function in loop
discard

template Draw(dt: cuint, ctx: GraphicsContext) =
# render the next frame
clearBuffer(background) # clear the screen

template Close() =
# ran when the game is closed
discard

2022 08/23

Read more

Hangover is a game engine based on gin. The primary goals of hangover were:
- Hangover will use OpenGL for graphics.
- Hangover will have consistent naming.
- Hangover will have an UI system.

$ nimble install hangover

Like Gin, Hangover introduces a template, called "Game" which can be used as a game loop.

import hangover

Game:
var
bg: Color = newColor(0, 0, 0)

proc drawLoading(percent: float32, loadStatus: string, ctx: GraphicsContext) =
## renders the loading screen
## only updates when setPc or setStatus is called in Initialize
clearBuffer(ctx, bg)

proc Initialize(ctx: var GraphicsContext) =
## load content files
discard

proc Update(deltaTime: float)
## process a frame event
discard

proc Draw(ctx: var GraphicsContext) =
## draws a frame
clearBuffer(ctx, bg)

proc closeGame() =
## called when the game is closed
discard

2022 08/23

Read more

Nims garbage collector just gets really annoying to work with when it comes to things like hooking external functions, like I want lua code thats called in nim to be able to get the engine to make a texture, then populate it or whatever, then eventually unref the pointer once lua frees it, the issue is that freeing a texture is a c function, and might not occur with luas destructor, so I have to hook nims destructor, which according to the docs is possible, but then you try it and aparently only nonpointer objects can hook their destructor, so I have to read even more docs just to find out when the destructor is even called to make sure thats safe, literal nightmare but at this point im so deep in that I might as well leave it and just figure it out later.

I think this really contrasts alot more when looking at how easy it was to get zig to just work with lua in conpositor, I just had to make a comptime fuction that made lua wrappers for construction and destruction of lua associated types, and then it just worked, lua had its gc and zig gave it objects, when an object moved it was moved not borrowed.

2025 08/10

Read more

I liked this album alot and wanted to make a full writeup of my feelings about it.

Angel with a Longshot (Courier Overture) [ft. Jedwill]
9.5 - Good opening, really like the fusion dubstep rock feel, really prepares for the album. Wish it played more into the experimental side of the album tho.
EDIT: this track really really grew on me 8.5 -> 9.5

Ch 1: SVU-AS (Heartbreak Intro) [ft. Lenval Brown]
7.0 - Not sure if I need to rate the interludes bc they're not music, but its fine other than the fact that ill need to skip on cd.

My Love is a Quickscope (Original Mix)
8.5 - This is the only track where top 5 gets kinda annoying, really like the nod to my favorite song telephone tho. Introducing the yelling here really helps this track not be a mid 7.

Dual Headed Hydranoid [ft. Namii & SadisticTushi]
8.0 - Not the biggest fan of the rapping, and the chess guy samples felt weird, but it grooves, also really shows what the top 5 voice can do. (also advances the plot so that helps it alot)

Worst rave EVER
7.8 - That guitar thing is insane, was worried about this one bc of the ammount of dank samples but its actually amazing.
EDIT this song kinda blows after a while, dropped from 9.5 to 7.8

Falling in Love With a Corporate Illustration
9.2 - Love this one, great return to form for vylet, dosent take its self seriously, but still gets emotional and sentimental, and grooves hard would be higher if it was just a tad shorter.

Wonka X Howl
9.8 - Was not expecting something this poppy to be in this album, this will problaby be the one I listen to the most from this album. Its catchy and really good out of context.

Ch 2: XPR-50 (It's All About the Game) [ft. Lenval Brown]
5.0 - Another interlude, fine ig but man I dont want to hear top 5 talking shit about herself for 3 min

Webpunk [ft. NekoSnicker]
8.0 - Really the throwback track to early 2000s pop, its great and I didnt think that vocaloid would go so well with the autotuney style of mid 2000s tracks.

Peace, Love, Glalie (And, In 2009, Somebody Stole My Ancient Mew Card) [ft. Shelly the Android Lobster]
9.0 - Vylet miku???????? Grooves and love how the dissonance throughout it interacts with the story.

The Slow Dance
9.3 - One of vylets best acoustic guitar tracks, really surrounds you like pest, an amazing precursor to the climax of the album. Could pick up a bit faster tho to keep up with the pace of the album.

Comet Catcher and the Reek Fish
9.8 - Actually an insane great mental breakdown track, love the gituar and top 5 mental screming, but over all those chops of literal breathing with the idk the name of the style melody. Really no words describe how this makes me feel.

Lightning Bolt
9.9 - I thought Reek fish was my favorite track in the album, but like dubstep with the emotion put into this track is insane, really really good, like actually insane. It keeps up with the 2000s web nature of this album too with the way it does dubstep, feels like a cool play on youtube intro music.

Ch 3: Ballista (Dear Aria, I Love Myself) [ft. Lenval Brown]
5.0 - It was around here the interludes got old. Almost lenval browned my pants at this point in the album but then this played.

Walking Beside a Dragonfly [ft. Lunari Lotus]
9.9 - The first in this album to actually made me cry, vylets way of protraying life chaning realizations is so amazing. And in a track about how she fell in love with her wife it hits so insanely hard. O and the end is the usual noise overflow from this type of vylet track, really the cherry on top the best play on this thing she does.

Jester
9.5 - Top 5 is back, great track about loving yourself. also the reference to the motif in her valentines day tracks, and the music never stops sample, this is such a great track, also chops.

LiveLaughLove2 [ft. Moesnail]
8.7 - Really good buildup track for the climax, but the dubstep does grate a bit.

A Digital Flower Field
10 - Yea amazing, dont think theres really anything to say other that now my top track of all time. Actually had me crying, something about it just really hit. (yes my first 10)

Ch 4: DSR-50 (O' Laniakea, Quell Not The Love Which Overflows From Me) [ft. Lenval Brown]
7 - might still be high from Digital Flower Field but this was a more barable interlude.

Love & Ponystep (ft. Tracey Brakes)
9.5 - A bit long but man really good track, kinda just really good. also Tracey Brakes really collabs on Vylets best tracks quite a bit lmao.

Ghostie Dub (Here to Light this Up) [Bonus Track/Outro]
8.0 - Good wind down, could have a bit more on the melody side but serves itts purpose.

2025 07/19

Read more

Multi item sorters looked cheap as heck in 1.21 but now they're even cheaper with the copper golems lmao, still a tad annoying but cheaper
The design in my survival world that I don't use had like 150 hoppers but now that the redstone is smaller you can probably cut that pretty far
Even the current storage I use could be made faster bc I don't have to use the minecart anymore

2025 07/11

Read more

bungy cord grappling hook is problaby one of my favorite platform mechanics ive seen ngl

Later: This games controls took a really long time to get used to
I can see why it says keyboard mouse reccomended

Later: This game is crazy hard, so much to keep track of
I think it's just BC enemies do so much damage, and there are literally no healing upgrades and like a 3 HP heal that costs literally half of my mana bar feels like nothing

2025 07/10

Read more

Can I just say the thing on the 7th layer is crazy, giant octopus that hunts by cancelling your senses and on top of that has no issues moving in 3d space, and can even effect 6th sense, really cool concept for the peak of cursed evolution in an impossible environment it's supposed to represent

2025 07/09

Read more

I always find it funny when people act like a GC is really slow, it's actually only a notable performance hit if your using cyclic types or trying to mitigate fragmentation, because of the way objects are stored in gced mem most of the time deleting a variable is tipically just a subtraction, unless it's 0 then it deletes it's children
Really what is typically bad about a GC is that it can't run on a thread due to it being a memory thing hence its a pause the world structure which is what's actually bad
Even cycle checking is such a well studied process that it's not horribly expensive
And you could copy nim and bake cycle checking into destructors, completely skipping it for all acyclic types
Tldr garbage collectors are actually super fast, they are just not thread safe

2025 06/24

Read more

Now that I think about it there is a pretty decent reason it [zigs use of while for an iterator] is more idiomatic to use captures, if you unwrap with .? You can segfault which is uncatchable people avoid using it and just use a capture or the const x = x_optional orelse return error.Whatever it's just easier to not have to logic your way to .? being always safe and raise an error
.? and .* are really only seen alot in C reliant stuff (.* Is also used in init functions alot BC there's no dupe for a single item pointer)

2025 06/21

Read more

So ive been rewriting my wayland compositor finally, and I never really thought about it but the design behind wayland's LayerSurface stuff is a really smart way of dealing with what it does.
For the uninitated, there are 4 layers (4 mandatory ones in the spec, but you can make more for your own use)
- background
- decoration-back
- decoration-front
- foreground
and then the windows go in the middle of the decoration, decoration layers have to be reserved and surfaces open on them take up window space. So like a task bar goes in decoration front, your wallpaper goes in background, window borders in decoration front, shadows can be in decoration back.
Whats really nice about this is that it allows for a ton of cool features you'd want, and it just flat out is in the api so if your compositor supports these properly any program that has any feature that uses this is compatible with your compositor. Not only that but since layer surfaces are unaware of their position if you have 2 bars, they are positioned, and avoided by the compositor.
Honestly the whole of wayland is one of those specs that can tell the sheer magnatude of work put in the design. I mean just the wording of api is pretty heavily designed off of a video compositor which are quite well worked on. So alot of the terminology is pretty easy to pick up and the docs don't have any really wild terms that are specific to wayland.
Realized Im grouping waylandroots in with wayland in this rant so some features are actually wayland roots, but still applies
honestly this might just be that ive only used the x11 api for this type of thing, and there is no well used c api ive ever used thats aged worse than that

2025 06/19

Read more

I never really thought about it before but interfaces in zig can be kinda bad sometimes.
Because the way you make the naive interface most people make in zig its normally reverse ownership, for example IWindow owns the object that implements it.
Vs in like cpp or rust its normally the correct way (the object implementing IWindow owns the interface it has with IWindow).
Kinda an interesting side effect of having no builtin interfaces, like yea you can add an interface to an object but then you cant have a running collection of the interfaces unless you are storing a running array of pointers to the interface, which is likely a pain though ive never tried it.

2025 06/01

Read more

looking back at it the archectecture of sandeee really shows I was still learning zig
There are just so many things in it that you dont do even tho zig can do them, like a multi-composition relationship for example, which while yes its in uml is not a pattern anyone uses and if you use it your making it with other stuff, really weird system.

multi composition is something like saying "type A, has a part that is either B, C, or D", not something you use much

its much better to just think of it as a composition of an interface "type A, has a part that has the ability to do P", and then implement "B can do P", "C can do P", "D can do P"
And since thats easier to wrap your head around thats whats notated in docs and implemented.

2025 05/31

Read more

Omg, have you seen laika, I think I've sent clips here but it's actually crazy good, At this point I feel like I just have really low standards bc I've enjoyed my past few games I've played so much lmao
The coolest thing in it to me is the diagetic music system
Like you have a cassette player that you listen to while exploring that plays your playlist, but when your in tense areas or bosses you don't use it, so it plays a set ambience track. The music is pretty much completely in world and I just really like that

2025 05/30

Read more

Obfuscation often seems like a go to security tool for many companies. With this in mind, I recently did some research to see if obfuscation should even be morally accepted. The results were surprising, even to me.

Act utilitarianism is a good framework for judging something as morally good or bad. So, how does it work? Well, if you take the Benefits of something and compare it to the disadvantages, you are already taking the Act Utilitarianism approach. You may wonder why am I bringing this up. Obfuscation is a technique that we could pretty easily divide into pros and cons. So, lets do that with!

Obfuscations benefits are can be easily summed up into the following list:
- More secure code
- Slower reverse engineering time
- Protected code from the public's eye

Obfuscation's disadvantages are more complex, and require longer explanations.

Obfuscation's ability to secure a program, is not really there. Obfuscation's security, though powerful is often thought of as significantly better than it actually is. If you use obfuscation as a sole way to secure anything, you are just deterring the inevitable decompilation of it. There are many alternatives to obfuscation but the most obvious one to fix this would be encryption.

Although obfuscation gives reverse engineers a hard time, it can also, at times, give the developers a hard time as well. There are 2 major approaches to implementing obfuscation: manually obfuscating, and writing a tool to automatically do it. If you manually obfuscate, the time it takes to read your own code will be increased substantially. And If you automatically obfuscate, it will take a while to write the obfuscator, forcing you to debug the obfuscator when you could be working on your actual codebase.

Along side the productivity dip, the overall performance of your programs is also substantially effected. If you obfuscate your code, CPU cache misses often times will be magnified. Along these lines, obfuscation can also use alternative control flows which end up being slower in the long run.

Finally, you may know I'm a big supporter of Open Source Software. A major issue with obfuscation is its obvious promotion of closed source software. Though you may argue that the competition gained by proprietary software is beneficial, I found no substantial research to support this.

You may wonder what these issues even have to do with any programmer who doesn't directly write obfuscators. Well, if obfuscation isn't even a moral practice, why not frown upon its use and advocate more research on other security measures.

2023 12/09