A macOS desktop app built with Electron to import photos and videos from cameras and SD cards.
I lost the import flow I liked when I cut my subscriptions, so I built
the one I actually wanted. It is opinionated on purpose: date-patterned
folders, keepers flagged before the copy, duplicates skipped. It does
not try to replace anything else in the kit; it exists so the import
step is certain.
Logo
The mark and the icon it ships under.
The mark.
The app icon.
Features
Auto-detect volumes: Cameras and SD cards detected on mount
EXIF metadata: Read date, camera model, lens, and dimensions
Folder patterns: Organize imports by YYYY/YYYY-MM-DD or custom patterns
Duplicate detection: Skip files that already exist at the destination
Pick / Reject workflow: Flag keepers and rejects before importing
Parallel imports: A worker pool copies files concurrently instead of one long queue
Background auto-updates: The app updates itself quietly between launches
Light & dark themes: Follows system preference
Install
Download from
GitHub Releases.
Every push to main builds a fresh alpha. macOS only.
Build from source
git clone https://github.com/juanmnl/importer.git
cd importer && npm ci
npm start # dev mode
npm run make # build DMG + ZIP
Node 20+ · macOS · TypeScript + Electron ·
MIT License
Status
Shipped and in use; it's how photos get off my cameras. Signed and notarized macOS builds on GitHub Releases, built in CI. Open source under MIT.
Brand and design system consulting for
Uwazi v2, the open-source human rights documentation platform by
Huridocs, used by 150+ organizations worldwide. Engaged November 2025 to January 2026 for the brand; back since March 2026 across four tracks at once: the platform UI redesign, a new AI agent panel inside it, a rebuild of the marketing site, and a full rebrand with the launch video to announce it.
The Idea
A tribute to the people who do the work of memory: archivists, researchers, and the materials they've worked with for centuries. Paper, ink, the impression of a letterpress. Calm and editorial by default, color held back for where it counts.
The thinking
Uwazi is one codebase serving 150+ organizations, from large legal teams to two-person archives, many of them non-technical and working in hard conditions. A loud brand would have fought the content, which is often evidence of the worst things people do to each other.
So the system gets out of the way. Editorial by default, monospace for the record, color held back for the few places it has to mean something. The letterpress idea gave it a reason to be quiet without being cold.
The harder constraint was that it had to survive being implemented by other people. It ships as tokens and patterns a small open-source team can hold in their heads and apply without me in the room.
Logomarks
The logo is the wordmark above. These are the marks that stand in for it when the wordmark cannot.
App icon
Rounded square for OS surfaces
Symbol mark
Stamp form for compact uses
Palette
Named for the press. Three for ink and stamp, three for paper stock.
Ink #1A1A1A the letterpress
Seal #E8432A the stamp
Carbon #00B4F0 the copy
Vellum #F5EED7 warm stock
Parchment #F5F0E8 cool stock
Paper #FFFFFF the margin
Type
Uwazi
Roboto Mono · brandAa Bb 01
The quiet record of what happened, who said it, and when.
Inter · interfaceAa Bb 01
Roboto Mono carries the wordmark, a quiet nod to monospaced records. Inter does the day-to-day reading.
Brand World
The rebrand extends past the logo into a full art-directed visual language, an homage to print, ink, and paper.
Duotone field. Place as evidence.Stacked record. The archive itself.Halftone burst. Moments of attention.Dispersed cube. The mark broken open.
In product
The brand carried through to the surface people actually use.
Document view. The page as the primary object.Metadata. Records around the record.Dark mode. Same calm, inverted.
Status
Live as the brand and design system for Uwazi v2. In daily use across 150+ organizations documenting human rights work worldwide. The public website at uwazi.io came out of the same system, designed and built in Framer.
The work picked back up in March 2026 and has since grown into four tracks running together, August 2026.
The platform UI. A redesign of Uwazi itself: library, entity view, relationships, settings, import. Shipped as a Figma design system and an interactive prototype running a real 4,400-entity corpus, with a migration kit staged to hand the components, tokens, and accessibility patterns back to the Huridocs production repo.
Ask Bert. A new AI agent panel inside the platform, designed as part of the same prototype. The newest surface in the product and the one with the least precedent to lean on.
The marketing site. A rebuild of the currently published uwazi.io in Astro and React, the full page set plus a WebGL globe. A rebuild of the live design rather than a redesign of it, which is a different and stricter brief.
The rebrand. A new visual language for the whole organization, and a 38 second announcement video to launch it: ten scenes from the brand marks through to the closing lockup.
Mantel is a white-label operations platform for restaurants and bars in Ecuador. Waiters fire the order from their phone, the kitchen sees it on screen, and every sale goes out invoiced with the SRI built in. A public website with a QR menu and online reservations comes included. One system to run the floor on a Friday at 8pm.
Logo
A Georgia M, set like the menus. Ink for paper, the red for the room.
The mark, ink on paper.
The tile, red on the room.
The Idea
Software the way it should be: made to fit your room, not a system that does everything halfway. Mantel is the one place the whole night lives. And it's yours, not an account shared with a hundred other restaurants. Your own instance, in your color, your logo, your domain. El Encanto in Quito is customer zero.
The problem
A restaurant in Quito runs the night on five things that don't talk to each other: a POS rented by the month, a separate portal for the SRI billing, a WhatsApp thread for reservations, a printed menu that's wrong by Friday, and a notebook for the count at close. Nothing reconciles. The owner finds out what happened on Saturday, not during.
Most software sold here is the opposite of help: one shared cloud account, a hundred venues deep, built for none of them. You bend your room to fit the system.
I built Mantel the other way around. One instance per venue, the whole night in one place, the SRI billing inside it instead of bolted on. The bet was that an owner would rather run their own system in their own brand than rent a seat in someone else's. El Encanto proved it out as customer zero, and it's now going to other rooms.
What it does
Eleven areas, each a live view of the same night.
The floor: Live table map. Free, seated, reserved, covers at a glance.
Orders & kitchen: The comanda goes from the waiter's phone to a paperless KDS.
Cash & close-out: Open with a float, close with the count and the difference.
Inventory & cost: Multi-store stock, recipes tied to dishes, margin per plate.
Digital menu: A QR menu in your brand; 86 a dish and it's gone.
Events: A guest-chef night with its own menu; portions run out on their own.
Reservations & door: Online bookings and walk-ins, straight onto the floor.
Staff & shifts: Clock-in, the weekly rota, hours per person.
Roles & access: Ten roles, each its own view; installs as a PWA.
Reports & accounting: Sales, cost, and margin, ready for your accountant.
SRI billing: Electronic invoicing inside; close the table and it's filed.
In product
Live prototype views from the system: floor, kitchen, inventory, menu, billing, and the white-label theming.
Salón. The floor in real time: seated, free, reserved.Cocina. The comanda lands on the KDS, no paper.Inventario. Multi-store stock and margin per plate.Carta QR. 86 a dish and it disappears for guests.SRI. The bill files itself. IVA and service figured.Marca blanca. The same operation, re-themed to each venue.
How it works
Three steps, no eternal migration.
We talk: Understand the place, its zones, its menu, how the team works a night.
We configure and deploy: Your own instance (your brand, floor plan, and menu), set up and live.
You operate: The team is in on day one and it works.
Status
Running in production in Quito. El Encanto is the first venue on it, customer zero. The white-label core is now its own build: a venue module instead of a hardcoded brand, a house theme with a brand switcher, and a fictional demo venue for showing new rooms. Being offered to other restaurants and bars, August 2026.
A wine garden in Quito. Built around small-grower bottles, food made for the table, and an outdoor garden that doubles as the dining room.
A full engagement: name, brand, strategy, the website at elencanto-uio.com, on-site pieces (menus, signage, the little stuff that touches a guest), social media and photography for the place, and the operations app the team uses to run service.
The Idea
A warm dark room. A hand-drawn mark in cream like ink on a coaster. Wine first, then the food that goes with it, then the garden that holds both. Everything tuned to feel like a table you sit down at, not a brand you scan.
Logo
A mark and a wordmark that name what the place is.
On the room.
On paper.
Palette
Wine country at dusk. Deep browns and grass green hold the room. Gold and beige are the candlelight. Accent red is for the bottle you want to remember.
Deep Brown #4A1F1A the room
Brown #6E3C30 oak and earth
Grass #3D4A40 the garden
Gold #C9A66B candlelight
Beige #FFF6EA paper and ink
Accent #BE2641 the bottle
Type
Arboria in two weights for the words, Lindsey for the handwritten touches: chalkboard specials, a flourish on a card.
Arboria Book body
Arboria Black display
Lindsey accent
Brand World
Photography from the place: the house, the corridor, the garden.
La casona.El corredor.El jardín.
Operations app
The team at El Encanto needed something to run service. I built it with them, and it kept growing.
It started as orders in, tickets out. Now the whole operation lives in it: the floor and the kitchen, cash and close-out, inventory and recipe costs, reservations and walk-ins, staff hours and scheduling, a shared supplier directory, purchases and expenses, and the accounting behind all of it. Every sale files itself with the SRI through electronic invoicing hosted inside the app, and the monthly IVA return and the ATS annex now come straight out of the books instead of being assembled by hand.
The public website came into the same codebase too: the landing, the QR menu, and online reservations ship from the repo and deploy on their own, replacing the original Framer site.
Building from scratch means we can shape it to the room instead of fitting the room to someone else's POS.
Web client: React + Tailwind, mobile first, runs on whatever device is closest to the host
API: Hono on Node with WebSockets for live order state
Printing: 80mm comandas, pre-cuentas, and SRI receipts straight from the browser to the thermal printer
Data: Postgres with Drizzle, fully typed, with the tax math covered by tests
In product
The whole flow, start to finish: a waiter takes the order, the kitchen sees it, the table sees a bill, the night closes out.
Mesero. Orders into the system.Cocina. Tickets land, get marked done.Cuentas. Splits and totals.Caja. End of the night.
Status
Brand and site are live. The operations app runs the room every service and keeps growing, deep in the accounting side as of August 2026. The white-label version of it is Mantel.
A Mac app I'm building for the way I actually work. I run two or three Claude Code sessions at once, often on the same repo, each one delegating to subagents. In separate terminals that means constant window-switching, no view of who delegated to whom or what any of it costs, and agents tripping over each other's changes.
Operator is the place I launch and watch them from. Each session runs in its own embedded terminal, every tool call and subagent shows up live on a timeline, and each agent works in its own git worktree so nothing collides.
Logo
A field of dots pulling into a circle: many agents, one center.
The mark.
The dock icon.
The thinking
The first instinct with a tool like this is to wrap the agent: proxy its traffic, install a runtime, own the session. I didn't want that. The moment Operator becomes something you install into the loop, it can break the loop.
So it stays a pure observer. It pins each session's id at launch and rebuilds the timeline from Claude Code's own transcripts. Nothing is installed, there's no global config, and if Operator isn't running the agents work exactly as before. Even permissions stay where they were: Claude Code asks in its own terminal, and Operator never intercepts.
Features
Projects as the unit: Sessions group under the repo they belong to. Each project carries its own agent roster (model, effort, and permissions per lane), a task backlog agents pick up on launch, and a moodboard, and every agent is told at spawn which siblings are already running
Agents that work as a team: Each lane launches with a role charter (implement, review, research, QA) and hands tasks around through the Operator lane, which routes work to the best-suited lane and does the job itself when none fits. A dispatch lands even when the target is idle: Operator launches that lane with the task as its opening brief, tells the sender how it landed, and logs every handoff per project. The roster board shows each role's current task, ordered however you drag it
Agent library with per-task models: A visual editor over your .claude/agents/*.md. The point is choosing which model runs each agent (Haiku for extraction, Sonnet for general work, Opus for hard reasoning) with cost and speed hints right where you pick
Live orchestration timeline: Every session's tool calls and subagent delegations as they happen, nested by who spawned whom, with a ticking duration on the running tool and elapsed time on the finished ones. Rebuilt from Claude Code's own transcripts, so nothing gets installed
Console, Chat, and Preview views: The raw terminal, a document-style chat with a real composer (image attachments, model and effort controls, slash commands), and a live preview of the app being built that finds the session's dev servers on its own, where pinned annotations go back to the agent as a punch list
Isolated worktrees and fan-out: Each agent gets its own git worktree, so parallel agents on one repo never collide. Dev-server ports are reserved per working directory, so their local servers don't either. Fan a single task out across several agents at once, each badged so the group reads at a glance
Task, diff, merge as one loop: Every task remembers which lane and worktree produced it, so when it completes its diff is one click away, with Merge or Discard inline. An optional per-project check command runs on completion and stamps a pass or fail on the task row
Usage and cost dashboard: A token-level view of what's driving usage, plus a per-model breakdown of input, output, cache, cost, and API vs wall time, with agents grouped by project and identified by lane
Pick up where you left off: Open sessions save continuously to a crash-safe store. Relaunch and resume the exact conversation, reopen clean, or resume a whole project in one action, every previously open agent coming back. The sidebar works as a project shelf: groups collapse, reorder, and close as a unit
Command palette: Cmd+K reaches sessions and Operator itself: switch views, open a diff, launch any idle lane, start a queued backlog. Cmd+N for a new session, Cmd+1–9 to switch. Drop an image on the window to paste its path, click a link in the terminal to open it
How it works
Operator pins each session's id at launch (claude --session-id <uuid>) and tails its transcript to rebuild the timeline live, so it stays a pure observer of the sessions it starts, with nothing installed and no global config.
Permissions are handled by Claude Code itself in the terminal, as usual; Operator doesn't intercept them. A claude you run yourself in iTerm or VS Code is completely unaffected.
Stack
React 19, Vite, and Tailwind on the front, a Tauri 2 (Rust) backend behind it. portable-pty with an xterm.js WebGL renderer for the embedded terminals, and a transcript tailer for the timeline.
Status
In active build, at v0.13.1 as of August 2026. The source is private, but signed macOS builds are public. This site is maintained by agents running inside it.
TERMINUS v3 · juanmnl industries last login: tue aug 05 · 23:41 > work 01 operator 02 mantel 03 ryms > open 01
terminus9600 baud · caps
Description
An interactive terminal in a browser. Type commands to move through the site, change themes, or load a game. The whole thing pretends to be a CRT from 1985 and most of the time you forget it isn't.
A tribute to my first computer, a Commodore 64, and to the command lines I grew up reading.
Logo
A terminal window the size of a favicon, phosphor still on.
The mark.
Screens
The portfolio routes you can navigate by command or by URL.
home · the promptabout · who I amwork · employmentprojects · case studies
Also: skills, contact, and cv. Type the name or click a menu item.
Games
Type the name at the prompt and play. The frame stays in character. On a phone, a Game Boy-style touch controller slides in below the screen so the games play without a keyboard.
snake · don't bite yourselfasteroids · vector ships, vector rocksinvaders · faster every wavequito-runner · my city, with weapons
Themes
Six to choose from: blackvoid, crt, hydra, mr-pink, synthwave, and untitled. Type theme at the prompt to cycle, or pick one by name.
Stack
Vite + vanilla TypeScript. SVG filter for the CRT barrel distortion. CSS scanlines and color tokens per theme. No frameworks.
Status
Live at terminus.juanmnl.com. Done and playable; it gets a new game or theme when the mood strikes.
A fasting tracker for the Apple Watch. I fast most days and wanted something that lived on my wrist: start a fast, glance at the ring, see what my body is doing, and log it without reaching for my phone. Most fasting apps are bloated and want a subscription. This one does one thing.
The logo doubles as the interface: the mark fills bottom-up as the fast runs, so it reads the second you raise your wrist. Pick a preset, watch it fill, and learn what your body is doing in each phase as the hours pass.
Logo
The mark is the interface: it fills bottom-up as the fast runs.
The mark, at rest.
The watch icon.
The thinking
Every fasting app I tried wanted an account, a subscription, and my phone in the loop. A fast is a start time and a goal; the tracker should live where the glance happens. So Fastrack is watch-only by design. No iPhone app, no accounts, no analytics, nothing leaves the device.
The other bet was making the brand do the work. The mark, stacked bars clipped to a circle, is the app icon, the complication glyph, and the progress gauge itself. One shape carries the whole app.
Features
Quick-start presets: 12:12, 13:11, 16:8, 18:6, 20:4, 24h, or a custom length. One tap starts the fast
Logo gauge: The mark itself is the progress display, filling bottom-up in silver as the fast runs
Phase education: A live read on the metabolic phase you're in, from digesting to deep ketosis, with the next milestone counting down
History and streaks: A calendar of past fasts you can edit day by day, current and longest streak, and weekly trend charts
Schedule and reminders: Optional phase and goal alerts plus a daily start reminder, local notifications only
Weight log: Optional body-weight tracking through Apple Health, with edit and delete for logged entries
Complications: A corner complication and a Smart Stack card with live fast status
Fasting phases
The physiological milestones the app surfaces while a fast is running.
0 to 4h, Digesting: Blood sugar rises, insulin active
4 to 8h, Post-absorptive: Blood sugar stabilizing
8 to 12h, Early Fasting: Blood sugar drops, fat burning begins
12 to 14h, Metabolic Switch: Ketone production starting
14 to 18h, Fat Burning: Ketosis ramping up
18 to 24h, Autophagy: Cellular cleanup accelerating
24h and up, Deep Ketosis: Growth hormone elevated
Design
Monochrome at its core, derived entirely from the logo: black, white, and greys on a pure black canvas with a subtle film grain. Four selectable accent themes (Graphite by default, plus Ember, Fern, and Tide) layer a single hue over that base; surfaces and tracks stay grey. Liquid Glass surfaces for the controls, SF Rounded throughout. Secondary actions live below the fold, so the gauge always owns the screen.
Stack
SwiftUI on watchOS 26, standalone, so it runs without the phone. Swift Charts for the trends, HealthKit for an optional weight log, local notifications for the reminders.
Status
In active build, July 2026. The landing site is live with the privacy policy, and the App Store listing is next. Private repo for now.
A component library for agentic interfaces, written as one file of plain CSS. Panels, live rows, tool-call lines, streaming carets, token meters, model badges. No build step, no dependencies, nothing to install. You link a stylesheet and write HTML.
It came out of Operator. Its landing page had a whole system buried in it that I kept rebuilding by hand every time I needed a new screen, so I pulled the system out and made it droppable.
Logo
A session panel reduced to strokes. The library in one glyph.
The mark.
The thinking
The rules are bans, not preferences, and they are the reason the system survived a full rebuild. State reads as a dot, a tint, and a word, never a glow. The dot never pulses. Motion only ever means a state change, so idle interface holds still. Mono is data, sans is speech. Agents are square, humans are circles.
The other decision was to stay a guest. Every token is prefixed and lives on a .dm root instead of :root, so a host page that owns its own background, accent, border and radius cannot break a mounted subtree, and the library cannot squat the document it is dropped into.
Status
Moved into its own repo on August 1, 2026, with the token layer, the components and the composed demo scenes shipped. Still mine, still moving. A public demo embed will land here when there is one to link to.
