What programming/technical projects have you been working on?

I'm still puttering on a game I've wanted to play since the old days of NetTrek.

It's a LAN multiplayer space combat game, with each ship composed of a crew of several players with a shared "main viewscreen" per shop. I know there have been a couple of these over the years, but mine distinguishes itself by requiring only a modern browser on a phone, tablet, or laptop to join and play.

I've got a lot of work in on the engine, wire protocol, graphics, game dynamics, error recovery, and shaping the learning curve.

Early playtests yielded a surprise - teams tended to get really attached to their ship, and the effect got stronger when I made it possible to tune the VFX for weapons and shields (even though the tuning had no impact on the balance of play).

Where I am now is focused on learning 3D modelling and texturing; I want to make a collection of coherent design systems for ships to appeal to different fandoms. Nacelles-and-beams (Trek-like), greebles-and-blasters (Star Wars-like), and frak-cannons (Battlestar-like) are where I'm starting.

I'm torn about whether it's worth it for me to learn, or just get help building the limited number of models I'll need.

I'm working on a thing to assert that you're a human or that you've got human content. It's got some block-chain and crypto things in it. It's like proof of ID but still anonymous.

I got around to adding the mortgage tracking functionality to my partner's personal finance dashboard; it's working? I think? I'll have to ask him to test thoroughly tomorrow to see if the maths are right.

That is the last feature in his original design, so until he can test, I'm free to do whatever?

I downloaded some old Yu-Gi-Oh! games (the Power of Chaos series) and I wanted to get into modding them, mostly adding a cap to the rewards so you can't earn more than a playset of the same card, and also maybe expand the deck pool for the AI opponents.

That said, I'm also part of Timasomo and that's going much worse than planned so maybe I should focus on it...

I found myself fascinated by a math idea so used programming and some basic graphics to explore it: "square squares" are perfect square numbers whose digits are also perfect squares.

https://merveilles.town/@akkartik/117380846030422227

I participated in a local hackathon and won 3rd place which was nice.

Based on the Ultimate Tic-Tac-Toe post from the other day (snip), I've been working on my own bot. I held rank 1 for a few days last week but then lost it since. Today I made it back to rank 1 after working on this a little bit every day. The fight for the top is pretty crazy. Since X has such a huge advantage, you can't afford to lose as X so the place to gain points is when playing O, you want to steal wins or get draws. The bot that does that the best wins. Having the limitations in place, 1000ms on the first turn and 100ms per turn after, when you can only code your bot with 100k chars, puts some pretty big handicap on the bot. You gotta put as much knowledge as possible in such little time and such a small space. It's a pretty interesting challenge.

Edit: Leaderboard

I learned a bit of WebGL. Just enough to draw a quad using a triangle fan and then applying a fragment shader to it so I can play around with fragment shaders. I then wrote a small transpiler from a subset of the Forth Haiku Salon dialect of Forth to GLSL. This was surprisingly simple once I found the right track. Compilation is logically almost like execution due to a pair of virtual stacks that keeps track of which variable currently corresponds to the top of the stack. So the concept of a stack really only exists at compile time.

A piece of Forth code like 1 3 + 5 * 3 swap - turns into a sequence of assignments in the fragment shader code like such:

d0 = 1.0;
d1 = 3.0;
d0 = d0 + d1;
d1 = 5.0;
d0 = d0 * d1;
d1 = 3.0;
tmp = d0;
d0 = d1;
d1 = tmp;
d0 = d0 - d1;

The stack juggling stuff easily turns into a lot of entirely unnecessary reassignments, but my intuition is that the GLSL compiler will remove those through copy propagation optimization. The transpiler is for now just a Python script, but I want to rewrite it in either Zig (for use with WASM) or to JavaScript so it can be executed in the browser.

I've used three.js once before so I'm not exactly on deep water when it comes to WebGL, but that hides a lot of the details of WebGL so this helped me understand better how it actually works.

The history of it all is especially interesting to me. Shaders as a concept was apparently introduced to Renderman in the late 80s. To my knowledge, GeForce 3 was the first consumer graphics card to implement shaders. The idea is that you can turn texturing and lighting (and whatever else you might think to do with them) into the same problem by having an arbitrary program decide on what colors to output during rasterization. Before that, OpenGL had a fixed lighting and texturing pipeline which could do simple things like flat and Gouraud shading.

The GeForce 3 also had vertex shaders, which similarly execute a program for each vertex and can output whatever other vertex you want instead. In the modern OpenGL APIs you have to supply a vertex shader. For my application, this is very simple. I do translation and a simple scaling transform, just so I could more easily write my four vertices...

Later, geometry shaders became common, which operate on entire sets of vertices and are able to emit a whole new geometry instead. A basic example might be that your input is a bunch of single vertices which are each turned into quads by the geometry shader.

Then there's the "hey, what if we could just as easily apply these programs to arbitrary data instead of just graphics primitives?" that eventually snowballs into these threads being somewhat less interesting reading to me.

