NeoOffice Basic

NeoOffice Basic is the built-in macro and automation language of NeoOffice, the long-running native Mac OS X / macOS port of OpenOffice.org (and, in its later years, LibreOffice). It is not a wholly new language: it is the StarBasic / OpenOffice Basic dialect — a BASIC descendant designed for office-suite scripting — as it shipped and ran inside NeoOffice. When people speak of “NeoOffice Basic,” they mean writing Basic macros against the NeoOffice document model on the Mac, using the same Sub/Function syntax, the same Basic IDE, and the same UNO automation API that the wider OpenOffice.org family used.

NeoOffice itself was created in 2003 by Patrick Luby and Edward Peterlin at Planamesa Software, who were the first to make OpenOffice run natively on Mac OS X without an X11 server. Their port carried OpenOffice.org’s entire macro subsystem onto the Mac, which is why NeoOffice Basic is best understood as the Mac-native face of OpenOffice Basic rather than an independent invention.

History & Origins

The language at the heart of NeoOffice Basic begins with StarDivision, the German company founded in 1985 by Marco Börries that built the StarOffice suite. StarOffice gained a built-in BASIC-style macro language — StarOffice Basic (commonly StarBasic) — to let users automate the suite, in the same spirit that Microsoft Office had with Visual Basic for Applications. After Sun Microsystems acquired StarDivision in August 1999 and open-sourced the codebase as OpenOffice.org in 2000, StarBasic became widely known as OpenOffice Basic, and its automation hooks were formalized around the UNO (Universal Network Objects) component model.

NeoOffice enters the story in 2003. Two engineers — Patrick Luby (a former Sun engineer who had worked on early StarOffice Mac efforts) and Edward Peterlin — set out to give Mac OS X a genuinely native OpenOffice. An early Cocoa-based attempt, NeoOffice/C, proved unstable, so the team pivoted to a Java-integrated approach branded NeoOffice/J, whose first prototype (0.0.1) appeared on 21 July 2003. Crucially, the port did not reimplement the office suite — it adapted OpenOffice.org’s existing C++ engine to the Mac, which meant the StarBasic macro engine came along intact. From the user’s perspective, that engine is NeoOffice Basic.

Over the following years the project matured: NeoOffice/J 1.1 (June 2005), then NeoOffice 1.2 (February 2006), which dropped the “/J” suffix. The 2.x and 3.x lines tracked OpenOffice.org, and from NeoOffice 2017 onward the suite was rebuilt fully on LibreOffice, so its Basic dialect followed LibreOffice Basic. The final release was NeoOffice 2022.7 on 2 September 2023, and the project was declared no longer active in December 2023, with LibreOffice recommended as the successor.

A note on dates: The underlying Basic dialect predates NeoOffice — it grew out of StarOffice in the late 1990s. The 2003 date used here marks when that macro language first became available as NeoOffice Basic, i.e. inside the native Mac port. Where exact StarBasic introduction dates are uncertain, this page favors hedged, verifiable framing over precise but unconfirmed claims.

Design Philosophy

NeoOffice Basic inherits the design goals of StarBasic / OpenOffice Basic, which were shaped to make office automation approachable:

• Familiar BASIC syntax. Macros are written as Sub and Function routines with readable, keyword-led statements (If…Then…Else, For…Next, Do…Loop, Dim). The intent is that spreadsheet and word-processor users, not just professional programmers, can automate their work.
• Automation through an object API, not a new runtime. The language is a thin, friendly layer over the suite’s real power: the UNO API. Macros obtain service objects, read and set properties, and call methods to drive documents, cells, paragraphs, and the application desktop.
• Embedded, document-and-application scoped. Macros live in libraries attached either to a specific document or to the user’s application profile (“My Macros”), so automation travels with the file or with the user.
• Cross-platform by design. Because the same dialect runs on Windows, Linux, and (via NeoOffice) the Mac, a macro is meant to behave consistently across platforms — NeoOffice’s contribution was making that promise hold on Mac OS X natively.

