Why we built Foundry

There is a specific kind of fatigue you only get from being a developer who builds. You finish a Slack message about a curl test, alt-tab to a calculator app to sanity-check an exchange rate, alt-tab to Postman to actually run the request, alt-tab to a notes file, then to a regex tester, then to a Soulver-shaped scratch file you keep around, then back to the editor — and twelve minutes later you're not sure what you opened those things for.

We built Foundry because that loop is not a workflow. It's drag.

This is the post about why it exists, what it does, and the principle holding it together: one keystroke. Everything you build with.

#The friction we couldn't ignore

For years the setup looked like this:

• A calculator app for unit conversions and tax math.
• Postman for HTTP requests.
• A snippets manager that synced through a cloud account I didn't trust.
• An app for daily notes.
• A todo app where the export format was hostile to grep.
• Three browser tabs of tools — regex tester, JSON formatter, color picker — that I rebuilt from memory every time.
• A spotlight launcher that could open apps but couldn't do anything.
• An AI chat tab pinned in a browser.

And the part I'm slightly embarrassed to admit: when I needed to "just test this real quick," what I actually did most often was alt-tab to whatever browser was nearest, Ctrl+Shift+I, paste twenty lines of JavaScript into the console, watch it run, close the tab. Nothing saved. Refresh the page and it was gone. I'd write the same six-line fetch-and-format snippet from scratch every Tuesday because the friction of opening a "real" scratch tool was higher than re-typing the code I'd written nine times that month. It was tacky. It was unstable. It was the fastest tool I had.

That confession — the fact that the fastest tool on the machine was the one with no save button, no history, and no name — is what finally made it clear something was wrong with the lineup, not with me.

A few patterns kept repeating across the rest of the stack:

The keystroke cost was real. Cmd+Tab to the calc app, Cmd+N for a fresh sheet, type the math, Cmd+C the result, Cmd+Tab back. Each transition is half a second of moving hands and three seconds of "where was I." Across four hundred switches a day, the arithmetic is honest. The software wasn't slowing me down — moving between pieces of software was.

The data was held captive. Every product had its own database, its own export format, its own cloud account. The snippet I needed in the HTTP client lived in the snippet manager. The bookmark I wanted to search lived in the bookmarks app, where the search box only matched titles. The export wasn't missing — it was twelve flavors of "here is your data in a format the next product can't read." There was no single document of "everything I work with." There were twelve documents, in twelve directories, owned by twelve companies with twelve different opinions about whether your data was still yours next year.

The trust was thinning. Every tool I depended on had been sold, repriced, deprecated, or "pivoted to AI" at least once during the years I used it. The calculator was acquired and started begging for a subscription. The notes app shipped a redesign that nobody asked for. The todo app pulled the export feature behind a paywall. Twelve roadmaps means twelve chances per quarter for someone else's business decision to break my workflow.

I'm aware this complaint sounds like a person who's too lazy to keep tabs in order. The honest version is: I did keep them in order, and the order was the problem. Twelve apps in good order is still twelve apps.

#What Foundry is, said plainly

Foundry is a desktop app you open with Ctrl+Shift+Space from anywhere on your machine. The window has a single input box. You type whatever — a calc expression, a URL, a curl command, a regex literal, a hex color, a JSON blob, an IP address, a city name, an app name, a shell command, a question for an AI — and Foundry routes it to the right tool. Twenty-six routes, currently. The route is detected from the shape of the input; you don't pick a mode.

Behind that input, the same window holds:

• Sandboxes for thirteen languages, each with their own runtime, output panel, and history.
• A calc engine that handles money, time, dates, durations, bytes, temperatures, and time zones — Soulver-style, line by line, variables persist down the file.
• A full HTTP client with environments, folders, variable interpolation, and a copy-as-curl button.
• Daily notes with per-folder scopes, streak tracking, and a markdown editor that knows how to continue a list when you press Enter.
• Todo lists with sections, subtasks, deadlines, urgency chips, and drag-and-drop that respects subtree boundaries.
• Snippets that you can splice into a sandbox at run time with a single @use:name line.
• A bookmarks vault that archives the page text so you can search bookmarks for a phrase from the article, not just a title.
• Reminders with natural-language input ("remind me in 15m to push the deploy") and OS-level notifications.
• A dashboard with twenty-eight configurable widgets — weather, world clock, RSS, stocks, crypto, todos-today, daily note, pomodoro, habit tracker, package tracker, system info, git status, embedded iframes, sandbox output pinning — laid out on a 12-column drag-and-drop grid.
• A system-wide spotlight that overlays the active monitor with the same input box, summonable from any other application.
• Google and AI Search for any questions that need to be addressed.

