HTML/OS

HTML/OS is a server-side web programming language made by Aestiva, a small software company in Torrance, California. It first shipped in 1996. You write HTML/OS code straight into ordinary HTML pages, between << and >> delimiters. The server runs that code and sends plain HTML to the browser. The language also has its own built-in database, so a site needs no CGI scripts in Perl and no separate database server. Aestiva expanded the name as “HyperText Markup Language Operating System” and marketed the product as “the first operating system made for the Web”, but it was never an operating system. It was an interpreted language plus an engine, installed as an ordinary CGI program on an existing web server.

HTML/OS never had a large following. Aestiva sold it commercially (the 1999 retail price was $799) while free tools such as PHP and Perl took over web development. Its FAQ says so directly: “HTML/OS is a commercial product. It’s [sic] competitors are free”. Even so, the language never quite disappeared. Aestiva still built its own business software on it decades later, gave away a free engine from 2010, and a small group of developers still writes about it.

History & Origins

Overlays, 1996

According to Aestiva’s press releases, the company was founded in January 1996 to build an HTML-centred platform for the young World Wide Web. Its first product came out the same year. A 1999 release says it shipped “in late 1996 under the name ‘Overlays’”, and a 2000 release says “June of 1996”. The product was later renamed HTML/OS. The old name stayed in the language’s vocabulary: a block of code in a page is still called an Overlay, and its commands are Overlay Tags, or Otags.

Aestiva’s own chronology, published on htmlos.org around 2010, says the first engine ran on Linux and already had automatically typed variable arrays, global variable management and built-in integration with HTML. The same page says Windows and other Unix platforms were added in 1997. It puts the first embedded 4GL database and Mac OS support in 1998, and relational database features and the dbConsole database manager in 1999.

The CGI alternative, 1999-2001

By the time of the earliest press releases still online, HTML/OS had reached version 1.6 (January 1999). Aestiva pitched it at web designers who knew HTML but did not want to write CGI programs. In the 1.6 release, HTML/OS tags “are placed in HTML documents in much the same way Javascript scripts are placed within documents”, so designers could keep their usual HTML editors. Aestiva said the built-in database meant hosting providers needed no extra database product, and that the engine ran on ordinary virtual hosting accounts.

The platform list for 1.6 was Sun (SPARC and Intel), SGI IRIX, BSDI, FreeBSD, DEC Unix, Linux and Windows 95/98/NT. In April 1999 Aestiva and Tenon Intersystems announced a Macintosh version. Aestiva had ported the Unix engine to Mac OS by compiling it under Tenon’s MachTen Unix environment, and it ran in the cgi-bin folder of Tenon’s WebTen server. Aestiva’s Director of Technology, David Silverberg, said the port “was as quick as any port from one version of UNIX to another.”

Version 1.7 (July 1999) added user-defined functions and a SCRAMBLE tag for copy-protecting web software that developers sold to others. Version 1.9 (March 2001) added multi-tasking and split the product into a professional development edition and a cheaper run-time edition. Aestiva’s marketing in this period talked about “Webputing”, “server-jumping” (spreading one dynamic site across several machines) and a “NET-anywhere” build-once, deploy-anywhere campaign.

Books, H2O and Aestiva Array

In January 2002 Aestiva’s D. M. Silverberg published Advanced Web Sites Made Easy, a book-length introduction to the language. A follow-up, Advanced Web Software Made Easy, approached HTML/OS from the point of view of someone building multi-user web applications. Aestiva later posted both books as free PDFs on htmlos.org. In March 2004 Aestiva announced H2O (“HTML with HTML/OS Overlays”), a browser-based programming language built on the HTML/OS engine, available through web hosting providers and as a download. Some later descriptions call it a free, cut-down edition, but the 2004 coverage does not say so.

Aestiva’s chronology says work on Aestiva Array began in 2005, and that it was released to the public in 2007. Array is a multi-user, browser-based desktop with a file manager, programming editor, database console and background job scheduler, all running on the HTML/OS kernel. In 2008 Aestiva redefined the names: “Aestiva Array” became the engine and environment, and “HTML/OS” meant just the programming language. Aestiva’s chronology says htmlos.org was announced on 1 March 2009, and in 2010 Aestiva announced a free version of the engine. According to InformationWeek (July 2010), the free Developer Edition replaced a $5,000-per-server price and carried a commercial licence, alongside a $1,500 Professional Edition.

Design Philosophy

