MivaScript

MivaScript (also written Miva Script) is a proprietary, tag-based server-side scripting language for building web applications - above all the Miva Merchant e-commerce platform, which has been written in it since 1998. A Miva Script program is an HTML document sprinkled with <Mv...> tags: <MvASSIGN> sets a variable, <MvIF> branches, <MvOPENVIEW> runs a SQL query, <MvFUNCTION> defines a function, and anything inside { ... } in a tag attribute is an expression. Source files (.mv) are compiled by the Miva Script Compiler into bytecode (.mvc) that runs on the Empresa virtual machine, which plugs into Apache, IIS or FastCGI on Linux, Windows or macOS; page templates (.mvt) written in a simplified subset called the Miva Template Language (StoreMorph, MVT) are compiled on the fly by the same engine.

The language began life in 1993 as LEHTML, a Perl hack by David Haldy and Joe Austin for Austin’s San Diego hosting company; it was rewritten in C as HTMLScript, commercialised by HTMLScript Corporation from 1996, redesigned with an XML-style syntax by Jon Burchmore in 1997 and renamed Miva Script on 14 October 1997. It has been compiled rather than interpreted since 2002, gained SQL, MySQL and a template compiler in 2005, and is still maintained: engine 5.52 was published in August 2026, and every release of Miva Merchant up to Miva 26R2 (July 2026) runs on it.

The encyclopedia’s master list files MivaScript as dormant, and that is fair in one sense - it is a single-vendor language whose only significant application is that vendor’s product, it is never used for anything else, and its documentation has been frozen at version 5.38 since January 2023. But it is not dead in the way most languages on this site are: the engine still gets releases, it was moved to decimal floating-point arithmetic in version 5.50, arm64 Linux builds were added, and there is an active developer community around Miva Merchant that writes new Miva Script every day. It is better described as a living but captive language.

History and origins

LEHTML and Volant Turnpike (1993)

Joe Austin’s own account, written in 2013, dates the beginning to 1993, when he and his friend David Haldy wrote “the first version of HTMLScript in the perl programming language, which was called LEHTML (Logic Enhanced HTML)”. It ran under the first NCSA web server that supported CGI. Because Perl could evaluate code at run time, LEHTML had no expression analyser of its own: it simply translated an expression in a page into Perl syntax and handed it to Perl. Austin wrote a wrapper in C “that let it start off as a root process and then downgrade itself immediately to the ownership and permissions of the owner of the script file”, which was what made it safe to offer on Volant Turnpike, the hosting service he ran and later sold to Haldy.

HTMLScript and HTMLScript Corporation (c. 1995-1996)

Volant Turnpike’s users liked LEHTML enough that Austin and Ron Ahern reimplemented its syntax in C with a real expression analyser. Austin called the result HTMLScript, registered the name with the USPTO and formed HTMLScript Corporation with Troy McCasland and Derek Finley; Wikipedia dates the language to 1995 and the company to 1996, and the earliest archived HTMLScript home page - tagline “The Document is the Application”, borrowed in spirit from Sun’s “The Network is the Computer” - is from December 1996. Miva’s own corporate history likewise begins the company in 1996, which is why this encyclopedia uses 1996 as the year of first appearance: it is the year the language was first sold under a name that has a continuous line to today’s product.

Two design decisions from this period are worth recording. HTMLScript had no loops - no WHILE, no FOR - because, in Austin’s words, “servers did not have much processing power back then, and even one program that ‘ran away’ was enough to bring the whole server down. So, I did not implement a loop, which made it impossible for an HTMLScript server process to run away.” And it had a macro facility for self-executing code, which “was powerful, but it eventually had some security issues that had to be fixed when Ivo Truxa discovered ways to exploit it”. Loops arrived with the 1997 redesign, and macros were removed when the language became compiled in 2002.

Wally Owen took over development while Austin, McCasland and Finley did sales, marketing and support; Jeff Huber, a power user, ended up running most user support. The first big licence went to CyberSource, which used HTMLScript to build the Netscape Software Store and needed a version that spoke the native API of Netscape’s server - a server that “started springing memory leaks galore” under load. Austin hired Jon Burchmore to fix them.

From language to shopping cart: Big Boys Toys, KoolKat and the hosting bundle

Austin wrote a sample shopping cart called Big Boys Toys, and noticed that people were modifying the free sample to sell things rather than buying the language: “There was far more money in e-commerce then in the scripting language.” Roque Napoli wrote a proper catalogue-based store, KoolKat, and ValueWeb - specifically an executive named John Enright - became the first large host to bundle it with hosting accounts, under a bundle-licence scheme Austin adapted from his time at Imspace Systems and McCasland pitched to “every single hosting company he could find”. Austin credits ValueWeb and McCasland with essentially inventing the hosted e-commerce account.

