Tango

Tango is a visual Web application development language and server, built in 1995 by EveryWare Development Corp. of Mississauga, Ontario. Its premise was that connecting a SQL database to a Web page should not require knowing SQL, HTML or CGI. You drew the application as a vertical tree of icons - search this table, if that condition, loop over these rows, return this HTML - and the pieces of HTML hanging off each icon were filled in by a tag language of <@ASSIGN>, <@CALC> and <@VAR> meta tags. It is one of the earliest examples of what would later be called low-code Web development, and it arrived a year before Active Server Pages and in the same year as the first release of Allaire’s Cold Fusion.

It is also, as programming-language history goes, an unusually well-travelled artefact. It was sold three times, renamed three times, and is still commercially available in 2026 under its fourth name. The encyclopedia lists it as TANGO; the product’s own manuals spell it Tango, then Witango, then TeraScript.

What a Tango application actually is

A Tango application file - extension .taf, stored as XML from Tango 2000 onwards - is not a script. It is an ordered tree of actions, each with a name, an icon and a set of parameters, executed top to bottom unless a control action says otherwise. The Studio’s action palette is small enough to list in full:

That is the whole language of control flow. Notably there is a Branch action - a jump to another named action or action group, which the Studio helpfully keeps pointing at the right target when you rename or move things, and which makes non-trivial Tango applications read rather like a flowchart with gotos.

Each action can carry three blocks of HTML as attributes:

• Results HTML - appended to the accumulated output after the action runs.
• No Results HTML - substituted instead, when a Search, Direct DBMS, Script, File or External action returns nothing. The manual is explicit that you get one or the other, never both.
• Error HTML - returned immediately if the action fails.

A fourth attribute, Push, flushes everything accumulated so far to the browser when that action completes and then continues - streaming output, in 1990s clothing.

The result-accumulation model is the whole execution model. There is no page being rendered; there is a buffer that actions append to, and a Return action that ships it. A Search action’s Results HTML is implicitly repeated per row, which is how the language does iteration over query results without a loop construct.

The meta tags

Inside those HTML blocks lives the part of Tango that is recognisably a programming language. The syntax is deliberately HTML-shaped:

<@TAG ATTRIBUTENAME="ATTRIBUTEVALUE">

The @ after the opening angle bracket is the only thing distinguishing a meta tag from an HTML tag, and the manual’s rules are pleasantly precise about the rest: attributes are always named so their order never matters; line breaks are allowed anywhere a space is; no space is permitted around the =; and tags are case-insensitive, so <@CALC EXPR="3+7">, <@Calc expr="3+7"> and <@calc Expr="3+7"> are all the same tag. The vendor’s current marketing describes the language as “a rich script language of around 200 tags”.

Assignment is a tag:

<@ASSIGN NAME="foo" VALUE="123456" SCOPE="user">

and so is reading:

<@VAR NAME="foo" SCOPE="user">

Scopes and the @@ shorthand

Variables are not lexically scoped; they live in named, server-managed scopes. The Programmer’s Guide documents request, user, application, domain, system and cookie scopes, with abbreviations (usr, sys) and a precedence order used when you omit the scope. An <@ASSIGN> without a SCOPE attribute searches request, user, application, domain and system in that order for an existing variable of that name and assigns to the first one it finds - creating it in the default scope only if none exists. That is dynamic scoping with a session store bolted on, and it is exactly as much of a footgun as it sounds.

Because <@VAR NAME="homer" SCOPE="domain"> is unbearable to type inside an attribute value, the language provides a shorthand:

<@VAR NAME="homer">          @@homer
<@VAR NAME="homer" SCOPE="domain">   @@domain$homer

@@scope$name is the idiom you see in essentially all real Tango code, and it is the closest thing the language has to a distinctive visual signature. Sessions were first class from early on: the Witango_UserReference token that identified a user scope is the same parameter that turns up in the 2003 buffer-overrun advisory.

Calculation

Arithmetic is walled off inside <@CALC>, which has its own expression parser:

<@CALC EXPR="3+7">

returns 10. It supports six arithmetic operations - *, /, %, ^, +, - - parentheses, mathematical and string functions, logical and comparison operations, sub-expressions, and a PRECISION attribute controlling decimal places. It also has its own private variables, single letters A through Z, which the manual warns are “only applicable to <@CALC> and do not work with <@ASSIGN> or <@VAR>” - a second, tiny variable namespace living inside the expression language. A num() function converts hexadecimal (0x), octal (0) and binary literals, and the manual notes drily that passing it a decimal number “either yields an error or an incorrect result”.

