I'm a tinkerer — the kind of person who sees a settings file, a locked-down console, or a UI I didn't design and thinks "okay, but what if I opened this up." Coding, modding, reverse-engineering, reflashing, rebuilding. I don't stick to one platform or one language; I go wherever the interesting problem is, which lately has meant C on a console that says no, JavaScript on that same console, and a web app that takes dinner orders.
whoami
> Aramaki — builder of tools nobody asked for but everyone ends up using
interests
> coding · modding · hacking · homebrew · reverse engineering · "let's see what's inside"
rule
> if my tool claims to preview what the console does, it runs the console's own arithmetic
The A-Theme project is one pipeline with three theme formats at the end of it — author a theme in the editor, publish it to a database, read it back on the console. The RomM path is the live one, and since CyberFoil gained themes, every RomM and Tinfoil theme can go there too, converted in the editor; the Tinfoil path still works and is still served, but that app has been overtaken. Every arrow below is a code path that actually ships:
🟢 RomM-Themes — where the work is now
The RomM Switch client — a full SDL2 homebrew app rather than a shop — is where most of this project points these days. A theme there is a folder on the SD card and changes far more than a colour scheme; 160 themes published so far:
- 19 semantic colour roles — not raw palette slots, so a theme stays coherent as screens get added
- Backgrounds with a dim control, plus
drift/pan/zoommotion that costs zero extra memory, and real frame animation via sprite sheets - Seventeen focus-effect kinds around whatever is selected — two particle kinds, four that light the focus ring, and eleven border treatments that replace it outright. All procedural, so no art ships with them and they cost no texture memory, and the colour is a palette role rather than a hex so the effect moves with the theme. The maths is one implementation: the browser editor's port is diffed against the client's C++ across 16,133 rows, compared as raw 32-bit float patterns, so the preview is provably what the console draws
- Replacement font, mascot art, and music — including tracker modules, often a few KB for minutes of audio. A theme's font does not cost the console's shared face: that stays loaded behind it and covers any string the theme's typeface has no glyph for, so a Latin-only font leaves Japanese titles readable instead of turning them into boxes
- Every one converts for CyberFoil — copied across as they are, CyberFoil lists none of them (it wants
"version": 1, the number); through Theme-App's CyberFoil editor, it lists all 160 - Every submission is validated in CI against the same rules the client enforces, so a typo'd colour role or an uncommitted background never reaches a console
- Animated backgrounds are budgeted, not trusted: one 720p frame is 3.6 MB of texture, so there's a 48 MB ceiling — and an animation over budget falls back to the still image in the preview, because that's what the console does with it
tools/spritesheet-maker— new — a local app that turns a GIF, a video or one still image into a sheet the client can actually read. The client slicescols = sheet_w / frame_widthfrom the top-left, so a sheet with padding between cells misaligns every frame after the first and nothing says so until it plays wrong on hardware. It ports the client's own acceptance rules — the 48 MB texture budget, the 240-frame and 60 fps ceilings, a cell that isn't 16:9 — and measures frame brightness the way the catalogue's validator does, sincedimis tuned against the still image while the frames are what text sits on. Drop a file and the sheet, a playable preview and thetheme.jsonblock appear; ships as one executable per platform, ffmpeg included
🖥️ Theme-App — the editor for those themes
Three editors, one per theming target, sharing a launcher and the same scaffolding — each runs as a browser app, an installable PWA, and a Windows desktop build the release workflow cuts from CHANGELOG.md on every tag. The RomM editor is where the work goes:
- Browse the published catalog from inside the editor — it reads the same
manifest.jsonthe console reads, and opens a theme with its background, font, mascot and music downloaded, so the quickest way to start is to open the nearest existing theme and change it. The URL handling deliberately mirrors the client's owntheme_catalog.cpp, percent-encoding byte for byte - Background motion that actually plays —
drift/pan/zoomand sprite-sheet animation, previewed by a port of the client's owntheme_motion.cpprather than something that merely looks like drift. A differential test runs 6336 inputs through both implementations and requires byte-identical output; it earned its keep immediately, catching that the console computes in 32-bit float where the first port was a whole pixel off at some timestamps - Import a folder, a
.zippack, or a baretheme.json— atheme.jsononly names its background, so importing one file used to hand you colours and five dangling references - 20 starting palettes, each setting all 19 roles and contrast-checked on the pairs that actually break a theme: body text over all three surfaces, muted text, the focus ring, and whatever sits on an accent fill
The CyberFoil editor — new — for CyberFoil, the installer that gained external themes in 1.5.0:
- Any RomM theme, converted. Pick one from the catalog and it comes out as a CyberFoil pack: 19 roles mapped onto CyberFoil's 11 with the legibility pairs kept together, the background darkened by the theme's own
dimin the pixels (CyberFoil has no dim), and the theme's font — which CyberFoil cannot load — drawing a banner with the theme's name instead. All 160 convert, and CyberFoil lists every one - Tinfoil themes too. All 170 in Tinfoil-Themes convert: Tinfoil's layout colours read for what they do, its logo fitted into the banner, BMPs redrawn as PNG — and where a see-through Tinfoil menu would leave text unreadable over CyberFoil's full-width bars, that bar's opacity is raised just far enough, hue kept, and the change listed
- Checked by CyberFoil's own code. Whether the picker lists a theme, under what name, and which colours and images survive all come from a port of CyberFoil's
theme.cpp. The realtheme.cppis compiled on the host against small stubs and the port has to agree on 5186 cases — names measured in UTF-8 bytes, a BOM,"version": 1.0accepted where"1"is not, an alpha multiplied into a default with integer division - Its screens, from its source — main menu, file list, install queue and install progress, laid out from CyberFoil's page constructors and coloured through the same hex-literal remapping CyberFoil uses, with OLED mode and Remove anime as toggles. The anime mascots can be replaced or hidden
And the Tinfoil editor, still maintained, no longer where new work lands:
- Browse the entire live theme database from inside the app and load one with a click — it downloads and unzips the archive entirely client-side (real embedded JSZip, no server involved) and wires up every bundled logo, background and audio file automatically
- Palette generation via real k-means colour clustering, extracted straight from your background image — not a gimmick, actual dominant-colour maths
- A pixel-accurate mockup preview of the real Tinfoil layout where every visible piece is hoverable: hover a selection tile and it names the JSON field that controls it; click it and the form scrolls there and highlights it
- Full alpha/transparency support with a visual slider and diagram, because hex colour formats are not intuitive and I got tired of explaining them
🕹️ switch-rom-forwarder — new — forwarders built on-device
HOME-menu forwarders for retro games, generated on the console, with no PC in the loop. Point it at a folder of ROMs or a shop index, pick a game, and it resolves the title, fetches box art, and builds the NSP.
- Written in JavaScript — on a Switch. It runs on nx.js, so Node is the only toolchain requirement: no devkitPro, no MSYS2
- Title resolution that survives bad filenames — NACP first (authoritative), then CRC32 against No-Intro/Redump DATs, then filename cleanup. That's what rescues a file called
SLUS-01234or named after its own checksum, and the resolved name is always editable before it's written - It checks forwarders other people made. A forwarder built on someone 8000 else's system points at paths that don't exist on yours, and the failure mode is a title that installs cleanly and then does nothing. This verifies the embedded NRO and ROM paths first, and can rebuild against your real paths
- Sync mode diffs before it acts — new / changed / missing, shown to you first. Missing entries are flagged and never auto-uninstalled, because silently removing things is a bad surprise
- Status: early. The app boots, scans sources, and resolves titles and icons; the NSP build backend isn't landed yet, and the README says so in the first screen of text rather than burying it
🎮 Switch-Theme-Installer — Tinfoil themes, installed on the console
The one I'm most proud of, and the reason the Tinfoil side stays usable. A native C application (.nro) that runs directly on a Nintendo Switch — no PC required:
- Reads the theme database live over the Switch's own networking stack, browsable with a controller
- Real device rendering via SDL2 — an actual on-screen preview of a theme's colours and layout before you commit to installing it
- Runs the same k-means palette extraction as the browser app, but on-device — reads raw pixels out of a decoded image on the Switch itself and rewrites the theme's JSON in place, byte-for-byte, no serializer needed
- Built the hard way: real devkitA64/libnx toolchain, zip extraction via
zziplib, JSON parsing via a hand-verifiedjsmnintegration, and multiple real hardware test-and-fix cycles until it ran clean
🌈 Tinfoil-Themes — the older database, still up
173 entries of community and original themes, served straight off GitHub Pages and read from the editor and from the console. Tinfoil has largely been overtaken by the RomM client, so this is stable rather than growing: the database stays up and the installer keeps working, while new theming work happens on the RomM side. It also has a pre-commit secret scanner, because a Tinfoil options.json carries shop credentials and a theme database is exactly the kind of repo someone pastes one into by accident.
🍲 dinner-by-derek — new — not a Switch in sight
Proof I don't only build things that plug into a console. An installable ordering app for a supper club: customers open a link, pick a day, order, and choose pickup or delivery; the whole week is run from a phone.
- No app store, no customer accounts, no online payment — it's a website that installs to a home screen and behaves like an app
- One file is the database (SQLite), no build step, and Node 20 + Express are the entire stack
- Contrast is measured, not asserted — the palette is six colours plus eight derived tones, audited to WCAG AA, and two of those tones exist only because the audit found pairings that failed
- It generates its own marketing. Social graphics, print cards at 300 DPI with bleed, and thermal-printer stickers with a QR code, all rendered from one brand SVG and the live database — so the week's menu post reads the week that's actually published
Also kept around and kept patched: hekate, Atmosphere, uLaunch, nx-hbmenu, Plutonium and a pile of save editors — the reading list behind everything above.