Slick-C

Slick-C is the proprietary, C-like macro and extension programming language built into SlickEdit, a long-running commercial programmer’s editor. It occupies an unusual position among programming languages: it exists not as a general-purpose language for building applications, but as the language in which an editor extends and—to a remarkable degree—implements itself. Much of SlickEdit’s functionality, from its built-in commands to its dialog forms, is written in Slick-C, and the language’s full source ships with the editor so that users can study and reshape the tool they work in every day.

In spirit, Slick-C is to SlickEdit what Emacs Lisp is to Emacs: a deeply embedded extension language whose source code is open to the user and whose runtime lives inside the editor. Where it differs is in its lineage—instead of a Lisp, Slick-C borrows the syntax of C and C++, making it immediately legible to the working programmers who are its audience.

History & Origins

SlickEdit was first released in 1988 as a character-mode (text-mode) editor for MS-DOS and OS/2. It was created by J. Clark Maurer, who founded the company—originally named MicroEdge, Inc.—the same year. Before starting MicroEdge, Maurer had been a programmer at IBM, where he is credited with developing a widely used internal IBM editor known simply as “E.” That heritage of building editors for programmers carried directly into SlickEdit.

From its early days, SlickEdit was designed to be extensible, and Slick-C is the language that made that possible. The precise moment Slick-C was introduced as a distinct, named language is not separately documented in the surviving public record; it is best understood as having originated alongside the editor and matured with it. By the time the GUI-era Visual SlickEdit was being reviewed in the late 1990s, Slick-C was firmly established as the editor’s macro language—described in a 1998 Linux Journal review as a language “very close to” C++ whose .e macro source files compiled into binary .ex files.

From MicroEdge to SlickEdit

For its first decade and a half the company traded as MicroEdge, Inc. During the GUI era the product was branded Visual SlickEdit, a name that appears on versions through roughly v6. In the early-to-mid 2000s (the exact year is not firmly documented, but it falls between approximately 2001 and 2006) the company was renamed SlickEdit, Inc., and the “Visual” prefix was eventually dropped, returning the product to the name SlickEdit. The company remains independently operated and is still led by its founder.

What Slick-C Is

Slick-C is a macro and extension language, not a standalone application language. Its purpose is to drive, customize, and extend the SlickEdit editor:

• Syntax derived from C/C++. Slick-C reads like C: braces, semicolons, if/while/for, functions, and a C-style preprocessor. This was a deliberate choice—the editor’s users are programmers who already know C-family syntax.
• Compiled to bytecode. Slick-C source files (.e) are compiled by a built-in compiler into binary bytecode files (.ex) that are executed by a runtime embedded in the editor. This compile-to-bytecode model is comparable to how Emacs compiles Emacs Lisp, and it lets the editor load and run extensions quickly.
• Self-hosting. A large portion of SlickEdit—including built-in commands and its forms-based UI—is itself written in Slick-C, and the source is shipped with the product. Editing and recompiling that source is a supported way to change how the editor works. (The lowest-level core of the editor is written in C/C++; Slick-C sits above it.)

Design Philosophy

A few principles distinguish Slick-C and the SlickEdit approach:

A familiar language for a programmer’s tool. Rather than inventing a novel syntax or adopting a Lisp, SlickEdit chose C-family syntax so that its users could extend the editor in a language they already read fluently. The barrier to writing a first macro is low precisely because the language looks like the code being edited.

The editor is open to its user. Shipping the Slick-C source of the editor itself reflects a philosophy that a power tool should be inspectable and modifiable. A user who wonders how the Beautify command works can read its Slick-C source—and change it.

Bytecode for responsiveness. Compiling macros to .ex bytecode keeps extension code fast to load and execute inside an interactive editor, where latency is felt directly.

The Slick-C Language

Paradigm

Slick-C is fundamentally a procedural language. It centers on functions (commands and macros), control flow, and structured data, in the manner of C. Community references note that Slick-C does not provide a traditional class-based object-oriented model (it has structs rather than classes), so it is most accurately described as procedural rather than object-oriented—though, as an evolving language embedded in a commercial product maintained for decades, its exact feature set is best confirmed against current SlickEdit documentation.

Typing

Slick-C has a notably hybrid type system. Alongside conventional C-like static types, it supports typeless (untyped) variables, an approach reminiscent of REXX. From REXX it also draws string-handling sensibilities. In practice this means a Slick-C programmer can declare strongly typed values where that is useful, while also working with flexible, typeless variables for quick scripting—a pragmatic blend suited to editor automation, where some tasks want rigor and others want brevity.

A flavor of the syntax

Because Slick-C is C-derived, a simple command-defining macro looks much like a small C function:

1
2
3
4
5

// A trivial Slick-C command that inserts text at the cursor
_command void hello_world() name_info(',')
{
   _insert_text("Hello, World!");
}

The exact built-in functions and command annotations are specific to SlickEdit’s runtime, but the surface—braces, types, function calls—is immediately recognizable to anyone who has written C.

Influences

Slick-C’s dominant influence is unmistakably C and C++, from which it takes its syntax, preprocessor, and overall feel. Its typeless-variable model and string orientation reflect the influence of REXX. There is no documented evidence that Slick-C went on to influence other programming languages—as an editor-embedded extension language, its impact has been felt within the SlickEdit ecosystem rather than across the wider language landscape.

Evolution

Over more than three decades, SlickEdit—and with it Slick-C—has tracked the evolution of the programming world:

• Character-mode to GUI. SlickEdit began as a DOS/OS2 text-mode editor and moved into the GUI era as Visual SlickEdit, with OS/2 support continuing through early 4.x versions.
• Cross-platform breadth. The editor expanded onto Windows, Linux, macOS, and commercial Unix platforms (such as AIX, HP-UX, and Solaris). Specific platform support has changed across releases and is documented per version by the vendor.
• IDE integration. With SlickEdit Core (reportedly available by around 2008, when version 3.3 was promoted), the SlickEdit editing engine was brought into the Eclipse IDE as a subscription plugin, extending its reach to developers working in that environment.
• Product tiers. In 2014 the line was split into SlickEdit Pro and a more limited SlickEdit Standard.

Throughout these changes, Slick-C has remained the editor’s extension language, and the practice of shipping its source with the product has persisted.

Current Relevance

SlickEdit remains actively developed. The latest major version, SlickEdit 2025 (version 30), was released on November 2, 2025, with a maintenance release (v30.0.1) following on March 5, 2026. The company, SlickEdit, Inc., continues to operate independently. Slick-C is still the language users reach for to customize the editor, automate editing tasks, and read or modify the editor’s own behavior.

It is a niche language by design—you will not build a web service or a mobile app in Slick-C—but within its niche it remains relevant and in use, supported by an established commercial product and an enduring community of power users.

Why It Matters

Slick-C is a clear, long-lived example of a powerful idea: an editor that is extensible in a real programming language, and largely written in that same language. This self-hosting design—shared in spirit with Emacs and Emacs Lisp—turns the editor from a fixed tool into a programmable platform whose behavior is open to its users.

By choosing C-family syntax rather than a Lisp, SlickEdit made that platform approachable to mainstream programmers, lowering the cost of writing a first macro and inviting users to inspect and reshape the editor’s own source. For more than thirty years, Slick-C has quietly demonstrated that an extension language need not be exotic to be deep—and that a commercial editor can be both a polished product and an open, hackable environment built in the very language it hands to its users.