Project portfolio

Why RompMusic?

• Libre software — GPL-3.0: use, study, modify, share.
• Gratis — No paywalls or proprietary lock-in.
• Self-hosted — Library stays on your server; full privacy.
• Cross-platform — Android, iOS, and web.
• Gapless playback — Albums without gaps between tracks.
• No tracking — Zero telemetry or analytics.

Components

Server (quick start)

python -m venv venv && source venv/bin/activate
pip install -e .
cp .env.example .env
uvicorn rompmusic_server.main:app --reload

Notable env: MUSIC_PATH (library root), AUTO_SCAN_INTERVAL_HOURS, BEETS_AUTO_INTERVAL_HOURS. Dashboard scans use a background DB session so they continue if the tab closes.

Client (Android playback)

Background playback uses react-native-track-player: native service owns the queue; JS dispatches play/pause/seek; events sync back to the store. Patch included for Kotlin nullability with Expo SDK 54.

Docker (umbrella)

git clone --recursive https://github.com/151henry151/rompmusic.git
cd rompmusic
cp .env.example .env
# Edit DB_PASSWORD, JWT_SECRET, …
docker compose up -d

Docs: Install, Configuration, Self-hosting.

Features

• Fog-of-war board; lobby; vs computer (bot uses same fog rules); challenges; random colors.
• Fischer time controls (minutes+increment); server-side clocks; captured-piece counts.
• Post-game review: fog lifts; replay full position history.
• Full chess via chess.js: check, mate, stalemate, castling, en passant, promotion, draws, resign.
• Disconnect handling; return to lobby.

How visibility works

The server keeps the true position and per-player path memory; each client gets a masked view. Opponent moves do not reveal the board for you.

1. Your pieces — always visible.
2. Your traveled squares — cumulative paths: pawns (each step); knights (chosen L-route, every square on the L); sliders (full ray); kings (start/end; castling paths); en passant capture square on path.
3. Captures against you — capture square revealed afterward.
4. Visible squares — empty reads empty; occupied shows that piece if visible.
5. Probes — illegal pawn push into block, or fake diagonal capture to empty (non–en passant): lose turn without moving; destination stays explored.
6. Sliders — enemy on ray: capture first blocking piece; (friendly-block behavior per engine rules).
7. Into check — illegal destinations still highlight; attempt fails without passing turn; hypothetical attackers flash red.

Server sends dark-chess targets after piece select; every move is validated.

Architecture

darkchess/
├── server/index.js    # HTTP + Socket.IO
├── server/dark.js     # Fog / masking
├── public/            # index.html, app.js, style.css
└── package.json

Run & deploy

Node 18+; ESM. npm install, npm start → http://localhost:3333 (override PORT). State is in memory—one process or sticky sessions. Behind nginx, proxy /darkchess/ and /darkchess/socket.io/ (v1.3.1+ uses relative assets and socket path). GPL-3.0+.

What this is

• Landing — Introduction + Chapters I–XX with short descriptions.
• Per chapter — Reading level switcher: ELI5, ELI10, ELI20, and Full Text (embedded chapter PDF only).
• Layout — Left: explanations or PDF iframe; right: unique interactive companion (MIU system, pq-system checker, figure–ground, etc.).
• Design — Vanilla HTML/CSS/JS; shared/style.css, shared/nav.js; fonts EB Garamond + Inter.

Structure

• index.html — chapter grid; intro/, chapter-01/ … chapter-20/.
• pdfs/ — intro.pdf, chapter-01.pdf … (one scroll range per iframe).
• scripts/split_geb_pdf.py — regenerate PDFs from full book (Python 3, pypdf).
• PLAN.md — chapter plan and companion concepts.

Build: none—serve static files from /geb/. Each chapter embeds only its PDF segment so viewers cannot scroll into adjacent chapters.

Tech stack

Backend: FastAPI, Uvicorn, SQLAlchemy, SQLite. Frontend: Expo, React Native, React Native Web. E2E: Playwright.

API (excerpt)

