Daniel Mangelsdorf · Melbourne · field notes from the lab

I build small models that do surprising things.

Maps that draw themselves, diffusion models trained from scratch on one GPU, a language model built from bytes up. Everything below is real output — recorded, measured, and written up.

Vector World
Generative geography
Vector World

A 33.7M-param transformer draws a map one 500 m tile at a time — here rendered as an explorable 3D suburb.

Terrain, mid-generation
Generative geography
Terrain, mid-generation

The same world at the frontier: rain over forested hills, with empty tiles waiting for the model to write them.

Outpaint
Canvas expansion
Outpaint

A from-scratch 92M-param diffusion model extends images past their borders — four candidates per step, human picks one.

TerraMind flood mapping
Earth observation
TerraMind flood mapping

A geospatial foundation model segments flood water from Sentinel-1 radar — five held-out test scenes, masks swept over raw backscatter.

LLM Maker
Language models
LLM Maker

A 97.5M-param model trained from scratch on one GPU answers in real time — every token beside the distribution it was drawn from.

Site safety detection
Object detection
Site safety detection

A fine-tuned YOLO detector finds people and their safety gear on construction sites — and spots when it's missing.

All six clips are recordings of these systems running — no mockups. Click any card for the full write-up.

ABOUT.TXT

Who's at the keyboard?

README.md

I build my own foundation models, fine-tune them, and turn them into things you can actually use.

Most of what I make starts as a model trained from scratch on my own machine — a generative map writer, a diffusion model, a language model built up from bytes — and ends as something with an interface you can poke at. The interesting part is rarely the architecture; it is finding the odd, specific problem a small model can solve beautifully, and then building the thing around it.

Built things

Shipped products

Full-stack AI products built from scratch — each with the architecture and the decisions behind it.

LIVE DEMOPROJECT_01~/projects/chatbot-factory/widget.ts

Chatbot Factory Simplistic

A lightweight chatbot builder for creating embeddable AI assistants with a simple factory-style setup flow. It ships as a live app with a drop-in widget script, bot-specific configuration, and a clean interface for adding conversational AI to external sites.

#Next.js#AI Chatbot#Vercel#Widget#TypeScript
> Open the app

◆ KEY DECISIONS

Distribution
Drop-in widget script. Keeps integration simple for static sites and modern app frameworks.
Hosting
Vercel deployment. Fast previews and production deploys make it easy to test bots in real sites.
UX
Simplified setup flow. The factory pattern turns chatbot creation into a repeatable configuration task.
Reuse
Bot-specific ids. Multiple assistants can share the same widget runtime while loading their own configuration.

◆ PRODUCT FLOW

01
Paste Your Site

The user enters their website URL and Chatbot Factory starts from the public pages they already have.

02
Generate Preview

The app scans key pages, learns the business context, and builds a working chatbot preview before anything is installed.

03
Tune & Approve

The owner reviews the assistant, adjusts the setup, and confirms it is ready to answer real visitor questions.

04
Copy & Deploy

Chatbot Factory provides a small embed script that can be pasted into the site, taking the chatbot from preview to live widget in minutes.

Need an embeddable AI assistant? I build chatbot products that can be configured once, embedded quickly, and reused across customer-facing websites.

> get_in_touch
PRIVATE REPO · DEMO ON REQUESTPROJECT_02~/projects/raw-photo-editor/index.ts

RAW Photo Editor

A non-destructive RAW photo editor that runs in the browser and as an Electron desktop app — LibRaw compiled to WASM for decoding, a WebGPU pipeline written in WGSL for true-HDR preview, and gain-map (Ultra HDR) JPEG export. Every feature is driveable programmatically by an AI agent; the GUI is a thin layer over that same API.

#WebGPU#WGSL#WASM#Electron#TypeScript#HDR
> Request a demo

◆ KEY DECISIONS

Agent-first
The API is the product. Every feature works headlessly; Playwright drives the same surface for agent-driven end-to-end tests, and the GUI is a client of it.
Compute
WebGPU over canvas filters. Real colour-managed HDR processing needs GPU compute — WGSL shaders give per-pixel control the 2D canvas can't.
Portability
One codebase, two shells. The Chromium browser build and the Electron desktop build share the pipeline; desktop adds filesystem access, nothing else forks.
Decode
LibRaw → WASM in a worker. Battle-tested native decoding without a server round-trip — files never leave the machine.

◆ PIPELINE

01
Decode

LibRaw compiled to WebAssembly decodes any supported camera RAW in a Web Worker — validated end-to-end on a Sony A7RII corpus — keeping the UI thread free.

