Yoix

Yoix is a general-purpose, procedural scripting language whose interpreter is written entirely in Java. Richard Drechsler and John Mocenigo created it at AT&T Labs - Research to build the graphical front end of a production fraud management system. It became open source software, with its first external release in November 2000. Yoix reads like C, borrows its GUI component names from Java’s AWT and Swing, and takes its drawing model and some of its internals from PostScript. The name is pronounced like the English word “yoicks”.

Yoix is an early example of a design that became common: a small, generic runtime installed once on the client, running application scripts that are downloaded from a web server on demand. The authors built and ran this model for AT&T in the late 1990s, before Java Web Start existed and while browsers were still too unreliable for all-day production work.

History and origins

A fraud-management GUI before Y2K

According to the authors’ 2006 paper in Software: Practice and Experience, the story begins in early 1998. AT&T’s fraud management group was dissatisfied with how development of a new system, required before Y2K, was going. A small team of researchers negotiated to build it by the end of the year with their own design. The front-end GUI was the hard part. It had to be a cross-platform networked client that could run for an eight-hour shift without crashing. It would be used 24/7 by hundreds of geographically dispersed users. And, at least initially, only two researchers in New Jersey would maintain it.

Browsers crashed regularly and restricted access to client resources, and Swing was still immature. So the team wrote an interpreter in Java for the client side. A standard web server, HTTP and CGI supplied scripts to the interpreter and answered its data requests. “From these design decisions,” the paper says, “the Yoix interpreter and, eventually, the Yoix language were born.”

The authors’ November 2000 introductory paper states that “since January 1999, the Yoix interpreter and its prototype implementation have been successfully powering the Global Fraud Management System (GFMS), a 24/7 system with over 500 users in several locations.”

Public release

Version 0.9.1, dated 15 November 2000, is the first external release in the project’s history file. The AT&T Research page at research.att.com/sw/tools/yoix/ was online by January 2001, and eleven more 0.9.x releases (counting lettered point releases such as 0.9.2a) followed before version 1.0 on 8 May 2002. The project was licensed at first under AT&T’s own Source Code Agreement and Binary Software Agreement. For some time, the license page noted that the OSI board had not yet ruled on whether the AT&T license met the Open Source Definition. By December 2005, current versions were licensed only under the Common Public License 1.0.

In the source README, the two authors thank AT&T Research colleagues including Rick Becker, Dave Belanger, Rob Calderbank, Rick Greer, Steve North, Daryl Pregibon and Allan Wilks. Becker gets special mention “for dropping in almost every morning for over a year”.

Design philosophy

• A Java application, not an applet. Yoix scripts run in a full Java application. The FAQ explains that the constraints on applets “would emasculate the functionality of Yoix too much,” and that adding a browser would reduce reliability.
• No reflection. Many Java-hosted languages reach Java classes through reflection. Yoix instead exposes Java features through more than 150 built-in object types that are coded by hand in the interpreter. Scripts can only use what the interpreter provides. The authors argue this lets one program work around Java’s portability bugs “one-time, behind-the-scenes” for every script.
• Write once on the server. Application scripts live on a web server and are fetched as needed, so fixing or upgrading an application means changing files on the server.
• Familiar to C and Java programmers. The syntax is C-like, the library includes libc-style functions such as printf, fscanf and strfmt, and GUI types keep Java’s names (JFrame, JButton, JTable).
• Consistent geometry. Screen coordinates are normalized to 72 units per inch, the PostScript convention, on every platform.

Key features

C-like syntax with dictionaries and named blocks

Yoix is not object-oriented, but its dictionaries group typed fields. A named block runs statements inside the scope of a dictionary or other compound object. The SPE paper explains that this, together with permissions and heterogeneous arrays, was inspired by PostScript’s dictionary stack:

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

import yoix.*.*;

Dictionary point = {
    double x = 3;
    double y = 4;
};

point {                          // named block: work inside the dictionary
    printf("distance = %g\n", sqrt(x*x + y*y));
}

Array langs = {"C", "Java", "PostScript"};
for (ptr in langs)               // for-in, added in 2.0.0
    printf("%s ", *ptr);
printf("\n");

Output:

1
2

distance = 5
C Java PostScript

Pointers without the danger

