jakeg.dev

pyZDL: a launcher for GZDoom profiles

2026-11-04T00:00:00+00:00

pyZDL is a Python launcher for GZDoom and other Doom source ports.

Each profile bundles a source port, an IWAD, an ordered mod list, extra arguments, and optional config and save directories. Per-profile directories keep total conversions from overwriting each other's settings.

Features:

Searchable profile library with cover art and keyboard navigation
Ordered load list with enable/disable toggles and drag-and-drop
Automatic -deh handling for .deh and .bex patches

Splitting extra arguments

Profile arguments are typed as a single string, so the launcher has to split them the way a shell would. On Windows, shlex leaves surrounding quotes in place, so they are stripped by hand:

def split_args(value: Optional[str]) -> list[str]:
    """Split an argument string, respecting quotes and multiple spaces."""
    if not value:
        return []
    try:
        parts = shlex.split(value, posix=(os.name != "nt"))
    except ValueError as exc:
        raise LoaderError(f"Could not parse extra arguments: {exc}") from exc
    if os.name == "nt":
        # shlex in non-POSIX mode leaves surrounding quotes in place.
        parts = [
            (
                part[1:-1]
                if len(part) >= 2 and part[0] == part[-1] and part[0] in "\"'"
                else part
            )
            for part in parts
        ]
    return parts

Downloads:

Source on GitHub

Building Resumaker, a small encrypted resume app

2026-11-04T00:00:00+00:00

Resumaker started as a tiny command-line tool: point it at a JSON file, a Go template, and a stylesheet, and it produced a clean one-page resume. That was enough for a while. Then I wanted to publish the code, and the data became the problem. The resume JSON was sitting in the repository, along with every change to my contact details and work history.

I removed it from the git history. The better fix was to stop keeping the resume in the repository at all. Resumaker became a small Go web app: an account can hold several resume versions, edit them in the browser, and print them to PDF without any server-side rendering pipeline.

From a script to a service

The web app is deliberately unexciting: Go's standard library for HTTP, pgx for Postgres, golang.org/x/oauth2 for GitHub and Google sign-in, and server-rendered HTML with Bootstrap. There is no SPA and no build step for the frontend.

Sessions are random tokens stored as hashes in Postgres. OAuth accounts are keyed by the provider's user ID rather than email address, so two providers can never end up sharing an account by accident. Resume content lives in encrypted revisions, which gives the app a simple history model: every save creates a new revision, and the latest one is what the editor loads.

Keeping the data encrypted

The encryption is envelope encryption. Each user gets a random 32-byte data key. That key is wrapped by the server's master key and stored with the account. Each resume revision is encrypted with the user's data key using AES-256-GCM.

The revision ID is used as associated data, so a ciphertext only decrypts under the row it was written to. Moving a revision to another resume, or swapping two revisions, makes decryption fail. The master key stays in the service environment; losing it means losing access to every stored resume, which is the trade-off that makes the design worth it.

Deleting the render pipeline

The first version of the web app had a render queue. Saving a resume enqueued a job, a separate worker claimed it, launched headless Chrome, printed the HTML to PDF, encrypted the PDF, and stored it for download. It worked, and it was a lot of machinery: a worker process, a job table, Chrome availability, timeouts, sandboxing, and encrypted artifacts to clean up.

Then I remembered that every browser already has a print dialog. The preview page is a self-contained HTML document with a print stylesheet. The user presses the print button, chooses "Save as PDF", and gets a better result than the headless pipeline produced. The whole queue, worker, Chrome dependency, and artifact storage disappeared. The change deleted about 1,200 lines and added 200.

The important part is CSS:

@page {
  size: letter;
  margin: 0.42in;
}

@media print {
  .print-toolbar {
    display: none;
  }
}

Page size, margins, and break avoidance live in the same stylesheet as the screen layout. The browser does the part it is already good at, and the server only has to render HTML.

Editing without a JSON textarea

The first editor was just a textarea containing the resume JSON. It was honest, but it was not a good way to edit a resume. The current editor is a structured form with sections for contact details, experience, education, and skills. Rows can be dragged to reorder them, and repeated sections can be added or removed without a round trip.

A toggle switches between the form and the raw JSON. The two views stay in sync: switching to JSON serializes the current form values, and switching back parses the JSON into rows. If the JSON is invalid or contains fields the form cannot represent, the editor keeps the JSON view open and shows an error instead of quietly dropping data. The server treats whichever view was submitted as the source of truth.

The resume list has the utilities I kept reaching for: preview and print, duplicate a version to make a variant, and delete with a confirmation dialog.

Five ways to look serious

Resume templates are where the project gets to have some fun. Resumaker ships with five styles:

Classic is the original LaTeX-inspired one-pager.
Modern is a clean sans-serif layout with a teal accent.
Sidebar puts skills and education in a tinted rail.
Comic is a wholehearted Comic Sans homage, complete with a HIRE ME sticker.
Dingbats is the Wingdings-adjacent option: black section bars and symbol decorations, but the words stay readable.

Classic	Comic

The rest are on the project page.

Deployment

The app is deployed with an Ansible playbook. It cross-compiles the Go binary on the controller, installs PostgreSQL and nginx on the host, creates the database and role, deploys a hardened systemd unit, and obtains a Let's Encrypt certificate through the webroot challenge. Updating is a re-run of the playbook.

That is a lot of words for "a small app", but most of it is one-time setup. The service itself is a static binary, a database, and a reverse proxy.

What I'd add next

The obvious next features are custom template uploads, key rotation, and cleanup jobs for old revisions. Custom templates are the ones I actually want, but they need a real sandbox before I am comfortable running arbitrary template code next to other users' data.

For now, Resumaker does the small thing it was supposed to do: keep a few versions of a resume, keep them encrypted, and make printing one painless.

Source on GitHub · Live site

NGage FPGA

2026-11-04T00:00:00+00:00

A parody product site for the fictional NEXGEN-GAGE NX-1, a reconfigurable handheld whose hardware becomes a different console each time you load a new core. It is written as a late-90s/early-2000s style page, complete with guestbook, visitor counter, and "best viewed in" badges.

Demo: drproteus.github.io/ngage-fpga-site

Pokémon TCG (GBC) Recomp

2026-11-04T00:00:00+00:00

A cross-platform recompilation of the Game Boy Color Pokémon Trading Card Game. The project builds the game from the pret/poketcg disassembly, recompiles it into portable C with gb-recompiled, and runs it on an SDL2 runtime for macOS, Linux, and Windows.

GitHub: drproteus/pokemon-tcg-gbc-recomp

The longer-term goals include widescreen and other quality-of-life improvements, plus a data pipeline that lets card sets be edited as CSV or JSON and levels be edited in Tiled.

Status

This is early-stage work. The native runtime boots and renders the title screen, and the card data tools work. Map extraction and widescreen patches are planned but not yet done.

Reference ROM build (RGBDS, byte-identical): done
Native recompiled runtime: boots and renders the title screen
Native-patch SDK: spike proven
Card extractor, compiler, and CSV/JSON converters: done, with a byte-exact round trip
Card art mapping and new-card scaffold generator: done
Map extractor (to Tiled) and widescreen/QoL patches: planned

How it works

The project separates three concerns so each can be swapped independently:

Ground truth. The pret/poketcg disassembly, assembled with RGBDS, is the reference implementation and the source of truth for data formats.
Recompiled runtime. gb-recompiled turns the ROM into a portable C project with an SDL2 runtime. Native patches and host presentation live here.
Data pipeline. Cards, decks, boosters, maps, scripts, and text are extracted into external formats (CSV/JSON, Tiled TMX/TSX) and compiled back into the game's native formats.

Legal

This repository contains no ROM images and no extracted game data. You need your own ROM that you are legally entitled to use. The build tools check it against a known hash before producing any derived output. The extracted card data is generated locally and git-ignored.

Pokémon is a trademark of Nintendo, The Pokémon Company, Creatures, and Game Freak. This project is not affiliated with or endorsed by any of them.

pyZDL

2026-11-04T00:00:00+00:00

A launcher for GZDoom and other Doom source ports. Profiles bundle a source port, IWAD, ordered mod list, and per-profile config and save directories.

GitHub: drproteus/pyzdl

Downloads:

Resumaker

2026-11-04T00:00:00+00:00

Resumaker is a small Go web app for keeping several versions of a resume, editing them as a structured form or raw JSON, and printing a clean PDF from the browser. It started as a command-line JSON-to-HTML renderer and grew into a hosted app when I wanted to open-source the code without publishing my actual resume.

Each account signs in with GitHub or Google OAuth. Resume content is encrypted at rest with AES-256-GCM, using a per-user data key wrapped by the server's master key. There is no separate render worker and no headless browser: the print stylesheet handles page size, margins and breaks, and the browser's print dialog produces the PDF.

Features:

Structured editor with drag-and-drop reordering and a synced raw JSON view
Duplicate and delete actions, with delete confirmation
Five print styles: Classic, Modern, Sidebar, Comic and Dingbats
PostgreSQL storage with encrypted revisions
Ansible deployment with nginx and Let's Encrypt

Styles

Classic	Modern	Sidebar

Comic	Dingbats

GitHub: drproteus/resumaker

Live: resumaker.skinet.org

Soul Blade Recomp

2026-11-04T00:00:00+00:00

A static recompilation of the PlayStation 1 game Soul Blade. The game's MIPS code is translated into C ahead of time and built into a native executable. It is built on psxrecomp and recomp-ui.