Other than that, I've installed the unscii fonts on my systems and use unscii-16 in my terminal. They predate but now implement the Symbols for legacy computing block added in Unicode 13, and provide good implementations of those characters based on old 8- and 16-bit computer fonts. Amiga as well as PC "ASCII" art now both look great in the terminal! I'm currently writing a translation table from C64 character ROM codes to Unicode but found that while it has a "CHECKER BOARD FILL" code which matches the C64 character 0x66, there are no standard half checker board fills as are found on the C64 (0x5a and 0x68). Unscii probably has the missing characters in the PUA blocks, but it would be neat to use standard Unicode entirely. The goal is for my screen editor petshop to be able to output a Unicode representation with escape codes for coloring and inversion.

The font looks great and is surprisingly legible as a TrueType font.

Danger There be talk of 'cool thing" with an LLMs ahead but not written by a toaster. =)

I've been working on a passion project (now small business) coming up on 6 years (guess I can't call it a passion project any more?) making IT management software geared towards MSPs (think settings management, policy validation, config backups, etc across network/servers/workstations) and getting it all packaged on Azure with a pretty interface.

For context I've built out a set of systems to capture and structure device state/config, strip secrets, etc then exposed that info in the UI. Like everyone else, I've been evaluating how/if LLMs have a place in the stack so I created a CLI tool to read from my software which I can give to agents (this abstraction has helped wrangle the LLM to work more rigidly and control access). With everything being structured data, that cuts down on the context of an LLM to see things like "what's installed", "how's it configured", "what ospf settings are in place and what are your neighbors", "what are you plugged into?" etc. Using the CLI just returns narrow json of what's being queried through the CLI.

That's made planning and labbing out changes MUCH easier (esp when used in conjunction with something like container lab). I can now use the CLI/LLM combo to query complex state for things like "show me Fortigate firewall policies at all sites involved with any windows servers running xyz software but only the ones with 10g bonded links" and an agent will use the cli tool to query only the narrow sections of config/state required to answer the question.

Now I've taken it a step further, directing an LLM to review an IT project's requirements and write manifests of changes against the framework of my system change tool and tests against that structured data and feed it back into the system (via that cli tool) which presents a rigid change proposal in the UI. I can then review work against real equipment but with the safety of eyes on the proposed work approving/editing/rejecting changes from the UI with mandatory approvals for any changes. Click the approve button and runners are dispatched to make the changes/run the tests/handle rollbacks.

Needless to say, I eventually got approval for a POC on a real and large client environment to execute a project in this fashion.... and it worked spectacularly well!! Come maintenance windows the process for this particular pilot had become "click the go button and move cables from here to there as told by the UI". I was also able to have cable labels automatically printed to the guys onsite as they moved cables.

I've liked this abstraction of putting software/controls between real equipment and the LLM so it can't directly touch anything. I feel like there's an emerging market to make industry specific tools like this; "Human > LLM > Tool/abstraction/controls > Real thing" where a human can be in the middle to review/approve/audit/etc.

Anyway, I've been enjoying exploring and learning these new (to me) abstractions and wanted to share what I've spending all my time on.

The biggest trouble I've had is wrangling LLMs to be be brief in their verbiage. Change manifests have worked well so far but the amount of exhaustive text they spit out is borderline unusable to a human (which I fear promotes clicking "next, next, next"). What's the answer? A post production agent pass?

Is anyone doing something similar? Has it worked well for you?

A month or so ago I jokingly said I was going to build my own golf game with blackjack and hookers.
Blackjack and hookers are still tbd, but after some contemplation I have decided to actually start working on it.

With copious use of AI agents I now have functional flight, bounce, skid and roll physics that is plausibly realistic, based on published golf physics papers, golf equipment manufacturers' information and finetuning by hand. I have just returned from an afternoon session of miniature golf, but I have never played actual golf, only several different golf videogames over the years, so I've been watching golf youtube instead of TV shows to ensure that I have the right intuition.

The weirdest thing I have involuntarily learned so far is that Donald Trump, even if we account for possible cheating, is genuinely very good at golf for his age, and not only that - in places he almost looks like he's able to enjoy it in a normal, human way, to get actual enjoyment out of something that does not involve bragging or putting somebody else down. That was unexpected.

The game is moving forward well, the most difficult part and the only truly innovative part, which is the course authoring tools that most players will never see, is moving along swimmingly so far, whereas graphics has been a bit of a pain. Even though I'm mostly trying to match the vibe of older videogames like Links LS 2000, which is technologically very basic, getting it actually right to look as comfy and crisp as those old games is a challenge. I wanted to write "especially since I don't want to use generative AI", which I am using here and there for placeholders, but to be honest it doesn't even work well for this graphics style, so it doesn't really matter what I want or don't want.

I only hope that @KilledByAPixel is going in a different direction with his excellent tiny golf game because even though I've had this idea in my mind for a while, it is true that I only started actually working on it after I played his game and realized how fun even a very simple golf game can be. And of course there are clear similarities in my game because I assume we're both using inspiration from the few golf game de facto standards that evolved over the decades. So I feel a bit like a backstabbing golf developer. But I assume our games will turn out different enough.