Miva Script and Miva Merchant (1997-1998)

In 1997 Burchmore rewrote HTMLScript with a syntax he and Austin developed “with the help of some people from SoftQuad, using the emerging XML standard” - the <MvIF EXPR="{ ... }"> style the language has kept ever since. The new engine still accepted the old HTMLScript syntax. Burchmore then wrote KoolKat’s replacement, which became Miva Merchant.

The name changed on 14 October 1997. “HTMLScript” was a marketing problem - people who did not know what HTML was tried to pronounce it as a word - so Austin and Finley went looking for a new one. In the foreign-language section of a San Diego bookstore, with his visiting German friend Boris Slawik, Austin picked up How to Read and Write Egyptian Hieroglyphics, whose first example word was “cat”: a milk basin (“mee”) followed by a quail (“waa”). Since KoolKat had been marketed as “an electronic (cat)alog” it seemed a neat fit, and when Slawik could not pronounce “waa” and kept saying “va”, Miva was born; Austin registered miva.com and filed the trademark that day. According to Wikipedia the company was formally renamed Miva Corporation in 1998, the year Miva Merchant 1.0 shipped; versions 2.0 and 3.0 followed in 1999 and 2000 and Miva Merchant 4 in 2001. (Miva’s own “History of Miva Merchant” video compresses this: it dates HTMLScript to 1995 and places the rename to MivaScript in 1998, alongside Merchant 1.0; Austin’s first-hand account of 14 October 1997 is followed here.)

Design and features

Tags, expressions and output

Miva Script is embedded in HTML. Everything that is not a <Mv...> tag is sent to the browser as-is (subject to the file’s STANDARDOUTPUTLEVEL, which controls whether plain text and HTML outside tags are emitted); everything inside { } in a tag attribute is an expression. Tags come in paired form (<MvIF>...</MvIF>, <MvWHILE>...</MvWHILE>, <MvFUNCTION>...</MvFUNCTION>) and stand-alone form (<MvASSIGN>, <MvEVAL>, <MvSKIP>). A minimal program:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

<MIVA STANDARDOUTPUTLEVEL = "text,html">

<MvASSIGN NAME = "g.name" VALUE = "World">
<MvEVAL EXPR = "{ 'Hello, ' $ g.name $ '!' }">

<MvIF EXPR = "{ s.tm_hour LT 12 }">
    Good Morning.<br>
<MvELSE>
    Good Afternoon.<br>
</MvIF>

The expression language is its own small thing: $ concatenates strings, comparison operators are spelled EQ, NE, LT, LE, GT, GE (and AND, OR, NOT), ROUND and CRYPT are operators, and a large library of built-in functions - gettoken(), substring(), indexof(), slugify(), miva_array_sort(), crypto_evp_sign(), gdImageCreate() and hundreds more - is called from inside braces.

Variables and scope

Variables are untyped, undeclared and case-insensitive, and every name carries a scope prefix:

Arrays use square brackets and structures use colons, so g.users[1]:firstname is the firstname member of the first element of g.users; <MvASSIGN> can address the same thing with INDEX and MEMBER attributes. Later versions added <MvREFERENCE> and <MvREFERENCEARRAY> for by-reference aliases and the VAR keyword in parameter lists for by-reference function arguments.

Functions

1
2
3
4
5

<MvFUNCTION NAME = "add" PARAMETERS = "num1, num2" STANDARDOUTPUTLEVEL = "">
    <MvFUNCTIONRETURN VALUE = "{ l.num1 + l.num2 }">
</MvFUNCTION>

<MvASSIGN NAME = "l.grand_total" VALUE = "{ add(l.subtotal, l.shipping_charges) }">

Functions in other compiled files are called with <MvDO FILE="..." NAME="l.result" VALUE="{ some_function(...) }">, which is the mechanism by which Miva Merchant’s modules are loaded: the store core MvDOs into a module’s .mvc and calls entry points with agreed names.

Databases: xBase, MivaSQL, MySQL and beyond