GitHub: drproteus/soul-blade-recomp

Downloads:

v0.0.2 for Windows (x64)

You need your own copy of the game to use this project. The disc image is not included and is never committed to the repository. Releases run on the bundled MIT-licensed OpenBIOS, so no retail BIOS is needed.

Retro Launcher

You can run the game standalone by downloading a release zip and pointing it at your disc. Alternatively, you can manage installs, updates, and disc and BIOS setup with Retro Launcher, a hub for self-compiling recomps.

Building

The generated C for the game is committed to generated/, so you can build from the repository without regenerating it. To regenerate it from a disc image, initialize the submodules and run the psxrecomp CLI:

git submodule update --init --recursive
./psxrecomp/tools/ci/build_emitters.sh
python3 psxrecomp/psxrecomp_cli.py generate \
  --config game.toml --project-root . --disc disc/<your>.cue

Then configure and build with psxrecomp_cli.py rebuild. The README in the repository covers the full build and release process.

Cataloguing PlayStation discs with psx-tools

2026-10-17T00:00:00+00:00

Multi-disc PS1 games are easy to lose track of. psx-tools is a set of small Python scripts for working with PSX ROMs.

detect-title reads the Title ID from a disc image.
lookup-disc finds the game by Title ID using SerialStation.
m3u_gen writes .m3u playlists for every disc set in a folder.

Finding the Title ID

The scanner skips the first 32 KiB of the image, then reads the rest in 4 KiB chunks until a regex matches a Title ID such as SLUS_012.51:

def get_psx_id(file_path: str) -> str | None:
    try:
        with open(file_path, "rb") as fin:
            _ = fin.seek(32768)  # Skip the first 32768 bytes
            while buffer := fin.read(4096):
                buffered = buffer.decode("ISO-8859-1")
                matches = title_re.search(buffered)
                if matches:
                    return matches.group(0)
    except Exception:
        pass

Source on GitHub

psx-tools

2026-10-17T00:00:00+00:00

Python scripts for PSX ROMs: read Title IDs from disc images, look up games on SerialStation, and generate .m3u playlists.

GitHub: drproteus/psx-tools

SirtetJS: Game Boy Tetris in Phaser

2026-07-30T00:00:00+00:00

SirtetJS is a Game Boy Tetris clone written in JavaScript with Phaser.

Rotate clockwise with C, counterclockwise with X.
Choose 1 Player on the menu and press space to start. The 2-player option is not supported yet.

Rotation

Rotation is an index into a table of precomputed shapes, following the Nintendo Rotation System. Each piece stores its orientations, and rotating only moves the index:

getCWIndex() {
    return (this.index + 1) % this.rotations.length;
}
getCCWIndex() {
    let i = (this.index - 1) % this.rotations.length;
    if (i < 0) i = i + this.rotations.length;
    return i;
}
rotateCW() {
    this.index = this.getCWIndex();
}

It builds with Bun and runs from any static file server. Try the live demo, or see the source.

SirtetJS

2026-07-30T00:00:00+00:00

A Game Boy Tetris clone implemented in Phaser, built with Bun.

GitHub: drproteus/sirtetjs

Demo: drproteus.github.io/sirtetjs

ebaysearch

2026-07-05T00:00:00+00:00

A work-in-progress command-line tool that scrapes eBay completed listings, so you can see what items actually sold for before pricing your own.

GitHub: drproteus/ebaysearch

Solving Protohackers in Go

2026-07-01T00:00:00+00:00

Protohackers is a set of network programming challenges. Each one asks you to build a server that speaks a specific protocol correctly under load.

I've completed the first six challenges in Go. Each solved README includes its test output as proof. The code is in the protohackers repo.

The challenges

Smoke Test: a TCP echo server that handles several clients at once.
Prime Time: a JSON-over-TCP server that answers whether a number is prime.
Means to an End: a binary protocol for storing prices by timestamp and returning their mean.
Budget Chat: a multi-user chat room over TCP.
Unusual Database Program: a key-value store reached over UDP.
Mob in the Middle: a proxy that rewrites Boguscoin addresses in chat messages.

Prime Time

Non-integers are never prime, and big.ProbablyPrime(0) gives an exact answer for values that fit in 64 bits:

num, _ := request.Number.Get()
var prime bool
if math.Trunc(num) != num {
    // Non-integers are automatically non-prime
    prime = false
} else {
    prime = big.NewInt(int64(num)).ProbablyPrime(0)
}

Protohackers

2026-07-01T00:00:00+00:00

Solutions to the Protohackers network programming challenges, written mostly in Go. Each problem directory includes its own README with the problem statement and, once solved, the test output as proof.

GitHub: drproteus/protohackers

Bun Phaser Template

