FAME

FAME - Forecasting Analysis and Modeling Environment - is a proprietary time series database and the fourth-generation language that comes with it. It was built in the early 1980s for economists and financial analysts who had a specific and, at the time, badly served problem: they were not managing records, they were managing histories. Unemployment by month since 1948. A bond yield every business day. GDP by quarter, revised. The relational databases arriving at the same moment could store that data, but expressing “the year-over-year change in this series, converted to quarterly averages, from 1990 through last Friday” in SQL was miserable, and doing it fast over millions of observations was worse.

FAME’s answer was to make the time series itself the primitive. In FAME 4GL, a series is a single value. It has a frequency - annual, quarterly, monthly, weekly, business-daily - and an observation attribute that says how it should behave when that frequency changes. You add two series and get a series. You lag one and get a series. You ask for it at a different frequency and the engine applies the conversion rule the series was declared with. The date range is not a WHERE clause you write each time; it is ambient state you set once and every subsequent expression obeys.

That design is arguably why FAME outlived most other products of its generation. Forty-plus years, four changes of ownership and one rebrand later, the engine is still shipping inside a commercial FIS product, and FAME .db files are still being read by central bank modelling code.

History & Origins

Gemnet Software, Ann Arbor

FAME was created by Gemnet Software Corp, founded by Lawrence C. Rafsky - a statistician better known in academia as the co-author of the Friedman–Rafsky test - as an independent software company in Ann Arbor, Michigan, in 1981. The first version was delivered to a customer, Harris Bank in Chicago, in 1983.

The founding team was reportedly small and specialised, with distinct responsibilities for the database engine, the compiler, the graphics layer and the econometrics. That division shows in the product: FAME was never a general-purpose language that happened to have date functions. The language and the storage engine were designed against each other from the beginning.

The Citicorp Decade

Citicorp acquired the company in 1984, and the following ten years were FAME’s most formative. Development under Citicorp ownership focused on exactly two things - the time series-oriented database engine and the 4GL scripting language on top of it - and this is the period in which FAME became the default answer for economic time series inside large financial institutions. Being owned by a major bank did the product no harm in that market.

In 1994, Citicorp sold the unit to private investors headed by Warburg Pincus, and it continued as the independent FAME Information Services.

From FAME to MarketMap to FIS

The independent era produced the product’s late expansions: TimeIQ, announced in 1999 as the first product in an “OpenFame” line, offered FAME’s time-series data model as a component framework, and was subsequently described as an object-oriented Java interface that replicated much of what the 4GL could do. FAME 9.0 in 2001 lifted the ceiling on a single database from 2 GB to 64 GB - an unglamorous change that mattered enormously to institutions whose tick and daily histories had outgrown the old limit.

SunGard acquired FAME in 2004, released the 9.x line through the second half of the decade, and in 2010 merged FAME and MarketMap Data into a single MarketMap brand. FIS Global acquired SunGard in 2015, the same year FAME 11.5 shipped in November. Today FAME is the storage and analytic component of the FIS Market Data Suite. It is sold, supported and used - but it is no longer sold as a language, which is the main reason it reads as dormant from the outside.

Design Philosophy

The series is the value

The central idea is easy to state and was unusual in the early 1980s. In most languages, a time series is a data structure you build - an array plus a start date plus a frequency, with all the arithmetic written by hand. In FAME, it is a first-class object with those properties attached, and the arithmetic is built in. Adding two monthly series aligns them by date automatically. Adding a monthly series to a quarterly one is a defined operation, not a bug.

Metadata that changes the arithmetic

Every FAME series carries attributes that the engine consults when it computes. The frequency says how often observations occur. The basis distinguishes daily from business-daily data, so that a five-day-a-week bond yield is not silently treated as having weekend gaps. The observed attribute - which can be beginning, ending, averaged, summed, annualized, high, low or formula-driven - tells the system what the correct answer is when a series is converted to a coarser frequency.

That last one is the design decision worth pausing on. Aggregating a monthly stock price to quarterly by summing it produces nonsense; aggregating monthly retail sales by averaging it produces a different kind of nonsense. Most systems leave the analyst to remember which is which, on every conversion, forever. FAME attaches the answer to the series once, at creation, and then applies it everywhere. It is a small piece of type-system thinking applied to economics.

Objects, not tables

A FAME database holds objects of three classes:

and each object has a type: numeric, precision, boolean, string, date or namelist. Formulas are the quietly powerful one. A derived series - a ratio, a seasonal adjustment, an index rebased to some year - can be stored as the expression that defines it rather than as computed numbers. Update the inputs and every dependent formula is correct immediately, with no recomputation pass and no risk of a stale materialised copy.

Not a relational database

FAME was designed from scratch around dated data rather than layered over a general-purpose engine, reportedly using a B-tree structure for its storage. The trade-off is the usual one: for the queries it was built for - “give me these two hundred series over this date range at this frequency” - the expression is extremely terse and the access path is direct, and for the queries it was not built for it is the wrong tool. No published benchmark comparing FAME to a relational engine is available, so treat vendor performance claims accordingly.

The 4GL