One state file. One export. One auto-updater that ships everything as a matched bundle.

That's it. That's the whole pitch. It is deliberately a lot of surface area, because the friction was deliberately the work between surface areas.

#The omnibar is the spine

Most "everything apps" fail because they pick the wrong central organ. They pick the list — file tree, project tree, kanban — and the user's job is to navigate that list before they're allowed to do anything. The list is bureaucracy. Foundry's central organ is a single text input that reads what you typed and decides what it means.

Type = 0.5 btc + 1200 usd in eur — calc fires. Type https://atlasum.net/blog — Foundry asks if you want to open it or save it as a bookmark. Type time in tokyo — current time in Tokyo, the offset, and how many hours ahead of you it is. Type ? cloudflare.com — HTTPS ping with status and latency. Type cmd: git status — runs the shell command, streams output. Type /foo.*bar/i — opens the regex tester pre-filled. Paste a curl one-liner and Foundry parses it into an HTTP Studio request, headers and body pre-filled. Paste the start of a JSON blob — it opens the JSON viewer. Type todo: review the migration — adds it to today's todo list, with a chip picker to override which list. Type a hex color — color studio opens with the swatch.

Type a phrase, and if it isn't a known shape, Foundry fuzzy-searches the entire workspace: every sandbox, snippet, daily note, todo, bookmark (including the captured page text), reminder, HTTP request, app on your machine. There is no folder tree to memorize. The search box is the home page.

This is the part I underestimated. I built it because I wanted one input box. I kept it because the input box turned out to be the only piece of UI that scaled with the surface area. Every new tool we added got an automatic route in. Every new piece of content got auto-included in the search. The omnibar isn't a feature; it's the architecture.

#The calc engine, because spreadsheets are a heavy answer

Open a calc sandbox and type, line by line:

1invoice = 1250 usd2tax_rate = 8.25%3tax = tax_rate of invoice4total = invoice + tax5total in eur

Each line evaluates. The result renders in the right gutter, inline. Variables persist down the file. The currency conversion fetches at the moment you ask for it; the rate footer tells you which day's ECB number it used and shows when it was last updated.

The same engine handles:

• Time durations: 2h 15m + 45m, 40h - (mon + tue + wed), 90 min in hours.
• Bytes and bits across the full SI/IEC matrix: 1 Gb to GB, 1.5 GiB in MB.
• Temperatures: 100F to C, 298K in F.
• Twenty cryptocurrencies: 0.5 btc in usd, 0.1 sol + 1.2 ada.
• Dates: today + 14 days, next friday - today, 2026-12-25 - today.
• Clock times in time zones: 8 AM CST to UTC, 12:00 PM Tokyo.

For 95% of the calculator math I do — invoice math, hosting cost projections, "what's this in EUR right now," "how many days until the renewal" — this is a tighter loop than opening a spreadsheet.

#Sandboxes, because the JS scratch file deserves a home

Foundry has full sandboxes for thirteen languages — JavaScript, TypeScript with strict-mode diagnostics, Lua, Markdown with live preview, Calc, JSON, HTML, CSS, Shell, Python, SQL, YAML (linted), .env (linted), and plain text. Each one has its own runtime, its own output buffer, its own history.

Three things make them more useful than the random scratch file you've been keeping:

• Live mode. A toggle that re-runs the sandbox on every keystroke, debounced. If you're writing a parser for a CSV and you want to see what the output looks like as you type — you do.
• Schedules. Any sandbox can run on an interval. every 5m, with an optional time-of-day window so it doesn't fire at 3 AM. The scheduler waits on idle (not done) so a long-running task doesn't get stomped by the next tick. Lifecycle events log to the sandbox's own terminal: ▶ scheduled · every 5m · window 09:00–17:00. There's a pill in the top bar that shows how many schedules are running, in standby, or errored.
• Linked snippets. Drop a // @use:fetchers line into a sandbox, and the snippet titled "fetchers" gets spliced in at run time, recursively (with cycle detection). The snippet stays in the snippet pane; it's not duplicated; updates flow everywhere.

This is the part I expected the smallest audience for and got the largest one. It turns out that "I want to test this twenty-line idea right now" is a thing every developer does dozens of times a day, and the scratch file was always a half-answer.

#HTTP Studio, because Postman is a fine product but not for this

The HTTP client inside Foundry covers what Postman covers — methods, headers, params, body, auth, environments, folders. The variable interpolation works the way you'd expect: {{api_base}}/users/{{id}} resolves at send time, and the resolved value is shown inline on hover. Folders carry their own variable maps that override the environment. Saving as curl is one button.

What it has that Postman has historically not: it lives next to your snippets, your sandboxes, your daily notes, and your bookmarks, in the same window, under the same hotkey, exporting to the same single state file. When you copy a curl command from someone's Slack and paste it into the omnibar, it builds an HTTP Studio request from the curl args. When you save a request, it's a row in a folder, not a row in some account on a server somewhere. When you run it, the JSON response comes back as an interactive tree where every key click copies its dot path.

This is the only category in Foundry where I'll openly say a competitor exists and is good. Postman is good. It's also not what I wanted, because I wanted one window.

#Daily notes, todos, snippets, bookmarks, reminders

These are the surfaces that didn't deserve a whole separate app, but every tool I've ever used made them their own app. Foundry rolls them in.

Daily notes are the one surface I underestimated. Per-date journal, multiple "scopes" (work / personal / scratch / whatever you define), full-text search across every note ever, and a streak badge so you know how many consecutive days you've actually written something. The textarea continues lists when you press Enter and indents/outdents with Tab. There's a "Today" button. There's a search box. The notes round-trip into the same export as the rest of your workspace.

Todos support what I always wanted them to: sections, nested subtasks, per-list deadlines with urgency chips (overdue, today, soon, future), per-task due dates with the same chips, hide-done, and drag-and-drop that respects subtree boundaries — drag a parent and its children come along. There's a "migrate unfinished" button that sweeps the unchecked items into a fresh list and leaves the checked ones behind, so you can carry over Monday's incomplete work to Tuesday without duplicating the done work.

Snippets support markdown and code modes, tags, slugs, starring, and the @use: directive that splices them into sandboxes at run time. The same snippets are searchable from the omnibar. The same snippets export with everything else.

Bookmarks archive the page text. When you save a URL, Foundry fetches the page, pulls the meta tags and favicon, and stashes up to 5,000 chars of readable body text. When you search, you're searching the body, not just the title — the same way "I remember an article about X" actually works in your brain.

Reminders are the small one I miss every time it's missing. Type remind me in 15m to push the deploy. The notification fires in 15 minutes through the OS. Type remind me every Monday 9am to review the on-call list and it recurs. Type remind me on 2026-06-01 at 15:00 to renew the domain. There's a snooze, an acknowledge, a delete. There's a pill in the top bar that pulses when something is awaiting acknowledgement.

None of these are heroic individually. The compound is.

#The dashboard, because the new-tab page deserved better

The home pane is a 12-column drag-and-drop grid. Twenty-eight widgets, each configurable, each resizable. You compose your own dashboard. Mine looks like this most days: a world clock with three zones, today's todo list, a weather widget, a pomodoro, a calendar with the month and a per-day count of notes/todos/reminders, a quick-calc widget for the live one-liner I'm always reaching for, a git-status widget pointed at the repo I'm in, a sandbox output pinned to the dashboard so I see the value of "today's revenue" or "current crypto price" or "open PRs" continuously.