2026-06-20T00:00:00+00:00

A starter Phaser 3 game project built with Bun. Use it as the base for a new browser game.

GitHub: drproteus/bun-phaser-template

Run bun install, then bun run build and bun run serve. The dev server runs at http://localhost:3000.

Demo: drproteus.github.io/bun-phaser-template

Bun Web App Template

2026-01-28T00:00:00+00:00

A starter web app built with Bun. It includes Backbone, lodash, jQuery, Normalize CSS, and Sakura CSS.

GitHub: drproteus/bun-app-template

Run bun install, then bun run build and bun run serve. The dev server runs at http://localhost:3000.

The demo uses the arrow keys to move a cat around the page.

Demo: drproteus.github.io/bun-app-template

gthumb

2026-01-28T00:00:00+00:00

A Go tool that scans a directory for JPEG photos, applies their EXIF orientation, writes square thumbnails and display-size copies, and produces a single-page static gallery (index.html) that can be hosted anywhere.

GitHub: drproteus/gthumb

Usage

go run . -src examples -out public

Each directory under -src (including -src itself) that contains JPEG files becomes an album. The output looks like this:

public/
  index.html
  thumbs/<album>/<photo>.jpg   square thumbnails (center-cropped)
  photos/<album>/<photo>.jpg   display-size copies (aspect ratio kept)

The main flags are -src, -out, -templates, -title, -thumb (default 400px), -max (default 2048px), and -quality (default 80).

How it works

Orientation: the EXIF Orientation tag is applied, so phone photos shot in portrait come out upright.
Metadata: camera model and capture date are shown in each photo's caption when present. Files without EXIF data are still processed.
Thumbnails: scaled so the shorter edge matches -thumb, then center-cropped to a square.
Display images: scaled to fit within -max on the longest edge. Images are never upscaled.
Template: templates/index.gohtml is a plain html/template, so the layout can be changed without rebuilding.

It uses bild for image work and go-exif for EXIF parsing.

channel2600

2026-01-07T00:00:00+00:00

A 2600chan-style imageboard written in Python. Threads and images are stored through Cloudinary, with ReCaptcha on posting.

GitHub: drproteus/channel2600

Earthman64

2025-12-12T00:00:00+00:00

A Commodore 64 memorial demo written in 6502 assembly. It shows a bitmap image with a cover of Coldplay's "Clocks" playing from the SID chip.

GitHub: drproteus/earthman64

Building

Assemble with dasm, then run the .prg in VICE. After loading, enter sys 2064.

dasm main.asm -oearthman.prg

Music and timing

The music plays from a raster interrupt. The code points the IRQ vector at $0314 to irq, then fires it at scanline $7e. Each interrupt calls the SID player and acknowledges the VIC:

	lda #<irq
	ldx #>irq
	ldy #$7e
	sta $0314
	stx $0315
	sty $d012
	...
irq:
	jsr $1003
	asl $d019
	jmp $ea81

The demo is still in progress. Scrolling text is on the to-do list.

Bun Postgres and S3 Template

2025-08-30T00:00:00+00:00

A working prototype for storing collections of items with image attachments, using Bun with Postgres for records and an S3-compatible store for media.

GitHub: drproteus/bun-pg-s3-backend

lastfm-grid

2024-10-16T00:00:00+00:00

A Flask server that builds a cover-art grid from a Last.fm user's top albums, served as a single image.

GitHub: drproteus/lastfm-grid

Demo: lastfm-grid.skinet.org

SIRTET

2024-10-12T00:00:00+00:00

A Tetris clone written in Lua for the LÖVE framework, started in 2014.

GitHub: drproteus/sirtet

Cellular Automaton

2023-05-31T00:00:00+00:00

Conway's Game of Life in vanilla JavaScript with no dependencies. An early experiment, with plans for wrapping edges and a cube-face variant.

GitHub: drproteus/cellular-automaton

Demo: static.skinet.org/cellular-automata

pyCHIP-8

2022-11-12T00:00:00+00:00

A CHIP-8 virtual machine interpreter written in Python.

GitHub: drproteus/pychip8

YACA

2022-10-13T00:00:00+00:00

Yet Another Caffeine App: a small Python app that keeps your Mac awake. Packaged as a macOS .app with make build.

GitHub: drproteus/yaca

bodyport

2022-03-14T00:00:00+00:00

Research into lossless compression for numerical sequences. Since no single scheme works for every data shape, this project parses the samples into 3-byte signed integers, plots them, and tests a compression approach against the shape of the data.

GitHub: drproteus/bodyport

EndOS

2017-01-06T00:00:00+00:00

A live Linux distribution for when you need a comfortable system to develop on. Built with archiso on Arch Linux and bundled with XFCE, preconfigured with a dark Adwaita theme.

GitHub: drproteus/endos