The language has pointers, the address operator &, and pointer arithmetic. The official site acknowledges the “knee-jerk revulsion” this causes, but the pointers sit on top of Java references. They can’t corrupt memory, pointers to stack data stay valid after the data is popped, and pointing past the end of a string raises a catchable Yoix error. Attributes such as @sizeof and @offset report on them:

1
2
3

String word = "yoicks";
Pointer p = word + 2;
printf("%s %d\n", p, p@sizeof);    // prints: icks 4

Declarative GUIs

Components are declared as nested initializers, with event handlers written as functions inside them:

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

import yoix.*.*;

JFrame f = {
    String title = "Greeter";
    Array layout = {
        new JButton {
            String text = "Say hello";
            actionPerformed(e) {
                printf("Hello from %s\n", root.title);
            }
        },
    };
};
f.visible = TRUE;

Other capabilities

• PostScript-style 2D graphics: moveto, rlineto, gsave, grestore, charpath and path manipulation on top of Java2D, without PostScript’s stack-based syntax.
• Regular expressions, including the =~ and !~ match operators.
• Threads, sockets, URLs and process execution. The 2000 paper shows a two-line script that copies the AT&T home page to standard output.
• Security: -S command-line security options, SSL connections (the FAQ recommends SSL and certificate verification when scripts come over the network), and since 2.2.0 an “applet mode” that runs scripts ending in .yxs under the installed Java security policy.
• Extension modules: Java classes written to a simple API can be imported as new Yoix types and builtins.
• Compilation: from 2.3.0, a Compiler type translates Yoix functions into JVM class files.

Performance

Yoix executes each statement as it is parsed, and the authors addressed the obvious performance worry directly. The project home page published this comparison, which it says came from 100 consecutive runs of each trial on an Intel Pentium 4 2 GHz machine with 256 MB of memory under Windows XP:

These are the authors’ own figures. The page does not say which versions of Java or Yoix were used.

The 2006 SPE paper ran a broader comparison. It set Yoix 2.0.0-beta3 against Java 1.5.0_06, BeanShell, Groovy, Jacl, JRuby, Jython, Pnuts and Rhino, The tests ran under Windows XP on a Compaq Evo N1000v laptop with a 2 GHz Pentium 4 and 768 MB of RAM, with a 256 MB JVM heap, a warm-up iteration and 100 trials per test. It reports that in a GUI construction test, Yoix and BeanShell were among the five fastest languages, which were within 3 ms of each other. It also reports that Yoix was faster than what the paper calls the “natural” Java implementation (a buffered reader appending to a StringBuffer) at reading 3.28 MB of text from a process stream. The authors credit this to the tuned library routines built into the interpreter, not to faster script execution.

Evolution

Around the language, the team published a set of tools. YWAIT is a full client/server application template. YDAT is a linked data-visualization module: selecting data in an event plot, histogram or graph updates the other views. Byzgraf provides business graphics, and YChart was used for demos such as an interactive periodic table. Java requirements rose over time. The first release was written with JDK 1.1 and also ran on 1.2 and 1.3. Version 1.4.0 (November 2005) dropped Java 1.3.1, and 2.3.1 required at least Java 1.5 (the authors recommended 1.6).

Current relevance

Yoix is dormant. There have been no releases since 2.3.1 in November 2011. In 2016, John Mocenigo placed the final distribution, the source code and an archive of the old website on GitHub under att/yoix, with the note that “the Yoix project is no longer supported”. The old AT&T Research URL now redirects elsewhere, and the yoix.org domain no longer resolves.

The software still works. The 2.3.1 yoix.jar from the GitHub repository ran every sample on this page on OpenJDK 25 in September 2026. Run it with:

1

java -jar yoix.jar script.yx

Building from source requires JavaCC. The README recommends version 4.0.

Why it matters

Yoix is a well-documented example of a language that grew out of one demanding application rather than from language research. Its central idea came out of the need to keep hundreds of fraud analysts running around the clock with only two maintainers: install one generic, carefully hardened Java program on every client, and deliver the application as scripts from a web server. That anticipated much of what Java Web Start and later rich-internet-application platforms offered. Its decision to avoid reflection, and to fix portability problems once inside the interpreter, is an unusual answer to the “write once, run anywhere” problem. The authors themselves summarized that problem as “Write Once, Test Everywhere”.