Rather than writing for the tiramisu thing like I said I would, I've been unable to peel myself away from working on tilegroxy still. I overhauled the documentation, using a more heavily customized template and even adding in a landing page. It's looking much more pretty than it was before. I'm most happy with the callouts on the longer configuration examples, since the service is entirely configuration driven it's really useful to have properly annotated configs.

Here's the documentation website: https://tilegroxy.com

If anyone has feedback to offer, I'm curious.

I foolishly got a Googlebook on launch day, as you do. Googlebook OS is fine, but at heart I'm a Gentoo Linux guy. So this evening Claude and I set out on a journey to get Gentoo running on this hog. From what I understand, the Snapdragon X1E is fairly well supported in mainline these days and this board has good support too. Optimism is high.

Where I sit right now is video, keyboard, and USB2 work a-ok. Currently we're working on getting nVME up and running for a root file system.

Little did I know my playing around with CyanogenMod on my Moto Droid back in the day or embedded software dev on some Arduinos would come in handy to get Linux on a laptop, but here we are. What a time to be alive!

So about a decade ago I wanted a hearing monitor that could be calibrated against my hardware (DAC + headphones) and calculate sound exposure on my ears while using the desktop. This was too difficult for me at the time and I got overwhelmed by the problem so I gave up.

Recently I tried having an LLM take a crack at the problem and it produced something. However since I don't understand the fundamentals of this project very well I've been unable to verify that it's correct. I've been running it for a few days now, it monitors sound output and it does a best effort to calculate sound energy at my ears, and shows me a chart of this history on a web app.

On paper I like the idea of building more human-friendly tools to help keep our meaty parts healthy. In practice, I guess that such a thing is impractical to ship on Linux since there's so many different hardware setups. I don't know how much error there is with such a tool since I don't have fancy microphones to help calibrate correctly. There are many gaps. Luckily my listening patterns aren't loud or long enough to be a safety issue even if there's a significant error margin.

There's some tech-adjacent stuff I did for our game recently: in-game cheats for marketing purposes, and art testing utilities.

Right now the focus is to be able to get another trailer out - more gameplay focused this time. Taking footage has always been a pain, and I've finally decided to be kind to myself (and my teammates) by creating a set of tools to make footage capture easier!

Cheats for Trailer Footage

Here's a list of footage capture "cheats" that I implemented recently:

• Cheat dialog - we used to just have keystroke-based cheat activation, but now I've set up a UI that you can enable/disable with a keystroke, and be able to use buttons and sliders to make some irregular adjustments to gameplay (cheats!)
• Camera controls
  • Allow the user to pan the camera with the right thumbstick (since left thumbstick is typically for moving your character).
  • Allow the user to zoom in/zoom out
    • Shoulder buttons for stepped increments
    • Trigger buttons for gradual zoom
    • Later on I gave up on manually controlling the zoom and implemented a button for automatic, eased zooming in/out towards specific values
  • Zoom and pan reset
• Manual spawn queue setup
  • The user can pick what enemies will appear after how many "beats" (we're making a rhythm game), the quantity of them, and in what spawning pattern (in a circle, a row, a column, in clusters, etc). This all gets queued into a list, then the user can press a button to spawn everything in one go.
  • This was super useful and allowed me to "stage" scenes that could (hopefully) look good in a GIF or a trailer.
  • I added a "copy to clipboard" and "load from clipboard" utility so that the user doesn't have to click the same set of things each time they have to set up a specific scenario. The queue of enemies gets serialized into JSON and then written to the user's clipboard.
• Loadout Store
  • Instead of earning EXP to level up and gain access to a randomized selection of upgrades, the user can just pick which upgrades to get and it gets added to their loadout (they also get levelled up along with each upgrade, so everything will remain looking consistent)
  • Also added a "copy to clipboard" and "load from clipboard" functionality here (see above) for convenience
• Heal the user back to full health
• Invincibility toggle
• Kill all enemies
• Clean up the drops (if I wanna get rid of EXP crystals and other stuff dropped by slain enemies)
• Spawn the boss - the player can pick how much remaining health the boss will have, since our game's bosses change their behavior depending on how much health they have left ("boss fight phases").

These cheats were inspired by this talk by Derek Lieu at GDC).

Art Testing Utilities

I also got a bit distracted by a series of videos (by VFX Apprentice) regarding "artistic principles of VFX", which led me to also implement the following cheats

• Toggle grayscale mode on/off - initially, I did this by simply desaturating all the colors. Later, I replaced this with a more accurate (?) implementation by converting the colors/pixels on the screen from RGB numbers (red-green-blue) to HSV numbers (sue-saturation-value), and then using the value number (pertains to lightness/brightness) as the RGB color to achieve a grayscale effect (please let me know if you want a more detailed explanation).
• Toggle saturation mode on/off - same as above, but instead of using value I used the saturation number.

These two toggles are useful for checking the value and saturation contrasts in your scenes! Good contrast helps you draw the player's eyes towards parts of the game that require their attention... that's what I understand from the theory anyway.

That's all for now!