FoxPro is dead. Now there is FoxPro again.
This new edition of Visual FoxPro, called FoxDev Studio, moves past the two-gigabyte limit that stopped the original software, while holding on to the same language. It sits upon a foundation that has not been frozen since 2007. The outcome is a language frozen at version 9, now running again without any need for a full rewrite.
The Old Limit
The software stopped its version numbering at 9, and its architecture is limited to 32 bits. Because of that, a table cannot hold more than two gigabytes, a memo file is likewise capped at two gigabytes, and a lengthy report can exhaust memory on a machine with plenty still available. These limits are not the result of licensing choices made by anyone. Instead, they come from signed 32-bit numbers baked into the code that handles file operations.
FoxDev Studio runs entirely in 64-bit. Every file offset is handled in 64-bit, and no table is actually brought into memory at all, which means a .dbf file that once stopped working can now keep going into the hundreds of gigabytes. There is one catch to keep in mind: once a table grows past two gigabytes, it cannot be opened again in Visual FoxPro. If you still work in both systems, that becomes a one-way door.
The foundation of the build is a language that was frozen in 2007, reconstructed on a foundation that has never been frozen since.
The Runtime
Your Visual FoxPro program was compiled into p-code and came with a runtime for executing it. FoxDev Studio repeats that structure: a compiler and a bytecode interpreter, made in Rust and compiled to WebAssembly, so one machine runs your code wherever the application runs. The editor checks what you type against that same compiler, so what it underlines and what the runtime refuses cannot drift apart.
The runtime is newly composed, fast to launch and self-contained. It openly acknowledges the areas it has not yet explored, and it fills in those gaps by asking Visual FoxPro itself how things are meant to work, rather than depending on a reference page and hoping it matches.
The Form and the Bridge
A program in motion is a thread. When it requires something from the outside world (a message box, a modal form, the next record) it does not reach out and pause; it gives way, and the task is carried out while the machine steps away from the stack, with the answer handed back. That is why MESSAGEBOX halts your program without freezing the window behind it, why READ EVENTS waits without spinning, and why SetFocus can fire GotFocus, and Init can run while a form is still being built, in the order FoxPro always did it.
React draws the interface from a live tree of objects, which holds the properties you would expect. Each object watches only itself, so changing THISFORM.lblGreeting.Caption to cMsg repaints just one label rather than the whole form. On a crowded screen, that is the difference between instant and sluggish.
A single tree is what the designer shapes, one stage before the finish. No second model stays in step with the first, so the form and its designer never begin to tell separate stories. The build avoids that trouble by shaping the tree itself, rather than keeping a copy.
The 32-Bit Problem
The .fll file is a 32-bit image, and every single process within a 64-bit application is 64-bit, which means the application itself cannot open one. Instead of informing you that it is impossible, SET LIBRARY TO launches a small 32-bit process whose sole purpose is to hold your library, with the runtime communicating with it. The calls are synchronous, since a program may call into a library in the middle of an expression, and an answer arriving later would not fit the request. It was measured against real libraries: the encryption library, FoxTools, and libraries built from Microsoft’s own API samples.
There is no 64-bit requirement for the bridge: a DECLARE … DLL statement connects to a modern library in the same process, and automation objects are reached as they have always been reached. The old path remains open; it simply is not the only one any more.
The Code You Already Wrote
What you have composed retains its original meaning entirely. FoxScript merely builds on top: a mechanism that lets you pass a block to something else to execute later, along with a method for responding to a web request from the code that already understands your business.
&& your old add-in libraries load just as before
SET LIBRARY TO “vfpencryption71.fll” ADDITIVE
LOCAL oServer
oServer = FoxScript.Http.CreateServer()
oServer.Get(“/api/v1/customers/:id”, LAMBDA(req, res)
LOCAL lnId
lnId = VAL(req.Params(“id”))
SELECT * FROM customer WHERE cust_id = lnId INTO CURSOR c_cust
IF RECCOUNT(“c_cust”) > 0
res.Status(200).Json(FoxScript.Data.CursorToJson(“c_cust”))
ELSE
res.Status(404).Json(‘{“error”: “Not found”}’)
ENDIF
USE IN c_cust
ENDLAMBDA)
oServer.Listen(8080)
READ EVENTS
That platform runs on the identical runtime that your forms do. The queries, the cursor and the library call are standard FoxPro tools; what FoxScript adds are the lambda and the server, both without requiring a separate language or a service sitting next to it. The keywords and the HTTP API are each set out in full.
The Build and the Schedule
FoxDev Studio runs 64-bit from top to bottom. All file offsets are treated as 64-bit, and tables are never read into memory, which means a .dbf file that once stopped dead can now carry on into the hundreds of gigabytes. There is one limitation worth noting: a table that has grown beyond two gigabytes will not open in Visual FoxPro again.
A pre-release build of the project is published on GitHub, rebuilt from every push to main nightly. The build is unsigned, which means the first launch prompts you to confirm. The documentation covers every part of the product, including the features that have not yet been built. The rough order of the work that is planned and mapped out is also included.
| Step | What It Is | Where It Runs |
|---|---|---|
| Compiler | Rust, compiled to WebAssembly | Every machine |
| Runtime | Reads tables in place | Every machine |
| Fiber model | Handles message boxes and modal forms | Every machine |
| .fll bridge | Small 32-bit process | Behind the scenes |
| FoxScript | Adds lambdas and HTTP servers | On the same runtime as forms |
What This Actually Means
The build keeps your projects, forms and tables the same way they were. It does not rewrite them, nor does it twist them into a new shape through conversion. It simply opens the folder you point at, and what is inside is what you see, exactly as it was.
What is being promised is real, and it is supported by the design of the build itself. The runtime asks Visual FoxPro how things should operate, and then conforms to its reply, which means that even a small difference in an event or an error number will not be rewritten away — it will instead be preserved.
“The limits are signed 32-bit numbers buried in the file handling, not a licensing decision anybody made.”
The build removes the memory limits that once held the original language back. A table that used to stop at two gigabytes can now move past that point and grow into the hundreds of gigabytes. This is a technical solution, but it is also a practical one: if you had data that ran into that ceiling, you now have a way to work with it once more.
The Trade-Off
Opening a table that has grown past two gigabytes is no longer possible in Visual FoxPro. Anyone still working in both will find themselves locked out, with no way back.
A small concession leads to the bridge connecting users to old libraries. Opening a 32-bit .fll file directly within a 64-bit process does not work, which means the build starts a tiny 32-bit process whose sole job is to hold your library. This bridge measures up against real libraries — the encryption library, FoxTools, and those built from Microsoft’s own API samples — and it works, though it never existed before.
The Verdict
Six years ago, this language was put on hold, and now it runs once more without needing to be rewritten. The build keeps what you wrote rather than forcing a fresh start, and it removes the memory limits that brought the original to a close. It is the sort of project that makes you glad someone cared enough to keep a language alive.
It does not erase the past. It reads it.
Source material: “Microsoft killed FoxPro in 2007. Anyway, here's FoxPro revived,” foxscript.org.
Get the Notebook.
The day's best stories and every fresh verdict, in plain English, in your inbox by seven. One email a day, no more.