Conditionals outside the action tree use the same expression grammar:

<@IF EXPR="@@fred > @@barney" TRUE="true!" FALSE="alas">

Arrays

For a tag language, Tango’s array support is surprisingly complete. Arrays are two-dimensional and are ordinary variable values:

<@ASSIGN NAME="initValue" VALUE="1,2,3;4,5,6;7,8,9;a,b,c;d,e,f;g,h,i">
<@ASSIGN NAME="array2" VALUE="<@ARRAY ROWS='6' COLS='3' VALUE=@@initValue CDELIM=',' RDELIM=';'>">

They slice with a wildcard subscript - @@array2[*,2] is a one-column array of every value in column 2 - and there is a family of set-like tags to go with them: <@ADDROWS>, <@DELROWS>, <@DISTINCT>, <@FILTER>, <@SORT>, <@INTERSECT> and <@UNION>. Query results are arrays, so the same operators work on data pulled from a database. Later versions added DOM manipulation tags (<@DOM>, <@DOMDELETE> and relatives) for the XML work Tango 2000 introduced.

Note the nesting in the example above: a meta tag inside an attribute value inside another meta tag, with the inner tag’s attributes switched to single quotes. Real Tango code nests three or four deep routinely, and the guide’s own cookie example runs <@TOGMT> around <@SECSTOTS> around <@CALC> around <@TSTOSECS> around <@CURRENTTIMESTAMP> to express “expires in one week”. This is the language’s least defensible property, and everyone who used it knew it.

The architecture

Tango was always three programs rather than one, and the split survived every rename:

• Studio (originally Tango Editor) - the visual development environment, which queries the database schema so tables and columns can be dragged into actions, and which ships Builders: wizards that generate a complete search, list, detail, add, update or delete form with its HTML.
• Application Server - the runtime, sitting between the Web server and the databases, executing .taf files.
• A Web Analyzer (formerly Bolero) on Windows, for traffic reporting.

The server connected to the Web server however the platform allowed. On classic Mac OS it was either Tango2000.acgi, talking to the Web server over Apple Events, or a WebSTAR API plug-in; on Windows and UNIX it was NSAPI, ISAPI or CGI. Databases were reached through ODBC, or by native connections to Oracle, the Mac Data Access Manager and FileMaker Pro - the last of which the Tango 2000 manual singles out as the point of the whole action abstraction, since “the abstraction of the database action from its database language (normally SQL) allows Tango to deal with desktop database systems that do not support a standard relational language”.

Extensibility went through the External and Object actions, which were frankly platform-specific: COM objects on Windows, JavaBeans everywhere, Apple Events on the Mac, DLLs on Windows, and shell-out to Perl or shell scripts via stdin/stdout on Windows and UNIX. Tango Class Files (.tcf), introduced in Tango 2000, let you write objects in Tango itself and reuse them - the language’s one concession to code organisation before Witango 6 turned a TCF into a multi-class library.

Because application files were plain XML, a Tango application built on a Mac ran unmodified on a Solaris server. In 1999 that was a real selling point, and it is why Bank of Montreal could develop mbanx on Windows NT and deploy on UNIX with, in their project manager’s words, no need “to write any additional code”.

History: four owners, three names

EveryWare, 1995-1998

Tango began as an accessory to another product. EveryWare’s business was Butler SQL, a relational database for classic Mac OS, and Tango 1.0 was the CGI plus editor that let WebSTAR talk to it - bundled with Butler and working only with Butler. The ODBC release, announced as due in January 1996, cut it loose and made it a product in its own right. Apple’s decision in May 1996 to put a test-drive copy in the Internet Server Solution 2.0 box gave it distribution, and by the 1997 Tango Enterprise releases it had grown a Windows version, direct Oracle access, server plug-ins and a customer list that ran from a national online bank to a record label to a medical school.

The positioning of that era is worth preserving because it is so recognisably modern: EveryWare called Tango an IRAD tool, intranet rapid application development, and sold it on the claim that a bank’s product managers could edit a prototype. What is now called low-code was, in 1997, called not having to hire programmers.

Pervasive, 1998-2001

Pervasive Software’s October 1998 acquisition of EveryWare - about C$16.2 million all in - bought a Web development tool for a company whose business was the Btrieve/Pervasive.SQL database engine. For a while the fit looked good: Tango 3.5 reached Solaris in February 1999 at US$6,995 a server, Tango 2000 reached Linux that December and was announced for the Mac at Macworld Expo on 5 January 2000, and Tango 2000 brought XML data types and Tango Class Files.