Pin a sandbox to the dashboard and its output renders as a widget — text or HTML, refreshed on the interval you set. This is the feature that turned the dashboard from "decoration" to "pinboard for the small numbers I care about." Anything you can write twenty lines of code to compute, you can put on the dashboard.

#Mini mode, split view, the system-wide spotlight

Three quality-of-life things that earn their inclusion the moment you stop noticing them.

Mini mode (Ctrl+Shift+M) collapses Foundry to a 520×420 always-on-top floater in the corner of your screen. The window saves its full bounds before it shrinks, so when you press the hotkey again, it restores exactly where it was. This is for monitoring a sandbox or documentation snippet while you write code somewhere else.

Split view runs two panes inside Foundry — any sandbox, tool, or todo list on the left, any sandbox/tool/todo on the right. Drag a tab onto the right half of the body to split. Drag a pane title onto the tab bar to undock. Resize the gutter. Swap left and right with one button.

The system-wide spotlight is the part that earns the "from anywhere" claim. The hotkey is registered globally; pressing Ctrl+Shift+Space from VS Code, from the browser, from Slack, from anywhere, summons an acrylic-blurred panel on whichever monitor your cursor is currently on. The same input box, the same routes, the same workspace search, the same AI chat. When Foundry's main window has focus, the global hotkey is dynamically released so the in-app keystroke wins; when focus shifts away, the global one re-grabs.

The detail that matters here: the panel is pre-warmed at startup so the first summon is instant. Not "fast." Not "snappy." Instant — frame-pops onto the screen with no perceptible load.

#Why this approach, instead of a million plugins

The framework competitors to Foundry are tools-with-a-plugin-marketplace. The trade-off is real: plugins solve the surface-area problem by outsourcing it, at the cost of a UX that's incoherent across plugins, a data model that's federated across plugin authors, and an update story that breaks every time a third-party maintainer abandons their corner.

Foundry is the bet that for a tight set of developer-shaped tools, integration beats extensibility. A first-party calc engine that knows about the snippet store, the HTTP environments, and the dashboard is more useful than three plugins from three authors with three different config formats. The cost is a smaller surface than a plugin ecosystem; the win is that the surface is coherent.

The architecture inside is registry-based — widgets, omnibar routes, quick-capture kinds, tool panes, calc units, validator formats are all registry entries. New entries land via the auto-updater. The bundle ships as one matched set, every component verified against a checksum before anything on disk is touched. Network drop mid-download leaves the install untouched; a mid-swap failure rolls backups back into place automatically. The update mechanism is the boring kind of careful; we wrote it once and it stays out of your way.

#The honest counter-argument

The fair version of "Foundry is too much app" is: a developer who already has a tight setup of best-in-class tools — Raycast for spotlight, Postman for HTTP, Notion for notes, Soulver for calc, Obsidian for journaling, a separate scratch IDE, a separate todo app — is paying real switching cost to come over. The tools they already use may be individually better than Foundry's individual modules. We're not promising "the best calc engine ever shipped" or "the best HTTP client ever shipped." We're promising one window, one hotkey, one state file.

The trade is real. The audience is the developer for whom the transitions between those tools are a bigger cost than any one tool's depth. For that developer, Foundry is the answer. For the developer who lives inside Postman all day and needs Postman's full feature set, the integration argument is weaker.

#What we're going to keep doing

Foundry ships matched-bundle updates. New widgets, new omnibar routes, new calc units, new languages, new tool panes — all land as registry entries in the next bundle. The system was designed to grow because we knew on day one that the surface area was the point. The roadmap is mostly more, with the constraint that every addition has to satisfy the integration test: it should know about the rest of Foundry, not be a silo dropped into the same window.

If you're the developer this post is describing — twelve tools, twelve search boxes, a daily commute through alt-tab — Foundry is the tool we built for you, because it was the tool we wanted for ourselves. It's a single keystroke away.

The tools we kept reaching for were never bad. They were good at their corner and indifferent to the rest. The cost of indifference compounds. Foundry is the bet that one workspace — coherent, integrated, governed by one hotkey and one state file — beats twenty corners that don't talk. We built it because we needed it. We're shipping it because everyone we showed it to wanted a copy.