• GET /health, GET /colors
• GET /level/{level} — canvas data; levels 2–6 need section_x, section_y
• POST /paint — { x, y, color }
• POST /zoom — validate { level, section_x, section_y }

Getting started

bash ./start-backend.sh    # http://localhost:8000
bash ./start-frontend.sh   # Expo; press w for web

Structure: backend/, frontend/, optional shared/. Version in VERSION; license GPL-3.0-or-later.

Key features

• Continuous background recording; configurable segment length (15s–30 min).
• Auto Music Mode — silence-based splits targeting ~5 min segments.
• Retention window; rotating buffer deletes oldest segments.
• Quality presets: Low 16 kbps, Medium 32 kbps, High 128 kbps.
• Export; WorkManager for rotation; Room DB for segment metadata.

How it works

ListenForegroundService orchestrates capture; MediaRecorder for encoding; segments as files; SegmentManagerService for rotation. Flow: record → split → prune when over retention.

Privacy

No network permission required for core recording; microphone permission explicit; optional encryption; one-tap delete.

Features

• URL input; preview; auto-generated videos; YouTube OAuth; playlist creation.
• Metadata from archive pages (artist, venue, date, lineage).
• Resume: skip downloads/uploads already done.

Flow

1. Paste archive.org details URL.
2. Preview tracks and durations.
3. Authenticate with YouTube.
4. Process: download audio → ffmpeg → upload → playlist.

Stack

FastAPI/uvicorn (systemd on hromp), ffmpeg, Python 3. CLI: python upload.py <archive.org URL> after install—see repo README.

Model contents

• Substrate & nest — heightmap-style world; sand grains; gravity; nest galleries.
• Pheromone & CHC fields — recruitment trail (deposit, diffusion, evaporation), footprint traffic field, nest cue, stress alarm.
• Life cycle — queen founding, brood, nanitics/workers, trophallaxis, task allocation (forage, dig, care).
• Workers — scout/recruit tropotaxis, zigzag sampling, food memory, trail marking.
• Instrumentation — CSV logs, tracing; see docs/reference/technical_specification.txt.

Run

Prebuilt Windows EXE, Linux AppImage, and raw ELF on GitHub Releases (mirrored under hromp /downloads/). Or open game/anthill in Godot 4.2+.

Structure

invoice_gen/app.py — main Flask app; templates/ — Jinja2 UI; static/ — CSS/JS and uploaded logos; requirements.txt; Alembic migrations under migrations/. Pretty invoice template: templates/invoice_pretty.html.

Run (dev / Docker)

python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
flask run

Production-style: docker-compose up --build (Gunicorn). Dev with hot reload: docker-compose -f docker-compose.dev.yml or ./switch-env.sh dev / prod. Key env: FLASK_ENV, SECRET_KEY, DATABASE_URL, SCRIPT_NAME=/invoice when mounted under a prefix.

Typical workflow

1. Register / log in; create or select company and client records.
2. Add line items and/or labor rows; adjust tax and notes; preview in the browser.
3. Generate the invoice (pretty HTML template) and download Excel where configured.
4. Drafts autosave locally and on the server so a refresh mid-edit does not wipe work.

Extras

• Optional Google Places address autocomplete — API key in credentials.ini (see README).
• REST-style JSON endpoints for clients, companies, invoice number checks, sales tax CRUD, session selections.
• Test harness script populates sample businesses, clients, and invoices for manual QA.

Satellite bands

CONUS GeoColor, snow/ice, day/night cloud combo, full-disk GeoColor, air mass RGB, sandwich RGB, ozone, water vapor (lower/mid/upper), dust RGB, and more—24-frame loops with hover-to-pause and click-through to NOAA.

Location & alerts

ZIP-based location with coordinate lookup (Zippopotam.us); dismissible, color-coded alerts. Temperature and precipitation forecast map links update with the selected location.

Technical

Custom frame-based animation; fetch() to NWS and STAR endpoints; CSS Grid/Flexbox. Files: index.html, styles.css, links.txt. Serve with any static host (python3 -m http.server for local dev).

Using the dashboard