Then in July 2000 Pervasive restructured “to focus on its core database business”. Development and marketing support for Tango was cut, no new features were planned, and the Mac OS X port was shelved. The product had ten months left at Austin.

With Enterprise / Witango Technologies, 2001-2010

On 29 June 2001 the technology passed to With Enterprise Pty Ltd of North Sydney - hence WiTango, a rebrand the new owner attributed to trademark issues. This was the most productive phase of the language’s post-EveryWare life. Version 5.0 in January 2002 gave the server pre-emptive multitasking, a plug-in client architecture and a proper debugging story. Version 5 for Mac OS X shipped on 27 January 2003 - the port Pervasive had cancelled - at US$593 for the Studio, alongside Windows, Solaris and Linux, with POP3/IMAP4/SMTP mail integration. Version 5.5 followed, its manuals dated August 2003 and its Mac OS X installation guide February 2004.

July 2003 brought the product’s most public embarrassment: NGSSoftware’s Mark Litchfield found that a sufficiently long cookie in the Witango_UserReference parameter overwrote the saved return address, and since the Windows server installed as LocalSystem, “any arbitrary code execution will run as SYSTEM”. The vendor, notified on 13 July, shipped a fix within days.

Tronics Software, 2010-present

Tronics Software LLC of El Dorado, California acquired the suite on 1 August 2010. Witango 6 was a serious engineering effort: the Studio was rewritten from scratch as a standalone Java application for cross-platform longevity, the project file became XML, and Witango Class Files became multi-class libraries. It also cut things - COM support out of the Studio (the vendor’s reasoning: “COM has been superseded by .NET and although Microsoft has not officially removed support for COM, it is widely believed to be a deprecated technology”), native Oracle OCI data sources, and J2EE compilation, described as temporarily removed. The rollout took four months and finished on 31 March 2011, with the developer blog assessing it fairly: “In many ways, the 6.0 release is closer to Witango’s past, than its future.”

Seven weeks later, on 19 May 2011, the product was renamed a third time. Witango became TeraScript; the server became TeraScript Server and the Studio became TeraScribe. Version 7 arrived on 27 November 2013, point releases through 2016, and TeraScript 8 on 12 January 2017 - the last release announcement the vendor has posted.

Where it stands

TeraScript is dormant rather than dead, and the distinction matters. There have been no announced releases since January 2017, no new documentation, and no visible community beyond the TeraScript-Talk mailing list - whose predecessor, the WitangoTalk and TangoTalk archive, covers “over 8 years” of a user base that has long since dispersed to PHP and elsewhere. But terascript.com is up, licences are still for sale, the manuals are still downloadable, and the site is itself a live Tango application: every page ends with a footer the server writes into its own output, naming its version and reporting the request time in milliseconds.

That footer is the most eloquent thing about the language’s current state. A .taf file written in a visual editor descended from a 1995 Macintosh CGI is still, in 2026, assembling HTML row by row and pushing it to a browser.

Why it matters

Tango is the clearest surviving example of a design that the industry abandoned and then spent twenty-five years rediscovering.

Its central bet was that the hard part of Web development was not expressing logic but connecting a database to a page, and that this connection should be drawn rather than written. Every part of the product followed from that: the action tree instead of a script, the Builders that generated whole CRUD forms, the schema browser feeding drag-and-drop, the abstraction of Search/Insert/Update/Delete over data sources that had no SQL at all. The manual’s own framing - “You can create simple applications in minutes - without ever writing any code” - is the sales copy of every low-code platform sold today.

The bet lost, for reasons that are visible in the language itself. Meta tags nested four deep inside attribute values are unmaintainable; a scope system that searches five namespaces for a name is unpredictable; a visual tree does not diff, merge or code-review; and the whole thing was a licensed commercial server at US$6,995 competing against PHP, which was free. When the Web’s centre of gravity moved to open-source scripting languages, a proprietary visual tool with a proprietary file format had nowhere to stand.

What remains worth noting is the timing. Tango’s action-based server was doing session scopes, database abstraction over heterogeneous back ends, server-side XML data types, streaming partial output and reusable server-side classes before most of those were common vocabulary. It got to the right problem early, chose a visual answer, and was outlived by the text-based answers - but it was outlived while still running, which is more than most languages of its generation can say.