DevTools
The live workbench for Visual FoxPro.
DevTools launches your VFP 9 app with modern tooling already attached — no changes to your code — then lets you drive it from your browser: a live console, instant hot-reload, and full observability. See what your running FoxPro app is actually doing.
runs on your machine · attaches with zero app-code changes · Windows + any browser
Launch, attached
Start VFP with the tooling already wired in — one click, no edits to your application.
Drive from a browser
A live FoxPro console: run code, flip features on and off, all against the running app.
Hot-reload
Save a class or program and it reloads in the running app — no restart, no lost place.
See it run
Live call maps, memory and cursors, grouped errors, slow queries — in Grafana.
Product tour
Watch a live FoxPro app.
Five moments from a running demo app — the browser dashboard on one side, the VFP 9 app on the other, nothing added to its code.
One click, VFP starts up — tooling attached.
Hit Launch and DevTools starts Visual FoxPro with the tooling already wired in. It connects back and shows up in your dashboard in seconds — nothing added to your app.
A FoxPro console, in your browser.
Type FoxPro, run it against the live app, and the result comes straight back. Toggle features and run saved snippets without touching the app or leaving the page.
Save. It's already reloaded.
Edit a class in your editor and DevTools reloads it in the running app instantly — no restart, no clicking back to where you were. The tightest FoxPro edit loop there is.
Watch the app think.
Run a screen and its call map lights up live — which routines run, how often, who calls whom — the same way modern services are traced, pointed at FoxPro.
Vitals for a 25-year-old runtime.
Memory, open cursors and forms, an event-loop heartbeat, errors grouped into issues, and slow queries flagged when the optimizer missed them — all live.
Why DevTools
The observability every modern stack has — for FoxPro.
VFP has had no modern tooling since 2007. DevTools gives a running FoxPro app the live console, hot-reload, and dashboards developers everywhere take for granted.
Live by design
Where a static map tells you what the code is, DevTools shows you what it does — while it runs. The two are built to work together.
Zero app-code changes
DevTools launches or attaches to VFP and wires in the tooling itself. Your application source stays exactly as it is — nothing to add, nothing to remember to remove.
Modern observability, finally
Dashboards, call maps, metrics, and grouped errors — the things every modern stack has, pointed at Visual FoxPro for the first time, in one Grafana across every instance.
Safe in production
The production telemetry is one-directional: it reports what's happening, scrubbed of your data — it never sends commands into the app and never ships your records off the box.
At a glance
Built for the way FoxPro is actually run.
changes to your app. DevTools attaches the tooling itself.
to launch VFP with the console, hot-reload, and dashboards attached.
observability pillars — metrics, traces, logs, and profiles, in one Grafana.
see it as it happens — not a log file read back hours later.
Get DevTools
DevTools is in private early access.
One edition, everything included. Tell us about your app and we'll set you up.
Everything DevTools does
The live workbench, plus the observability backend that turns a running FoxPro app into something you can actually watch.
- One-click launch — start VFP with the tooling attached, no app changes
- Browser dashboard — connected instances and a live event log
- Live FoxPro console — run code against the running app
- Hot-reload — classes and programs reload without a restart
- Feature toggles & saved snippets — flip and run against the live app
- Live call maps — which routines run, how often, and who calls whom
- Runtime vitals — memory, cursors, forms, event-loop heartbeat
- Grouped errors — thousands of errors folded into a handful of issues
- Slow-query insight — queries flagged when the optimizer missed them
- Production telemetry — a safe, telemetry-only agent that reports to Grafana
- Priority support from the team that builds it
FAQ
Fair questions, straight answers.
Do I have to change my application?
No. DevTools launches or attaches to Visual FoxPro and wires in the tooling itself — your source stays exactly as it is. There's nothing to add to your app and nothing to remember to strip out before you ship.
Is it safe to run in production?
Yes. The production side is telemetry-only and one-directional: it reports vitals, traces, and errors and never sends commands into the app. It's scrubbed of your data — names, counts, and timings leave the box, never field values or records.
How is this different from Carta?
Carta is the static map — what the code is: search, call graph, ERD, impact. DevTools is the live workbench — what it does while it runs: console, hot-reload, and observability. They're made to be used together.
What do I need to run it?
Windows with Visual FoxPro 9 for the live workbench features. The dashboards run in any browser, and the observability views are standard Grafana you host yourself.
Does my code or data leave my machine?
The developer tooling runs entirely local. The optional production telemetry sends only scrubbed metrics, traces, and logs to a Grafana you control — names, counts, and timings, never the contents of your tables.