FAME 4GL is a command language first and a programming language second - the same lineage as SAS or Stata, where you sit at a prompt, issue commands interactively, and then save the ones that worked into a script. It is case-insensitive, verb-led, and built around a set of global settings that subsequent commands inherit.

Ambient date and frequency

The most distinctive feature is that the reporting period is state, not an argument. Set the frequency and date range, then every display, report or graph that follows honours it:

-- comments in FAME 4GL are introduced with a double hyphen
open <access read> "econ.db" as econ

frequency q
date 1980Q1 to 2020Q4

display gdp
display e_eu frequency a date 2000 to 2003

The frequency a date 2000 to 2003 clause on the last line overrides the ambient setting for that one command - annual data for four years - without disturbing the quarterly range set above it. This is the ergonomic core of the language: the thing an analyst changes constantly (the window) is stated once, and the thing they write constantly (the expression) stays short.

Control flow

The language has the ordinary procedural apparatus - IF / ELSE / OTHERWISE, LOOP and FOR LOOP, TRY for error handling, and BLOCK / END BLOCK for grouping - with END closing nested structures. It also has two verbs that reveal what the language is for: REPORT and GRAPH, which produce formatted tabular output and charts as language constructs rather than as library calls. A 4GL is defined by having the deliverable built into the syntax, and for FAME the deliverable was a table or a chart of a time series.

Later releases extended this steadily: FAME 7.5 added PostScript report output along with database-level global names and formulas, and the 9.x line added 4GL debugging tooling - a DEBUG option with BREAK, STEP and CONTINUE commands in 9.3 - along with more built-in statistical and forecasting functions and new charting forms.

Reaching FAME from other languages

Because FAME’s customers were institutions with large existing systems, the host language interface (HLI) - a C API, distributed as hli.h and the libchli library, and generally referred to as CHLI - mattered as much as the 4GL itself. Practically every FAME integration in the wild goes through it:

• R - the CRAN fame package, originally developed at the Federal Reserve Board, which links FAME objects to R and handles frequency conformance
• SAS - the SASEFAME engine in SAS/ETS, which reads FAME series into SAS datasets with wildcard series selection and on-the-fly frequency conversion
• Julia - the Bank of Canada’s StateSpaceEcon stack, which opens FAME .db files through CHLI
• Python - community host-language bindings exposing the FIS MarketMap C toolkit
• Excel - the FAME Desktop add-in, whose FMD and FMS worksheet functions take the same expression, frequency and date arguments as the 4GL prompt
• Java - TimeIQ, the object-oriented framework announced in 1999

These interfaces build against a locally installed FAME, and FAME is commercial software, so the libraries are only present if you have licensed it. The published constraints are narrow and specific to each integration - SAS, for example, documents SASEFAME support on Windows and Linux Opteron hosts running FAME 11.5. Beyond what those particular packages state, we make no claim here about which operating systems or architectures FAME itself supports.

Current Relevance

FAME occupies an unusual position: commercially alive, culturally invisible. There is no public download, no free tier, no package on any registry, no Docker image, and essentially no way for a curious programmer to try the language. Its documentation lives behind vendor support. When a developer wrote an Emacs major mode for FAME 4GL, the stated reason was that syntax highlighting for the language did not exist in any common editor - a fair summary of its standing in the wider programming world.

Inside its niche the picture is different. Central banks, statistical agencies and financial institutions accumulated decades of series in FAME databases, and that data has a very long half-life. The vendor-maintained SAS engine, the Fed-originated R package and the Bank of Canada’s Julia module all exist because someone needed to get at FAME data from somewhere else. Not all of them survived: the R package was archived on CRAN in April 2023 for want of a reachable maintainer, while the SAS engine and the Julia module remain current. The typical modern encounter with FAME is not writing 4GL; it is reading a .db file that someone wrote 4GL against fifteen years ago.

What has genuinely eroded FAME’s position is not a competitor product but the commoditisation of its core idea. pandas gives a Python programmer a DatetimeIndex, automatic alignment on arithmetic, and resample() with a choice of aggregation - for free, with an enormous ecosystem attached. R’s xts and zoo do the same. Purpose-built time series databases - InfluxDB, TimescaleDB, kdb+ - cover the high-volume end. FAME’s distinguishing capability in the 1980s is now table stakes.

Why It Matters

FAME is a clean demonstration of what a domain-specific language buys you when the domain is chosen well. Its designers looked at what economists actually did all day, decided that the unit of work was a dated history rather than a row or a number, and built both the language and the storage engine around that single commitment. Everything characteristic about FAME - the ambient date range, frequency conversion as an operator, the observed attribute, formulas stored as expressions, REPORT and GRAPH as keywords - follows from it.

It is also a reminder of how durable data outlives fashion in tooling. FAME changed hands four times, its brand was absorbed into someone else’s product, and it never acquired a community in the sense that word now implies. But the abstraction was correct, so the files are still readable, the interfaces are still maintained, and the engine is still running. Most languages from 1981 cannot say as much.

The ideas, meanwhile, escaped entirely. Anyone who has written df.resample('Q').mean() and had the dates line up without thinking about it is using the model FAME committed to four decades ago - just without paying a licence fee for it.