HTML/OS assumes the page comes first. Aestiva’s FAQ tells newcomers that “when programming with HTML/OS you think top-down. You first think about how your HTML page should look. Then you swap out the dynamic sections with HTML/OS”. The language is built around that workflow:

• Code lives inside HTML. A program is an HTML file with Overlays in it. A page with no Overlays is just a static page.
• Everything runs on the server. The engine reads the page from top to bottom, runs each Overlay, and sends pure HTML to the browser. The book tells developers to “keep client-side programming to a minimum” because browsers were unpredictable.
• No declarations, one data structure. Every variable is a table of cells, and a single value is simply a one-by-one table.
• The session remembers. Variables persist from page to page within a user’s session automatically, and HTML form fields fill themselves from variables with the same name.
• Security by default. Start-links that launch an application from outside, and variables passed in on those links, are refused until they are allowed in the Control Panel.
• One vendor controls the language. The FAQ says Aestiva “has protected the standard from outside influence since its inception in 1996”, and claims backward compatibility with code up to ten years old.

Key Features

Overlays and their placement

Where an Overlay sits in the file decides when it runs. Aestiva’s language chapter and the current Array reference describe three kinds:

An Overlay that holds a single expression displays its result, so <<TODAY>> is short for <<DISPLAY TODAY /DISPLAY>>. Overlays can appear inside HTML tags (<img src=<<myimage>>>) but cannot be nested inside one another.

A minimal page:

1
2
3
4
5
6

<html>
<body>
<<DISPLAY "Hello, World!" /DISPLAY>>
<p>Today is <<TODAY>></p>
</body>
</html>

The login example below is adapted from Aestiva’s book. It uses all three kinds of Overlay: an Underlay sends users who are already logged in straight to the menu, an Inlay prints the date, and an On-click Overlay called letmein checks the password when the form is submitted:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

<<IF ISLOGGEDIN="TRUE" THEN GOTO "menu.html" /IF>>
<HTML>
This is my web page.<BR>
Today's date is: <<DISPLAY TODAY /DISPLAY>><BR>
<FORM METHOD=POST ACTION=letmein>
<INPUT TYPE=PASSWORD SIZE=15 NAME=mypassword>
<INPUT TYPE=SUBMIT NAME=mybutton VALUE="LOGIN">
</FORM>
</HTML>
<<OVERLAY letmein
  IF mypassword="12345" THEN
    ISLOGGEDIN="TRUE"
    GOTO "menu.html"
  ELSE GOTO PAGE
  /IF
>>

The form’s ACTION names the On-click Overlay, not a script URL. Nothing passes mypassword explicitly: the form field becomes a session variable, and so does ISLOGGEDIN, which is why the Underlay on a later page can test it.

Functional and multiword Otags

Otags come in two forms. Functional Otags look like function calls and can be nested: x=LENGTH(abc_name), UPPER(LEFT("Henry Smith",5)), ADDDAYS("01/01/2000",500). Multiword Otags read like small English sentences and end with a closing word that starts with a slash:

1
2
3

COPY FILE="myheader.txt" TO myheader /COPY
MAIL mytxt TO ADDRESS="[email protected]" SUBJECT="My News" /MAIL
DISPLAY FILE="sidebar.txt" /DISPLAY

EXPAND FILE="more.txt" /EXPAND pulls instructions from another file into the current Overlay, rather like an include.

Control flow and functions

1
2
3
4
5
6
7
8

IF test THEN instructions
ELIF test2 THEN instructions
ELSE instructions
/IF

FOR NAME=i VALUE=1 TO 10 STEP=1 DO ... /FOR
FOR NAME=mycolors ROWNAME=x DO ... /FOR
WHILE test DO ... /WHILE

The second FOR form walks through a table one row at a time without any index arithmetic, which the book calls the more common style. BREAK exits a loop. Comparisons include the usual =, !=, <, > and so on, plus ~ (begins with) and ~~ (contains). Adding an extra = (==, ~~=) makes a comparison case-sensitive.

Since version 1.7 programs can define their own Otags. Parameters and LOCALS are local to the function, and recursion is allowed:

1
2
3
4
5

FUNCTION dp_nohtml(x) DO
  x=REPLACEALL(x,">",">")
  x=REPLACEALL(x,"<","&lt;")
  RETURN x /RETURN
/FUNCTION

A function defined on one page stays available on later pages in the same user session.

Variables as tables