Open the page to see current conditions, 7-day forecast, and the satellite grid; use Change next to the ZIP to reload everything for a new location. Hover satellite tiles to pause loops; click through to NOAA for full products. Dismiss individual alerts with the × control.

Features

• Search + A–Z browse — substring search (up to 200 hits) or letter row in book column order; optional linter scripts flag OCR ordering quirks.
• Name builder — drop stopwords, match glosses, chain stems with Greek/Latin linking rules; outputs draft epithet—still needs real taxonomy checks.
• Entry cards — expand (G)/(L) tags; collapsed introduction panel with Borror’s preface.

Build & data

cd web && npm install && npm run dev
# Production: VITE_BASE=/word_roots/ for https://hromp.com/word_roots/
python3 scripts/extract_dictionary.py   # regenerate dictionary.json from PDF

Requires pdftotext (Poppler) to regenerate JSON from the PDF.

Gameplay loop

Shape future slices before the lockline passes them; follow anchor schedule and resolve entries on the paradox ledger. Lore text per level explains the temporal metaphor (“every slice exists at once,” observation frontier freezing the past).

Controls (excerpt)

• F/R or arrows — move selected time slice; WASD / QE — move y / x / z at that slice.
• Z/X — frame tilt; Space — A/B view; Shift — camera preset; mouse drag orbit, wheel zoom; Backspace reset; Enter advance after stabilization.
• Mobile: on-screen slice and move grids.

Architecture

Vanilla JS modules: timer, tokenizer, display; CSS variables for typography. Keyboard: Space play/pause, arrows for prev/next word. Privacy: processing stays in the tab; hromp only serves static assets.

Files

index.html, style.css, map.js, data/countries-110m.json. The map redraws the terminator continuously for the viewer’s “now.”

What you see

The world map fills with night shading on the side of Earth opposite the Sun; the curved terminator sweeps as time advances. Clock and date update with the visualization; scroll the page for short notes on Earth’s tilt and seasons.

Using the calculator

1. Enter a Sun diameter (any unit—outputs scale to match).
2. Read scaled planet diameters and distances from the Sun.
3. Use the second control to measure distance between any two bodies in the same model.

Deploy

Serve the file from any static root; README includes an example nginx location block for a subpath.

Model

Accel phase — user-specified ramp time. Cruise — remaining distance at max speed. Decel phase — user-specified ramp down. Total time is the sum—useful for rough ETA when acceleration matters (not constant-speed-only).

Inputs

1. Total distance (miles or km).
2. Maximum speed (mph or km/h).
3. Time to accelerate from 0 to that speed; time to decelerate back to 0.
4. Submit to see total trip duration across all three phases.

Data & credits

Digit file from calculat.io. Conceptually inspired by the classic Am I in Pi? toy.

Using the app

Choose month, day, and year; submit to search the digit stream for that eight-digit MMDDYYYY pattern. The UI loads π in chunks and reports the first offset if found (or that it does not occur in the bundled range).

View options

HUD Top menu picks which WCA face is “up” (persisted in localStorage); camera distance rotates with the choice so the perspective stays corner-like. Notation and solver stay standard (U = white on +Y in the model).

Purpose

Makes Russell’s analysis of denoting phrases—existence/uniqueness conditions, primary vs secondary occurrence, knowledge by description—readable without a PDF reader, while optional ELI layers scaffold the logic for students.

Credit

Teaching copy credited to Amy Reynolds (UNC-Chapel Hill); English spelling article credited to Sarada Mauck (Iowa State) in-page.

What you get as a user

• Alerts — Opt-in email and/or app push when a scheduled check finds the threshold exceeded.
• Context — Framing is data-driven (current vs long-term norm), not a single thermometer reading in isolation.
• Action — Campaign copy and merch tie the anomaly to visible solidarity (shirt) and community list (optional location).

Implementation notes

Backend: Flask API (subscribe/unsubscribe, device tokens, /api/check-temperatures, logs). Mobile: React Native/Expo + Firebase push. Ops: Cloud Scheduler triggers checks; threshold and frequency configurable (stricter in dev). hromp’s /too-hot/ page summarizes the project for the main site; live app is on its2hot.org.