One person's work, in one place. Apps so far, and whatever else turns out to be worth sharing. Each app says on its own page what it costs.
Live at itsdoubleem.github.io — deploys on push to
main.
This is a studio site, not a marketplace and not a blog. Every page answers three things for a stranger who lands on it: what does this person make, can I get it right now and does it cost anything, and who made it. Anything serving none of those does not belong here.
Three, and they are not style preferences.
- No invented numbers. No install counts, no download totals, no star ratings, no "trusted by N users", no testimonials — unless the figure is real and you can say where it came from. One honest page beats ten fabricated metrics, and a visitor who catches a single made-up figure is right to discount everything else on it. Where there is no number yet, say what the thing does instead.
- Do not promise that anything stays free. Everything here is free today, and each app says so on its own page, where it is a fact about that app. "Free, always" and "and it stays free" are promises about work that does not exist yet — the only way to keep one is to never charge for anything, ever — so they are not made. If something here is ever paid, put the price plainly on its page. What stays banned is the furniture around money, not money: no tiers, no "pro" version held back, no upgrade prompts, no email-gated downloads.
- Verify a claim against the running app, not against a grep. Check that a feature exists by using it on screen, and that it is gone by failing to find it on screen. This applies doubly to privacy claims: if a page says data never leaves the device, someone checked that recently.
The site collects nothing, so it needs no cookie banner. It loads two scripts on every
page — /motion.js and /globe.js — which move things and nothing else. /globe.js
paints nothing itself; it measures the device and fetches one of two fields. A window
over 1200px, or a narrower one with a mouse, gets /three.min.js and /globe-scene.js,
which draw the globe behind the story on the front page and, on every other page, the orb
field that globe sits in — that covers laptops, desktops and tablets. A phone gets
/sky-mobile.js, about 20 KB, which draws that same orb field in a 2D canvas with no globe
and no library, so a handset still never downloads the 589 KB one even when it asks for
the desktop site. three.js is vendored into /public under its MIT licence rather than
loaded from a CDN, so there are still no third-party requests, no analytics and no
cookies. Keep both true. All five are named in the about page's prose and in the claim every
app page carries (siteClaim in src/site.ts); a sixth one means editing those in the same commit.
Adding something is adding one markdown file to apps/, and npm run new-app -- <slug> "<Name>" [owner/repo] starts it in the shared format. npm run check fails on every TODO it
leaves. Nothing in src/ names an app, and no page is written by hand. The frontmatter contract is
src/content.config.ts; it validates at build time, so a typo
fails the build rather than shipping a broken page.
Each entry declares a type — app, tool, writing, novel, bot or other — and
the homepage renders one section per type. A section appears only when something is in
it, because an empty "Novels" heading would advertise work that does not exist, which is
rule 1 wearing a different hat.
Optional frontmatter grows the detail page, each part appearing only once filled:
screenshots (real captures, never mock-ups), platformNotes (what differs per
platform), and verify — a claim paired with the way a reader can check it themselves.
That last one is this site's answer to install counters: a number you are asked to
believe, swapped for something you can confirm.
A walkthrough is optional and lives in guides/<slug>.md. Its screenshots are captured
from the shipping app by that app's script — tools/capture-logger.mjs,
tools/capture-hangil-guide.mjs — never drawn — re-run it after any
change to the app, because a guide showing a screen that no longer exists is worse than no
guide: the reader assumes they are the one who is lost.
Install steps in the app's own languages are optional too, in install/<slug>.md. They
add a line of language names under the download buttons and a section with one row per
language. A translation no native speaker has checked says so on the page. See
install/README.md.
npm install
npm run dev # http://localhost:4321
npm run build # → ./dist, and fails on a missing asset or a hash that is not the file's
npm run check # downloads match their release: block and README, and the web build
# inside each APK matches release.web; the sample record matches
# LOGGER's version; every #link lands; the homepage primer reads
# cleanly, cites both its sources and points at a chapter that exists
npm test # unit tests in tests/ — Node's own runner, nothing to installCI runs npm test, npm run build and then npm run check, and a failure in any of them
stops the deploy. Every pull request gets the same three (.github/workflows/check.yml).
Dependency updates mostly merge themselves. Dependabot opens them
(.github/dependabot.yml, a few days after each release), and once a day
.github/workflows/deps.yml takes the oldest one that qualifies, tests it on main as it is
then, and merges it as your own commit, then deploys. A qualifying update is one npm package,
a patch or minor version change, open three days or more, touching only package.json and
package-lock.json, in one commit signed by GitHub (tools/deps-lib.mjs). Anything else waits
for you: majors, groups, every update to an action, and anything that fails, which gets a
comment saying so and is tried again only after Dependabot rebases it. Run
node tools/pick-deps.mjs to see what it would decide for each open one.
Astro, static output, no client framework and no adapter. The content is markdown, it
builds to plain HTML that works with JavaScript switched off, and GitHub Pages serves the
files. If astro build ever prints an adapter: line, something has reintroduced one —
take it out, because Pages cannot run a server entrypoint.
Every app is a separate project in its own folder and none of their source is vendored
here. This repo carries their built output — LOGGER's Android package and offline web
build in public/downloads/ and public/logger/, HANGIL's in public/hangil/ — so the
download buttons have something to point at on a CI runner, which builds from the
repository and cannot see an ignored file. Re-copy after any rebuild of an app; these
files are committed deliberately, not by accident.
| App | Source | Built into |
|---|---|---|
| LOGGER | ~/Logger_app |
public/logger/, public/downloads/logger.apk |
| HANGIL | ~/Hangil_app |
public/hangil/, public/downloads/hangil.apk |
Each has its own DEPLOY.md with the exact copy step, and its own README that is the
authority on what that app is. HANGIL's page screenshots are captured from the shipping build
by tools/capture-hangil.mjs and its guide's by tools/capture-hangil-guide.mjs, the same
way LOGGER's guide is by tools/capture-logger.mjs.
The APKs this site serves are committed under public/downloads/. Their SHA-256 sums are
62c91b7b2c6fccbf8991e22d7105d235a5f79e95cf99965ad840d8236ae1fd1f logger.apk
31c03f7cdd8da5a1579745c215707947757ce4fd7939f8caaadbc5732e4fac53 hangil.apk
The app page prints the same hash, but a hash is only worth as much as the page it sits on — anyone who could swap the APK on the site could swap the hash printed beside it. This copy is the second opinion. It lives on github.com rather than on the site, so a tampered download has to survive two places instead of one.
Regenerate them in the same commit that replaces an APK, never later:
shasum -a 256 public/downloads/*.apkA hash here that does not match the file is worse than no hash at all — it teaches the one
reader who bothered to check that checking is pointless. npm run check fails if the line
for an APK is missing or wrong.
Every fact about a release lives in one place: the release: block in apps/<slug>.md.
release:
version: 1.0.1 # typed once; the build cannot read it out of the APK
date: 2026-10-11 # the day it was published — starts the "New" pill
apk: /downloads/hangil.apk # must also be one of the page's downloads
sha256: 3846f5c0…df7fff75 # the build fails if this is not the file's hash
web: /hangil/ # optional: the offline web build, measured at build timeThe page never types these values into prose. It writes a token, and the build fills it in:
| Token | Prints | From |
|---|---|---|
{version} |
1.0.1 |
release.version |
{apkSize} |
1.6 MB |
measured from the APK |
{sha256} |
the full hash | release.sha256, checked against the APK |
{webSize} |
897 KB |
measured from the release.web folder, READMEs left out |
Tokens work in download notes, platform notes, verify entries, the update notice (badge
included) and the wrong aside. An
unknown token fails the build, and so does a hash or an APK size typed out by hand
(npm run check). Sizes are binary units written as KB and MB, which is what a phone's
file manager shows.
An app with source: in its release: block updates itself. Every hour, the deploy
workflow runs tools/sync-apps.mjs, which reads that repo's Latest GitHub Release. If it
is newer than what the site serves, the sync:
- downloads its APK (the asset named
asset:, or its only.apk) and refuses it unless its versionName matches the tag, it is signed by the certificate insigner:, and it asks for no Android permission the served APK does not (and never for INTERNET — both pages say the app cannot reach the network); - works the whole update out before writing anything, so an app that fails leaves the tree as it was;
- copies the APK to
public/downloads/, itsassets/www/intorelease.web, the 512px icon its manifest names over the page'sicon:, and rewritesversion,sha256,dateand the hash in the list above; - writes the release's notes to
releases/<slug>.md(cleaned: no HTML, PR numbers, hashes or links into the app's repo), which the page shows as What's new for the same seven days; - commits to the branch
sync/candidateas the owner's noreply address. Theverifyjob runs the tests, the build and the checks on that commit, and only if they all pass doespromotemovemainto it, after which the same run builds and deploys. A candidate that fails stays out ofmain, so the rest of the site keeps deploying and pills keep expiring. It holds back every app updated in that run, and the sync tries again on its next run. Read the red line in theverifyjob.
A release can ask for its update straight away instead of waiting for the schedule, which
GitHub runs 3–7 times a day rather than hourly. tools/release-app.mjs does this for you. A
release made any other way can do it with this workflow in the app's repo, and a fine-grained
token limited to this repository with Contents: read and write, saved as the app repo's
SITE_DISPATCH_TOKEN secret. If the token ever expires, the schedule still finds the release.
on: { release: { types: [published] } }
permissions: {}
jobs:
notify-site:
runs-on: ubuntu-latest
steps:
- run: gh api repos/itsdoubleem/itsdoubleem.github.io/dispatches -f event_type=app-release
env: { GH_TOKEN: "${{ secrets.SITE_DISPATCH_TOKEN }}" }If the live site falls behind, an Issue says so. .github/workflows/watch.yml runs
tools/check-live.mjs after every deploy run and once a day. It downloads the live APKs, reads
the live pages, and compares them with main and each app's Latest release. While anything is
wrong (an old APK, an overstayed pill, a release not arriving, no deploy for two days) one
Issue stays open, and it closes itself when the check passes. Run
node tools/check-live.mjs to see the same answer.
Outside links are checked weekly. .github/workflows/links.yml builds the site and asks
every outside link, including each citation in the homepage deck, whether it is still there.
One Issue stays open while any gives a definite "gone" (404, 410 or a host that no longer
exists, asked twice a minute apart). Sites that refuse robots are listed in that Issue but
never raise it on their own: on 2026-11-08 Britannica answered 403 to all twelve of its links.
Run npm run build && node tools/check-links.mjs to see the same answer.
To release an app, run node tools/release-app.mjs <slug> on the Mac that holds the
signing keys, after bumping the version in the app's repo and pushing it. It works the same way
for every app: it builds the APK, applies the sync's checks on the version, signer, permissions,
notices and web build (and refuses a dirty folder, a used version or missing notes), and shows
you the notes. Nothing is published until you add
--publish, which creates the Release with the APK attached and tells the site to update now.
Notes come from the CHANGELOG.md section whose heading names the version, or --notes-file.
A release with no APK attached is skipped with a warning on the run — so attach the APK to
every app release on GitHub, or the site never sees it. HANGIL's releases up to v1.0.2
carried none. A refusal (signer, version, permission, a notice tied to the old version)
fails the run and publishes nothing for that app. It fails again every hour, with a GitHub
email each time, until someone acts: read the run's red ::error:: line, then either fix
the release or update the app by hand.
What the sync cannot do is look at the app: screenshots and LOGGER's sample record need the
running app on a Mac (step 5 below). The first time it moves an app past them it writes
captured: '<old version>', and the sample-record check holds the record to that. While any
app has that line, watch.yml keeps one Issue open naming it (tools/check-captures.mjs).
npm run retake -- <slug> does steps 5 and 6 in one go: it starts the dev server, runs that
app's capture scripts and deletes the captured: line. It stops, and keeps the line, if a
script fails or if two of its new pictures in one folder are the same file byte for byte, which is
what a script stuck on a changed screen produces. A stuck screen with a ticking clock gets past
that, so it is a tripwire and not a check. Look at every picture before you commit. Run node tools/sync-apps.mjs by hand
to do the same sync locally without committing.
Without source:, or to update by hand, an update is:
- Copy the new APK into
public/downloads/<slug>.apk. Take the web build out of that APK, not out of the app's own build folder, which may have been rebuilt since the release:unzip public/downloads/<slug>.apk 'assets/www/*'into a scratch folder and copy its files intopublic/<slug>/. Keep any file the site adds, such as HANGIL'ssw.js. shasum -a 256 public/downloads/<slug>.apk. Put the hash inrelease.sha256and on that APK's line in the list above, in the same commit.- Set
release.versionandrelease.date(the day the version was published). For seven days from that date the download button wears a red New · {version} pill, on every app, with nothing else to switch on — see § The release pill. - If the app has an update notice with a
version:, the build now fails until you rewrite it for this release or delete it (see below). The same goes forreleases/<slug>.md, the What's new notes: the build fails while itsversion:is notrelease.version. Withsource:set, delete the file and runnode tools/sync-apps.mjsto write it from the GitHub Release; otherwise edit it by hand (releases/README.md). - Re-run the app's capture scripts with
npm run devrunning, and look at what changed:node tools/capture-logger.mjsfor LOGGER;node tools/capture-hangil.mjsandnode tools/capture-hangil-guide.mjsfor HANGIL. - LOGGER only: regenerate the sample work record in its guide, whose footer prints the
app's version. With
npm run devrunning,node tools/make-sample-record.mjswrites both the record and12-record.png, the guide's picture of it. It writes all three files only at the very end, one after another. If the record is missing the invented worker, the shifts or the pay period, it exits 1 and writes none of them, and a crash before the end leaves them as they were too. Look at the picture, and atgit status, before committing. npm run build && npm run check. The check fails if the sample record's footer and LOGGER'srelease.versiondisagree, or if any file in an APK'sassets/www/differs from the one served underrelease.web.
Every app with a release: gets a red New · {version} pill on the corner of its APK's
download button for NEW_FOR_DAYS (7, in src/release.ts) from release.date, the release
day counting as the first. Days are Korean days. Then it goes by itself: the site is
static, so it drops out of the next build, and the deploy workflow rebuilds once a day for
this reason. Shipping the next version with a new date brings it back.
The pill and What's new go together, on every app. While a release is new, the build
fails unless releases/<slug>.md exists and says something: a release is never announced
without saying what changed. With source: the hourly sync writes it; without, write it by
hand (releases/README.md).
It links to what there is to read: an update notice if there is one, else What's new in
{version} (releases/<slug>.md), which shows in red at the top of the reading column for
the same seven days. With neither it is a label. As a link it sits beside the button rather
than inside it, so the button still downloads.
When an update needs the reader to do something first, such as take a backup before a key
change, give the app a notice:. The page then shows:
- the release pill on the download button, linking to the notice. If the notice is kept
up past the release's new days with an
until, the pill stays too and shows the notice'sbadgeinstead. - a notice section at the top of the reading column, headed by its
badgein red, with an anchor the pill jumps to.
notice:
badge: Had 1.0? Read first # the notice's red tag; 28 characters at most
heading: Had version 1.0? Take a backup before you update
body: | # paragraphs, separated by a blank line; tokens allowed
Version {version} is signed with a new key, so Android will not install it over 1.0.
Updates after this one install over the top.
version: 1.0.1 # optional: the release this was written for
until: 2026-12-31 # optional: the last day it shows (default: while the release is new)
download: /downloads/hangil.apk # optional: which button wears the pill
id: update-notice # optional: the anchor; this is the defaultversionties the notice to one release. Whenrelease.versionchanges, the build fails with "notice was written for 1.0.1 but release.version is 1.0.2", so a notice about one update can never sit silently on the next one.untiltakes the notice down after that date. Without it the notice goes when the release pill does, seven days fromrelease.date— HANGIL's 1.0 notice had no end date and stayed up for weeks, which is why that is the default. Either way it goes at the next daily build, so it is gone within a day.downloaddefaults to therelease.apkbutton, or the first download if the app has no release.
A notice with a version: also stops the hourly sync for that app when a newer release
appears: a person wrote it about one update, so a person decides what becomes of it.
Most releases need no notice: the release notes already show as What's new. A notice is for the rare update that asks the reader to do something first. The pill links to the notice when there is one, and to What's new otherwise.
Only one notice per app. The red (--alert in global.css) is used for nothing but the
pill, What's new and the notice, so a page whose release is not new has no red on it. Since a notice goes by itself,
no other part of the page may depend on it being there — say the caveat in full where it
matters, as HANGIL's Android note does, rather than "see the note at the top".