All HTML/OS variables are two-dimensional tables. x=2 replaces x with a one-by-one table, while x[1,1]=2 changes only one cell. ROW("Larry","Moe","Curly") builds a one-row, three-column table. Database queries and CSV-reading commands return tables directly. Other details from the language chapter:

• An unset variable holds the value ERROR, which plays the part of NULL.
• Text cells can be up to 1 GB. Numbers can have up to 11 digits.
• Dates are written MM/DD/YYYY HH:MM.
• Three quote characters are allowed: single, double and caret (^...^). The caret makes it easier to store JavaScript that already contains both kinds of quote.
• @name is variable indirection: it reads or writes the variable whose name is stored in name.
• + adds numbers but joins text whenever an operand is not numeric. & always joins.

HTML forms work with these tables too. A field named myvar[2,3] fills that one cell, and repeating a field name fills successive rows.

The built-in 4GL database

HTML/OS has a database engine built in, and its databases are just files on the web server, with no database server process. Aestiva described the database language as a 4GL, in which one command does a whole operation, such as loading a record into a form. The core commands are DBCREATE, DBADD, DBGETREC, DBEDIT, DBDELETE, DBFIND and DBFINDJ (a join across two databases). You define a database’s fields in a comma-separated configuration file:

1
2
3
4

"user_name","STR","Y","50"
"user_login","STR","Y","15"
"user_startdate","DAT","Y","15"
"user_count_logins","INT","Y","2"

The four columns are field name, type, whether the field is searchable, and length. Types include STR, INT, FLT, DAT and CUR (currency; the Array 4.0 notes say it was renamed from DOL “to be less dollar-centric”). The book gives limits of 350 fields per record and 99 million records per database. Field names follow the same rules as variable names, so records move straight into variables and form fields. That is behind Aestiva’s FAQ claim that a database record editor takes “about four lines of HTML/OS code”.

Sessions, links and forks

Links inside HTML/OS keep the user in the same session with all their variables. A link can set a variable as it is clicked (<A HREF="/abc.html" NAME=X VALUE=3>), add SECURE to switch to SSL, or point at a page on another copy of HTML/OS (X:/cart.html). A link that starts with http:// leaves the environment. A FORK link opens a new session that inherits the current one’s variables, which is useful for pop-up windows. Array 4.0 added EXEC, which opens a fresh session with no inherited variables.

Evolution

The current Array reference also has sections on Ajax tags and XML processing tags. They show the language kept being extended after the 2000s, but the release dates of those additions are not documented in any source found.

Current Relevance

HTML/OS is a niche survivor more than a living platform. Aestiva’s htmlos.org still offers the free Aestiva Array engine “for Windows, Linux, and MacOS X web servers”. Its own front page admits that “this website has not been updated for over ten years,” while adding that the engine “continues to be developed”. That page says HTML/OS is the database engine behind Aestiva’s Power Office platform and the Webigami Sheets workflow product. In 2026 aestiva.com redirects to a product called Notebōrd, and it is not clear from the site how much of the old HTML/OS product line is still sold.

Independent activity centres on learnhtmlos.com. The site runs on HTML/OS itself, hosts a tag reference that identified itself as Aestiva Reference v4.89.48 in October 2026, offers free test servers, and collects user-contributed code. In June 2025 Terry Riegel posted a burst of articles there on JSON handling, HTTP requests and binary uploads in HTML/OS. The HTMLOS Yahoo group, long the main independent forum, went away when Yahoo Groups shut down in December 2019.

Why It Matters

HTML/OS belongs to the first generation of server-side templating languages, alongside ColdFusion (1995) and PHP/FI (1995). Like them, it was built on a then-radical idea: the web page itself is the program, with logic inserted into the markup, instead of Perl scripts that print HTML line by line. Some of its design choices are unusual even now:

• Every value is a table, and loops walk tables row by row.
• The database is built into the language rather than reached through SQL.
• The position of a code block in the file decides when it runs: before the page, during it, or when a link is clicked.
• Session state and form binding are automatic, with no code needed to carry values between pages.

Its history also shows why proprietary web languages mostly lost to free ones. By 2001 Aestiva said HTML/OS ran on “over twelve platforms”, and it worked on ordinary shared hosting, but it still retailed for about $800 while PHP was free. A language controlled by one small company could not build the open ecosystem that PHP, Perl and later Python and Ruby did. What remains is a well-documented example of a road the web did not take, and a small community still using it.