Key Features

BASIC language core

NeoOffice Basic supports the standard StarBasic feature set: variables declared with Dim (with Option Explicit available to require declarations), a Variant-style dynamic type system with optional explicit types (Integer, Long, Double, String, Boolean, Object, and others), arrays, user-defined Type structures, procedures (Sub) and functions (Function), and structured control flow. A minimal macro looks like familiar BASIC:

1
2
3

Sub HelloWorld
    MsgBox "Hello, World!"
End Sub

The UNO automation API

The real reach of the language comes from UNO. Macros manipulate the running document through service objects — for example obtaining the current document model, accessing sheets and cell ranges in Calc, or text and paragraph objects in Writer:

1
2
3
4
5
6
7

Sub WriteToCell
    Dim oDoc As Object, oSheet As Object, oCell As Object
    oDoc = ThisComponent
    oSheet = oDoc.Sheets.getByIndex(0)
    oCell = oSheet.getCellByPosition(0, 0)  ' cell A1
    oCell.setString("Hello from NeoOffice Basic")
End Sub

(Object and service names follow the OpenOffice.org/LibreOffice UNO model; exact behavior depends on the NeoOffice version and its underlying base.)

The Basic IDE

Like its OpenOffice.org cousins, NeoOffice includes an integrated Basic IDE (reached through the Tools ▸ Macros menus) with a code editor, an object/library organizer, a watch and call-stack view, and a debugger supporting breakpoints and stepping. Macros are organized into modules within libraries, stored either in a document or in the user’s profile.

Macro libraries and the scripting framework

Macros are grouped into named libraries that can be shared, imported, and exported. The broader OpenOffice.org scripting framework that NeoOffice is built on also accommodates other languages (such as Python, JavaScript, and BeanShell) alongside Basic, though Basic remained the default and most documented path for end-user automation.

Microsoft Office and VBA interoperability

NeoOffice did not provide full Visual Basic for Applications support; it relied on its own Basic dialect. However, compatibility work — notably around NeoOffice 3.0 (2009) — improved handling of Microsoft Office 2007 files, including spreadsheets that carry VBA macros, which mattered to Mac users exchanging documents with Windows colleagues.

Evolution

NeoOffice Basic’s evolution mirrors the evolution of NeoOffice and its upstream base:

Throughout, the language a user wrote stayed recognizably the same BASIC-plus-UNO dialect; what shifted underneath was the engine providing it, as NeoOffice migrated from the OpenOffice.org codebase to LibreOffice.

Current Relevance

With the NeoOffice project inactive since December 2023 and its final release (2022.7) dating to September 2023, NeoOffice Basic is best regarded as a historical, end-of-life dialect. Users who relied on it are pointed toward LibreOffice, whose LibreOffice Basic is the same lineage — so most macros written for NeoOffice carry over with little or no change. In practice, the living continuation of “NeoOffice Basic” is LibreOffice Basic (and, on the OpenOffice side, Apache OpenOffice Basic).

Its significance today is twofold: it documents how the StarBasic/OpenOffice Basic automation model reached the Mac natively, and it preserves a chapter of Mac office-software history from the years before LibreOffice and modern macOS ports existed.

Why It Matters

NeoOffice Basic matters as the Mac-native expression of an entire family of office automation. The StarBasic engine — born in StarOffice, opened up as OpenOffice Basic, and carried forward into LibreOffice — gave millions of users a way to script their documents and spreadsheets with approachable BASIC syntax backed by a serious component API. NeoOffice’s achievement was to deliver that capability to Mac OS X users natively, years before official Mac builds of the suite were stable, through the persistence of a tiny team at Planamesa Software. The language a NeoOffice user wrote was, in the end, a bridge: familiar BASIC on the surface, the powerful UNO object model underneath, and a cross-platform office heritage running all the way back to 1990s Germany.