Wikipedia singles out as “one of the distinguishing features of Miva Script” its native support for dBase III-style .dbf tables with a proprietary .mvx index format. <MvOPEN>, <MvFIND>, <MvSKIP>, <MvGO>, <MvADD>, <MvUPDATE> and <MvDELETE> navigate and modify such tables record by record, which is how every Miva Merchant store up to version 4 stored its products and orders. Empresa 5 (2005) added SQL: MivaSQL is a SQL access layer over the same xBase files, and native connectors exist for MySQL (the database Miva Merchant 5 was rebuilt around), PostgreSQL (from engine 5.24) and, historically, Oracle and ODBC (ODBC support was later dropped). The idiom in a Merchant module is:

1
2
3
4
5
6
7
8

<MvOPENVIEW NAME = "Merchant" VIEW = "Products"
            QUERY = "SELECT * FROM Products WHERE code = ?"
            FIELDS = "l.product_code">
<MvWHILE EXPR = "{ NOT Products.d.EOF }">
    &mvte:Products:d:name;<br>
    <MvSKIP NAME = "Merchant" VIEW = "Products">
</MvWHILE>
<MvCLOSEVIEW NAME = "Merchant" VIEW = "Products">

Batteries for a web server

Because the language was always meant to be the whole application layer of a shared-hosting store, the engine carries a lot in the box: <MvCALL> for outbound HTTP(S) requests with certificate pinning, <MvSMTP> and <MvPOP> for mail (TLS/STARTTLS with authentication since 5.18), <MvIMPORT>/<MvEXPORT> for flat files, <MvCAPTURE> to capture output into a variable, <MvLOCALIZED> for translations, file-system, tar and XML functions, a full OpenSSL-backed crypto library (Blowfish, RSA, EVP digests and ciphers, X.509 and PKCS#7 handling), the libgd graphics library, a Redis client (5.32) and, from about engine 5.24, asynchronous tasks (<MvASYNCHRONOUS>, miva_async_sleep() and friends).

Compiled, not interpreted

Until 2002 Empresa interpreted Miva Script directly, and the version 3.9x interpreters (the last was 3.9705) were a transitional form that already implemented some version-4 features such as arrays. The Miva Script Compiler, introduced in mid-2002, changed the model: mvc file.mv produces file.mvc, a platform-independent bytecode that the Empresa 4.x virtual machine (and its desktop twin, Mia) executes. Miva promoted two benefits - performance, since code “does not need to be parsed every time the application is executed”, and closure of source code, since merchants could no longer edit (and thereby break) the store’s scripts. No benchmark figures were published for either the 2002 compiler or later releases, so no quantified performance claim can be made here. The compiler is a proper toolchain: alongside mvc there is an assembler (mvasm), a coverage tool (mvcov) and a profiler (mvprof), and options such as -p all warn about unscoped variables.

Compilability required changes: the old HTMLScript syntax and the run-time macro facility - “often considered a security risk”, as Wikipedia puts it - were removed. Miva Merchant 4.14 was the first compiled release; from that version the store’s complete source was no longer distributed, and a February 2007 forum thread titled “Open Source MivaScript” shows developers still smarting about it (“Merchant 4.13 and earlier are open source, v4.14 and later are not”). The compiler was originally a paid product; Wikipedia states that it was made free in May 2005, and it has been a free download ever since.

Templates: StoreMorph and MVT

Miva Merchant 5 (2005) introduced a page-template system, StoreMorph, and with it a second language. The Miva Template Language (MVT) is a simplified subset of Miva Script - <mvt:if>, <mvt:foreach>, <mvt:assign>, <mvt:while>, <mvt:item>, later <mvt:do> and <mvt:call> (engine 5.21) - with &mvt:product:name; entities for output. .mvt templates are compiled on the fly by miva_template_compile() inside the engine, so store designers can edit them in the admin interface without a compiler, while module developers extend what templates can do by writing Miva Script. Engine 5.20 (2014) added mvt:foreachcontinue, mvt:foreachstop, mvt:whilecontinue and mvt:whilestop, and backslash escapes in template expressions.

Evolution

The most consequential change of the whole sequence was 2002’s move to compilation, which turned Miva Script from an embedded interpreted language, editable in place, into a compiled one with a closed vendor toolchain; the second was 2005’s SQL and template layers, which are what made the language’s continued existence under three different owners (Miva Corporation, MIVA Inc. and Miva, Inc.) possible. Since then evolution has been incremental and library-driven - one or two engine releases a year adding whatever Miva Merchant needed next: SNI, asynchronous tasks, hardware security modules, Redis, decimal arithmetic.

Corporate history in brief

The language has had one product and three owners. Miva Corporation (HTMLScript Corporation until the Miva rename of October 1997; Wikipedia gives 1998 for the formal change of corporate name) was sold to the pay-per-click search company FindWhat.com, which announced the roughly $8 million deal on 3 September 2003 and closed it in January 2004; FindWhat liked the brand enough to rename itself MIVA, Inc. in June 2005 and ran the San Diego business as its Small Business division. On 6 August 2007 a management group led by Russell Carroll and Rick Wilson (Austin’s former VP of sales) bought that division and formed Miva Merchant, Inc.; MIVA, Inc. itself sold its media business and became Vertro in June 2009. Miva Merchant, Inc. bought the Miva name back and became Miva, Inc. on 3 June 2013. It remains privately held in San Diego, with Rick Wilson as CEO since April 2017, and describes its software as running on “the proprietary Miva Script language”.

Current relevance

In August 2026 the language is in a curious state: fully alive as infrastructure, entirely invisible as a language.

• Engine and tools are current. According to the docs.miva.com download pages, Empresa 5.52 is a free download for Ubuntu 20 (x64), Ubuntu 22 (arm64), CentOS 6 and 7, macOS x64 and Windows IIS 7 (x86 and x64), plus FastCGI builds for CentOS 7 and Ubuntu 20; the compiler 5.52 for Ubuntu 20, CentOS 6/7, macOS x64 and Windows, and Mia 5.52 for Windows only; the engine files are dated 13 August 2026. MivaScript 5.50 replaced binary with decimal floating point throughout - an unusual and thoughtful change for a language whose entire life is spent adding up prices.
• The platform is current. Miva 10 (September 2020) and the Miva ‘26 releases (26R1 in April 2026, 26R2 in July 2026) are Miva Script applications, and Miva’s developer documentation, training courses (“MivaLearn”) and forums are about writing Miva Script modules and MVT templates for them.
• The language reference is not. mivascript.com, the official language site, documents version 5.38 (January 2023); the 5.50 decimal change is described only on the compiler download page. The Wikipedia article, tagged for lack of sources since 2009 and for conflict of interest since 2013, still lists 5.35 as the stable release.
• Use outside Miva Merchant is negligible. Wikipedia’s understatement is that the language “is significantly less widespread than other popular web languages”; in practice it is used to extend one product. The February 2007 plea to open-source it so that it might “gain traction like PHP” went unanswered, and nothing has changed since.
• Tooling exists. The Miva IDE extension for Visual Studio Code (and a Sublime Text package), published on GitHub by Miva Professional Services and maintained by Max Hegler of Miva, provides highlighting, completion, hover documentation, go-to-definition and linting for Miva Script and MVT, including warnings about XSS-prone constructs.

Whether that adds up to “dormant” depends on what one is measuring. As a language with a community, a roadmap and users beyond one vendor, MivaScript has been dormant since the early 2000s. As a piece of software, it is maintained more actively than most of the languages on this site.

Why it matters

MivaScript is a fossil record of a road not taken. In 1993-1996, before PHP (1995), ColdFusion (1995) and ASP (1996) settled what server-side scripting would look like, HTMLScript was one of the earliest “logic in the page” languages, with a security model (the setuid wrapper that dropped to the file owner’s permissions, the deliberate absence of loops) designed for the shared-hosting reality of the NCSA-httpd era. Its XML-style tag syntax of 1997 is a direct contemporary of ColdFusion’s CFML and a precursor of the tag-based templating that JSP and later systems adopted, and the .mv -> .mvc compilation model of 2002 anticipated the “compile once, deploy bytecode” approach that PHP accelerators and opcode caches were converging on.

More concretely, it is the language of one of the first hosted e-commerce products. Joe Austin’s observation that “there was far more money in e-commerce than in the scripting language” - and ValueWeb’s decision to bundle KoolKat with hosting accounts in 1997 - describes the business model that Yahoo! Store, osCommerce hosts and eventually Shopify would follow. That Miva Merchant is still shipping on the same language nearly thirty years later, having outlived two corporate parents, makes MivaScript one of the longest-lived proprietary web languages in continuous use - and, for anyone who has ever wondered what a .mvc file on an old shared host is, this is the answer.

Further reading

• Joe Austin, “HTMLScript History and How Miva got their name” (20 March 2013) - the founder’s own account, and the source for most of the early history above
• mivascript.com - the official Miva Script reference (version 5.38), with the RELNOTE.txt engine release notes
• Miva Developer Docs: Empresa, Mia and Script Compiler downloads - current 5.52 builds and the 5.50 decimal-arithmetic note
• Miva, “History of Miva Merchant” - the vendor’s version-by-version history
• The Register, “FindWhat.Com finds $8m for Miva” (3 September 2003)
• Wikipedia: MIVA Script