02
Adjust

A Lightroom-style non-destructive adjustment set. Edits are a recipe over the original file, never baked in, so every change can be revisited.

03
Render

A WebGPU pipeline written in WGSL renders the working image with a true-HDR canvas preview on displays that support it.

04
Export

Gain-map ("Ultra HDR") JPEG export: one file that renders HDR on capable screens and degrades gracefully to SDR everywhere else.

Working on browser-based imaging? I build GPU-accelerated, local-first media tools where the hard parts — decoding, colour, HDR — run client-side.

> get_in_touch
PRIVATE REPO · DEMO ON REQUESTPROJECT_03~/projects/data-insight-advisor/index.ts

Data Insight Advisor

A privacy-first web app for understanding tabular data and choosing the right ML model — entirely in the browser. Upload a CSV, Excel or JSON file; DuckDB-WASM profiles it in a Web Worker, the app visualises it with plain-language insights, and a pure-TypeScript engine recommends model families with fully explainable 0–100 suitability scores. No data ever leaves the tab, and there is no AI model at runtime — every recommendation traces back to a statistic and a rule.

#DuckDB-WASM#TypeScript#explainability#client-side ML#data profiling
> Request a demo

◆ KEY DECISIONS

Privacy
100% client-side. DuckDB-WASM plus a pure-TypeScript engine means the tool works on confidential data by construction, not by policy.
Trust
Rules, not a model. There is no AI at runtime. Each recommendation decomposes into a base score and named rules grounded in the user's own statistics.
Honesty
Says when data is weak. If no column meaningfully predicts the target, it reports that instead of inventing confidence.
Quality
Tested like a product. Vitest unit suite, Playwright end-to-end runs, and schema validation over the entire model encyclopedia.

◆ FLOW

01
Upload

CSV, Excel or JSON lands in DuckDB-WASM inside a Web Worker — with type detection and correction. No backend, no accounts, nothing uploaded.

02
Explore

Automatic profiling and charts with plain-language insights about distributions, missingness, and relationships in the data.

03
Recommend

The user picks a goal; a rule engine scores 20 model families and 44 variants against the actual dataset, 0–100, with every adjusting rule shown.

04
Learn

A 64-entry model encyclopedia, schema-validated in CI, browsable on its own — each entry scored live against the uploaded data.

Drowning in tabular data? I build explainable analysis tools that meet data where it lives — including when it isn't allowed to leave the building.

> get_in_touch
LIVE DEMOPROJECT_04~/projects/councilmate/app.py
Screenshot of CouncilMate AI

CouncilMate AI

A RAG-powered AI assistant that helps Melbourne residents navigate city council services — from waste management and parking permits to pet registration and community events. Scrapes and processes real council data, then answers questions with grounded, cited responses.

#Python#RAG#FastAPI#ChromaDB#Next.js#Scrapy
> Try the demo

◆ KEY DECISIONS

LLM
Claude API. High-quality reasoning for nuanced council policy questions.
Vector Store
ChromaDB. Lightweight and embeddable — ideal for document-scale council data.
Backend
FastAPI + Pydantic. Async API with typed request/response models for reliability.
Data Pipeline
Scrapy + Playwright. Handles both static pages and JS-rendered council content for comprehensive coverage.

◆ ARCHITECTURE

01
Scrape

Scrapy + Playwright crawl City of Melbourne pages and PDFs, extracting structured content.

02
Process & Index

Documents are chunked, embedded, and stored in ChromaDB with metadata for fast retrieval.

03
Route & Retrieve

User queries are routed to the right domain. Top-k relevant chunks are retrieved from the vector store.

04
Generate

Retrieved context is injected into the prompt. The LLM produces a grounded answer scoped to council services.

Need a domain-specific AI assistant? I design and build RAG systems that turn messy real-world data into reliable, grounded answers.

> get_in_touch
FIELD_NOTES.LOG

WRITING & BUILD NOTES.

Technical deep-dives on how things were built, plus living documentation on what's being built right now.

◆ BLOG — DEEP DIVES
> all_posts
● WIKI — LIVING NOTES
> all_docs
TRANSMIT.SH

Contact

AI solutions engineering and technical pre-sales — scoping systems, building them, and explaining them to the people who have to buy them. Melbourne, Australia.

$ mail: daniel@mangelsdorf.au
$ linkedin: /in/daniel-mangelsdorf
$ github: @dannysheesh
$ huggingface: @PeterRabbit
$ _█