Avenue

Avenue is the scripting and customization language Esri (Environmental Systems Research Institute) built into ArcView GIS, the desktop geographic information system product it sold through the 1990s and into the early 2000s. Avenue let ArcView users automate repetitive spatial-analysis tasks, customize the application’s menus and dialogs, and build standalone extensions, all without needing Esri’s separate ARC Macro Language (AML) or the underlying Arc/INFO workstation software. For much of the 1990s, Avenue was the primary way GIS professionals extended desktop mapping software, and its retirement in favor of Visual Basic for Applications and later Python marked a broader industry shift away from vendor-specific scripting languages.

History & Origins

Esri’s first ArcView release, ArcView 1.0, appeared in 1991 as a lightweight, entry-level GIS viewer with only limited customization options. ArcView 2.0, released in approximately 1993, was a substantial rewrite built on the cross-platform Neuron Data toolkit, and it was this version that introduced Avenue as the product’s built-in scripting language. Avenue gave ArcView 2.0 something its predecessor lacked: a way for users to reach past the packaged menus and tools and script the application’s own behavior directly, from automating map production to customizing the interface for a particular organization’s workflow.

Avenue shipped consistently across every subsequent ArcView 2.x and 3.x release, running on the Windows, Unix, and (through ArcView 3.0a) classic Mac OS builds that ArcView supported. It remained the primary customization path for ArcView users through the rest of the decade, documented in a series of third-party programmer’s references and Esri’s own training materials, including a 1996 multimedia course (“Avenue on CD”) presented at Esri’s User Conference.

The language’s fortunes changed as Esri began building its next-generation ArcGIS product line in the late 1990s. Rather than carry Avenue and AML forward, Esri adopted Microsoft’s Visual Basic for Applications and COM automation as the customization layer for ArcGIS Desktop, a decision that let ArcGIS expose its components to any COM-aware language rather than a single proprietary one. ArcView GIS 3.3, released on 22 May 2002, was the last version of the ArcView 3.x line and the final Esri product to ship with Avenue; ArcGIS 9, which followed in 2004, completed the transition, with Python eventually succeeding VBA as Esri’s preferred scripting language for ArcGIS.

Design Philosophy

Avenue was written with one job in mind: making ArcView’s own internals directly programmable. Rather than exposing a small, fixed set of customization hooks, Esri built Avenue around an extensive built-in class hierarchy representing ArcView’s core concepts, such as Views, Themes, Tables, Documents, and geometric Shapes, so that scripts could inspect and manipulate the same objects the application’s own interface worked with. Control flow in Avenue scripts was conventional and procedural (if/then/elseif, for-each loops, while loops), but nearly every value a script manipulated, from a map layer to a selected set of features, was represented as an instance of one of these built-in classes, reached through dot-notation requests rather than free-standing procedure calls.

That combination reflected Avenue’s scope: it was never meant to be a general-purpose language competing with C or Pascal, but a purpose-built tool for automating one specific application. Scripts were written and run from within ArcView’s own development environment, and Avenue’s built-in vocabulary (its classes, requests, and script objects) was scoped entirely to GIS operations: adding themes to a view, querying attribute tables, running spatial joins, or driving the layout and printing of a map.

Key Features

• Built-in GIS class hierarchy: Avenue exposed ArcView’s own document types (Views, Themes, Tables, Charts, Layouts) and geometric primitives as a large hierarchy of built-in classes, letting scripts manipulate live map data and interface elements directly.
• Script objects and the Script Editor: Avenue code lived in Script objects, written and debugged inside ArcView’s built-in Script Editor, and could be attached to buttons, menu choices, or events in a customized user interface.
• Requests (dot-notation calls): Avenue used a request syntax (object.Request or object.Request(args)) to invoke behavior on class instances and on classes themselves, the language’s equivalent of method calls.
• Extension mechanism: developers packaged related scripts, menus, and interface customizations into ArcView extensions, which end users could load or unload to add new functionality without modifying the base application.
• Direct spatial and tabular data access: Avenue scripts could query and edit attribute tables, select and manipulate feature geometry, and drive spatial analysis operations exposed by ArcView’s own tool set.

Evolution

Avenue changed relatively little at the language level across its decade in production. The core syntax, class hierarchy, and Script Editor introduced with ArcView 2.0 in the early-to-mid 1990s carried forward through ArcView 3.0, 3.1, 3.2, 3.2a, and the final 3.3 release in 2002, with new releases mostly adding coverage for new ArcView capabilities (additional classes and requests) rather than revising the language itself. The most consequential change to Avenue’s story was external: Esri’s decision, taken as it built the ArcGIS product line in the late 1990s, to standardize on VBA and COM automation instead of continuing to develop Avenue and AML as separate, application-specific languages.

Current Relevance

Avenue has had no active development or official Esri support since ArcView 3.3 in 2002, and it does not run inside ArcGIS Desktop or ArcGIS Pro, Esri’s current desktop GIS products. Esri’s own customization languages moved on first to VBA and then to Python (via the arcpy package), which remains Esri’s supported scripting environment today. Avenue survives mainly in legacy organizations still running unsupported ArcView 3.x installations, in archived ArcScripts and third-party programmer’s references from the 1990s, and in community projects such as AVPython, which explored bringing Python-based scripting to older ArcView installations as an alternative to Avenue.

Why It Matters

Avenue is a case study in how quickly a vendor-specific scripting language can be retired once its platform moves on, even after a decade as the standard customization tool for a major desktop software category. Through the 1990s, Avenue was the language in which a large share of practical GIS automation was written: batch spatial analyses, custom digitizing tools, and organization-specific ArcView interfaces used across government agencies, universities, and environmental research centers. Esri’s shift to VBA and later Python did not just retire a language; it retired an entire generation of GIS professionals’ accumulated Avenue scripts and extensions, illustrating the migration cost that comes with proprietary, application-bound scripting languages once their vendor chooses a different direction.