REBOL

On the first of October 1998, a company of a handful of people in Ukiah, California — a town smaller than most software offices — put up a download a few hundred kilobytes in size and made an immodest claim: this was not a programming language, not a scripting language, but a network messaging language, a thing that did not officially exist yet.^[1] The download was REBOL/Core 1.0, and behind the marketing was a genuinely strange idea: that the internet's real unit of exchange should not be the document but the message — a small, human-readable packet of data and code that the machine on the other end could simply understand.

The language was the life's work of Carl Sassenrath, the man who had given the Amiga its multitasking kernel thirteen years earlier. And for all its obscurity, REBOL kept turning up in the biographies of better-known things. Douglas Crockford — who gave JavaScript its second act and the world its data format — lists REBOL among the influences on JSON, calling it "a more modern language, but with some very similar ideas to Lisp, in that it's all built upon a representation of data which is then executable as programs."^[2] If you have ever exchanged data between two machines in human-readable form — and you have, today — you have used something REBOL argued for in 1998, alone, at dial-up speed, a decade early.

REBOL — pronounced reb-ol, as in "rebel with a cause" — is a backronym: Relative Expression-Based Object Language. Its community rebelled against what its maker's own site put plainly: "We rebel against the idea that modern software must be large and complex."^[3] This is the story of a language that was right about nearly everything except the two things that mattered commercially — timing and licensing — and of the stubborn, devoted community that has refused for a quarter-century to let it die. It covers what the language is and why it looks like nothing else, the Amiga mind that built it, the distributed-computing vision it shipped a decade early, the dialect idea at its core, the closed-source wilderness years, the open-source afterlife in Red and Ren-C, and how to try it today — for anyone searching what is REBOL, the REBOL language, or simply what an internet scripting language looked like before the industry decided what the internet should be.

What is the REBOL programming language?

Ask what REBOL is and even its admirers reach for a list, because it refuses the usual single-word answers. It is a dynamic, multi-paradigm language — functional, imperative, prototype-based object-oriented — that doubles as a cross-platform data exchange format: a REBOL source file is simultaneously a serialized data structure and an executable program, with no boundary between the two.^[4]

It is also famously small. Where a modern language runtime weighs hundreds of megabytes, the complete REBOL/View interpreter — evaluator, 40-odd native datatypes, networking stacks for a dozen protocols, a GUI engine, an event system, and multimedia codecs — fit in roughly half a megabyte, a binary smaller than the images on a typical web page. That was not a party trick; it was the argument. Sassenrath believed software complexity was a failure of design, and he set out to prove an entire internet application platform could live inside something you could email.

Three properties define the language more than any paradigm label:

• Everything is a series. Strings, blocks of code, lists, files, and open network ports all share one sequence abstraction — first, next, at, skip, tail, append, find, select work identically on all of them. Learn it once, use it everywhere.
• The internet is built into the syntax. REBOL gives literal notation to things other languages treat as strings to be parsed: an email address is a value of type email!, a URL is a url!, $1.99 is a money!, 12-Dec-2012 a date!, 100x50 a pair! coordinate, 1.2.3 a tuple! version number. read http://example.com fetches a web page; send [email protected] read http://example.com mails it to a friend. Both are one-liners, no libraries required.
• Code is data is dialect. REBOL programs are written in dialects — small, purpose-designed sub-languages for parsing, GUIs, drawing, security — all evaluated by the same engine, all interchangeable as data. It is the property Sassenrath himself called the language's greatest strength.^[5]

And there are no reserved keywords. if, foreach, func, print are not grammar — they are functions bound in the global context, as overridable as any name you make yourself. The evaluator reads expressions by position: a word in first position that evaluates to a function is called; otherwise words produce values. Even infix operators (+, =, >) are functions with special argument handling, not syntax. The result reads deceptively like a scripting language and behaves like something considerably stranger: a language whose grammar you can reprogram.

Functions take refinements — slash-marked optional modes that read like the dialects they are: copy/part s 8, find/match, parse/case, open/direct/binary. Your own functions declare them the same way: send/only/to is not sugar, it is how the language speaks. And scripts begin not with boilerplate but a header — REBOL [Title: "Demo" Date: 19-Oct-2026] — which is itself a dialect: a block of ordinary data describing the program, readable by any other program. The system describes itself in the format everything else uses. Uniformity all the way down.

The architect: Carl Sassenrath and the Amiga inheritance

You cannot explain REBOL's obsessions — smallness, messaging, machines cooperating — without its author's earlier masterpiece. Born in California in 1957 and raised in Eureka after the family left the Bay Area, Sassenrath was a broadcast kid before he was a programmer: electronics, amateur radio, photography, film — working at KEET, Eureka's PBS station, at thirteen, then climbing to technical director at KVIQ before college.^[6] He studied electrical engineering and computer science at UC Davis, went to Hewlett-Packard's Computer Systems Division, and in 1985 landed at Commodore — where he designed and implemented the kernel of the Amiga operating system.

That kernel — Exec — brought preemptive multitasking to personal computers at a moment when the mainstream PC ran one program at a time and the Mac cooperative-scheduled its way through the decade.^[7] Exec was a study in economy: a small kernel passing messages between components, doing more with a megabyte than rivals managed with ten.

When Commodore died, Sassenrath kept going — CDTV (the world's first CD-ROM set-top box, a precursor of DVD), ED-TV at Viscorp, set-top boxes at Videostream, senior roles at Apple's Advanced Technology Group and Hewlett-Packard, presidencies of his own Pantaray and American Multimedia. In 1996 he set aside everything else to pursue a vision he had been circling for two decades: a distributed-computing architecture for the internet, built around a language designed for it from first principles.^[8]

He founded REBOL Technologies in Ukiah in 1997 — incorporated March 1998 — deliberately far from Silicon Valley, in a Mendocino County town most famous for a brewery.^[9] The company never grew past about six people. What it lacked in size it made up in lineage: every instinct in REBOL is an Amiga instinct. An elegant kernel. Components that cooperate by passing messages. A machine — now a network of machines — that should feel small.

The detail collectors should note the side-catalog: AltME (the encrypted messaging system the REBOL community would adopt as home), MakeDoc (a plain-text authoring format that anticipated Markdown by years), WIP Wiki (among the earliest wiki engines), DevBase (a BBS for developers), NGS Forth, an Amiga Logo implementation, and Bay, a real-time motion-video editor for home computers.^[10] Sassenrath was building the modern web's furniture in a parallel universe where it stayed simple. He went on to become Principal Engineer at Roku, retiring in November 2023 — the man who made streaming-TV boxes small and cheap, of course.^[11]

The design principles: small, human, honest

Sassenrath described REBOL as experimental — not unfinished, but deliberately probing: a test of what happens when you design a language around context and symbolism rather than grammar and machinery, merging code, data, and metadata into one fabric.^[12] Its stated goals read like a manifesto against the direction of the industry: expressiveness measured in thoughts per line; programs a person can read aloud; complexity pushed out of the user's program and into the designer's problem; a runtime small enough that "does it fit" is never the question.

The discipline shows in the details. There is no package manager because the interpreter was meant to be the batteries. There is no build system because a script is data the interpreter reads directly. There is no public static void main because Sassenrath regarded boilerplate as a design failure, not a tax. Twenty-five years of software accretion has made these positions look less eccentric and more prophetic: the industry now sells "batteries included," "convention over configuration," and "infrastructure as data" as premium features. REBOL just assumed them in 1998.

An internet scripting language before the phrase existed

The REBOL/Core 1.0 launch release ran on seven operating systems on day one: AmigaOS, BSD, Linux, classic Mac OS, Solaris SPARC, and Windows 95/98/NT.^[13] Cross-platform claims were normal then as now; what was not normal was the depth of the integration. Where the era's scripting languages treated the network as a library you bolted on, REBOL treated it as syntax.

read http://example.com            ; fetch a web page
read pop://user:[email protected]  ; read your mailbox
send [email protected] read http://example.com
                                   ; mail that page to a friend
write ftp://site/file.txt data     ; upload a file
print read dns://example.com       ; resolve a name

Five lines, five protocols, zero imports. The trick underneath is the port/scheme architecture: every protocol — HTTP, FTP, POP, SMTP, DNS, Whois, Finger, daytime, TCP and UDP sockets, files, the console, the clipboard, later sound — plugs into the same series interface, so a network socket is navigated with the same first/next/insert/copy vocabulary as a string. A port is opened with open, written with insert, read with copy, closed with close — and because ports are series, your network I/O code and your string-mangling code are literally the same code. In 1998, when fetching a URL in C was a chapter of a book and Perl needed modules for everything, this was quietly radical. It remains the cleanest expression of "internet scripting language" anyone has shipped.

The model went deeper than convenience. Because every scheme is a port and every port is a series, REBOL programs composed networking the way Unix pipelines compose text — and the protocol handlers were written in REBOL themselves, so users could register new schemes by writing a port handler in a dialect. A protocol you invented last night could be read myproto://thing this morning, indistinguishable from the built-ins. The language was not merely network-aware; it was network-extensible.

Messaging, not documents: the distributed-computing vision

The official story of the web is documents: pages fetched, rendered, forgotten. REBOL's counter-story was messaging: the network as a fabric of cooperating programs exchanging small, meaningful packets — each packet itself REBOL data, loadable, inspectable, and where appropriate, executable. Sassenrath called the destination the X Internet: not the World Wide Web's read-mostly library, but an executable internet where applications live on the wire between machines.^[14]

This is why REBOL was marketed as a messaging language rather than a programming language, and why the claim, while grandiose, was technically honest. A REBOL "message" is a serialized block — the same literal format as code — so a program can mail not just text but a structured payload containing functions, objects, and dialects, and the receiving interpreter can load it into living values. mold flattens a value to its source form; load resurrects it. There is no serialization library because there is no serialization problem: the language already is its own wire format.

The flagship demonstration was the messaging itself. Sending structured data, email, files, or executable reblets (REBOL applets) between machines took single lines of code because the wire format and the language were the same thing. What the industry would later re-derive as JSON-over-HTTP, RPC stubs, and serialized object protocols, REBOL simply was: its data format was its API, its API was its language, and the language was small enough to fit inside the message.

Security was designed in rather than apologized for: the secure dialect set sandbox policy per interpreter, and reblets ran under explicit capability limits — which mattered, because a messaging language that mails code is an attack surface you either architect or ignore. REBOL architected it.

It is hard, from inside today's JSON-saturated world, to feel how contrarian this was. In 1998 the web's data formats were HTML and whatever binary protocols you could afford to implement. REBOL's bet — that readable, language-native data beats documents and stubs both — is the bet the industry eventually placed. It just placed it with braces instead of square brackets.

Dialects: the languages inside the language

If one idea survives REBOL, let it be dialecting — and let it be understood properly, because it is routinely confused with ordinary DSLs. A dialect in REBOL is not a library API, not an embedded language interpreted by strings; it is a different grammar over the same values, evaluated by the same engine, in the same memory, sharing the same datatype universe. You write a parser, a GUI, a drawing, or a config file in whichever grammar suits the domain, and the pieces interleave freely because there is only one kind of "thing" underneath.

The canonical demonstration is PARSE, REBOL's pattern-matching dialect — a recursive-descent, PEG-family parser whose rules are written as ordinary blocks:

parse "name=bob,age=42" [
    any [
        copy key to "=" skip
        copy val to ["," | end]
        skip
        (print [key "=" val])
    ]
]

The same dialect parses strings (text) and blocks (code structures) — so the tool you use to validate an email address is the tool you use to transform program source. Competitors needed a parser generator or a regex engine bolted on; REBOL programmers wrote grammars in the same file, same datatype, same brain. Long-time users will tell you parse alone justified learning the language: a readable grammar notation embedded in your program, not a separate build step.

Then there is VID, the Visual Interface Dialect shipped with REBOL/View — the piece that made journalists blink:

view layout [
    text "Name:"  field
    text "Email:" field
    button "Join" [alert "Welcome to the cult"]
]

A working GUI — layout, widgets, event handlers — in a handful of words that read like the interface they describe. VID is not code about the GUI; it is a little language for GUIs, with its own grammar (styles, layout words, action blocks) and view as its interpreter entry. Beside it sat DRAW (vector graphics — draw [line 10x10 100x80 circle 50x50 20]), COMPOSE (data templating), SECURE (sandbox policy), the function-spec dialect, the script-header dialect, rebcode (an experimental low-level bytecode VM shipped in late R2 builds) — and whatever dialects the programmer invented. A configuration file was a dialect. The argument was that humans already think in small languages — file paths, dates, money notation, email addresses — so a language should let you make them, not merely tolerate them.^[15]

User dialects are the payoff. Because a dialect is just a block interpreted under local rules, a REBOL programmer can mint a small language for any recurring problem — an email-header dialect, a deployment-script dialect, a trading-rules dialect — in an afternoon, and it plugs into everything the host language already knows. A config file written as a dialect is data: another program can load it, inspect it, transform it, and save it back without a parser ever being written. Sassenrath's argument was almost anthropological: humans never stopped inventing small languages — the telephone number, the date format, the CLI flag, the email address — so a serious language should treat dialects as the normal case, not an exotic feature.^[15]

This is the deep reason REBOL resists comparison tables. "Alternative scripting languages" is the category the market filed it under, but dialecting makes it something closer to a language construction kit with an internet socket attached — the ancestor of every "data as code as data" system since, and still the cleanest implementation of the idea anyone has put in a single coherent product.

How the evaluator actually works

REBOL's evaluation model is where the Lisp ancestry shows — and where the last generation of programmers who learned it still get quietly evangelical. There is no operator-precedence table to memorize and almost no grammar. An expression is a block of words, evaluated left to right: a word that evaluates to a function consumes its arguments and produces a value; anything else produces itself. if, loop, foreach, either are natives — functions like any you write — which is why there are no keywords and why control structures compose exactly like library calls.

The deep trick is that a block is also just data. do evaluates a block; reduce evaluates its elements and returns the results as a new block; compose builds a block with selected substitutions. So "eval" is not a forbidden back corner of the language, it is the ordinary machinery — the same machinery the dialects run on. PARSE, VID, and DRAW are, at bottom, just functions that take blocks and evaluate them under different rules. User dialects are made the same way: take a block, interpret it under your grammar. The language's famous uniformity — code as data, dialects as libraries — is not a slogan; it is what falls out when evaluation is a first-class operation on a first-class datatype.

The subtleties live in binding. Every word carries a pointer to the context it was bound in — the object, function, or global environment that gives it meaning — and bind lets you re-point them, which is how modules, objects, and dialects resolve their names. It is powerful and famously subtle: REBOL programmers talk about binding the way Lispers talk about macros, because once it clicks, metaprogramming is free, and until it clicks, bugs are bewildering.

The series: REBOL's one big idea about data

Underneath the dialects sits the design decision that makes the language cohere: the series. Every ordered thing in REBOL — string, block, list, file stream, open port — is a series: an ordered sequence of values plus a position. Where other languages gave you containers, REBOL gives you a viewpoint that walks:

s: "the internet scripting language"
s: find s "scripting"   ; position the series at the word
first s                 ; #"s" — the current element
copy/part s 8           ; "scriptin"
index? s                ; 14 — where we stand
back s                  ; step one position left

The same words — first, next, back, at, tail, head, pick, append, insert, remove, change, find, select — navigate a string, a block of code, a parsed structure, or a live TCP stream. Learn the series vocabulary once and you have learned the traversal API for the entire language. It is the kind of unifying decision that makes experienced programmers either immediately delighted or immediately suspicious, and REBOL's fans will tell you which reaction is correct.

The datatype system is the series' extrovert twin. REBOL recognizes roughly forty datatypes as literal syntax: word!, set-word! (x:), get-word! (:x), lit-word! ('x), path! (a/b), block! ([...]), paren! ((...)), string!, email!, url!, file! (%x), money!, date!, time!, pair!, tuple!, issue! (#tag), tag! (<x>), binary! (#{}), char!, object!, function!, port!, datatype! itself — the type names are values too. Numbers are numbers; emails are emails; the lexer knows the difference. It is a small thing until you have written a script that manipulates URLs, dates, and prices and noticed you wrote no parsing at all.

Objects are prototype-based — make object! [name: "x" greet: does [print name]] — and contexts are manipulated explicitly through bind, context, and construct, a taste of the Lisp/Self ancestry. Functions are made with func or function; even control words are natives in the global context rather than grammar, which is why REBOL has no reserved keywords to list in an appendix.

REBOL vs the scripting mainstream

How did it stack against the alternatives its buyers were actually choosing? Against Perl, the era's text king, REBOL traded regex for parse — slower to write a first pattern, dramatically easier to read the tenth. Against Tcl, the other "everything is a string" small language with a socket and a GUI kit, REBOL offered real datatypes instead of string-everything and dialects instead of eval. Against Python, its eventual category rival, REBOL was smaller by three orders of magnitude, more expressive at the top end — and entirely dependent on one six-person company for its runtime, where Python was already a commons. Against Java, the enterprise's answer to portable network computing, REBOL was a fraction of the size with none of the ceremony — and none of the library ecosystem, the IDEs, or the salaried evangelists.

That last asymmetry was the fatal one. REBOL's story is often told as a language that failed on merit; it did not. It is a language that lost to ecosystems — free ones — while charging for the good tier and keeping the engine closed. The technical comparisons mostly flattered it; the economic ones never stood a chance.

A REBOL program, annotated

Enough description — here is what the language actually looks like solving a real problem. A classic demo task: fetch a web server's log feed, pull out the day's distinct visitor addresses, and mail a summary to yourself. In most languages this is an afternoon; in REBOL it is an interruption:

REBOL [Title: "Daily visitor digest"]

log: read http://example.com/access.log   ; the whole file, as data
ips: copy []
parse log [
    any [
        to " " copy ip to " "              ; skip to a field, capture it
        (if not find ips ip [append ips ip])
    ]
]
send [email protected] rejoin [
    "Visitors today: " length? ips newline
    ips
]

Walk it once. read http:// returns the remote file as a string — the network as a function argument. parse runs the pattern dialect over it: copy ip captures each IPv4-shaped token into a variable; the parenthesized block is ordinary REBOL evaluated inside the rule — dialect and host language interleaved mid-pattern. find/append are the same series verbs used on strings and ports; rejoin builds the message; send is SMTP. No imports, no classes, no ceremony — the program is the size of the thought.

This is the compression REBOL people mean when they say solutions shrink from thousands of lines to hundreds. It is also the compression that makes the language hard to market: the demo looks too easy, so the observer assumes the problem was trivial, and files REBOL under "toy." It was not a toy. It was the argument, made executable.

REBOL/View and IOS: the commercial arc

The commercial strategy crystallized across 2000–2001 into a product ladder:

• REBOL/Core — the free interpreter; redistribution with applications permitted from October 2000
• REBOL/Command (September 2000, 2.0 May 2001) — the paid tier: ODBC databases, external-library calls, shell access, strong encryption; Command 2.0 advertised thirty platforms
• REBOL/View (April 6, 2001) — the free graphics build: the VID dialect, the DRAW engine, image effects, sound, and a tiny desktop environment, still inside a sub-megabyte binary
• REBOL/IOS — the Internet Operating System: a collaboration layer where every application was a networked reblet — Conference, Messenger, Contacts, file sharing — exchanged as messages between peers under a shared desktop metaphor^[16]

IOS deserves a closer look, because nothing like it has been shipped since. Inside an IOS world — a hosted, permissioned collaboration space — every application was a reblet: a small REBOL program plus its UI, synchronized as messages between the members of that world. Conference gave you live meeting rooms; Messenger gave presence and chat; Contacts, Links, and a shared file system filled out a desktop that existed between machines rather than on any of them. There was no app store and no deployment pipeline — a reblet was data, and data synced. Add a program to your world and every member simply had it. What we now distribute through Slack apps, Google Docs sharing, and a dozen SaaS dashboards, IOS did in 2001 as a coherent single system — on dial-up, in a fraction of a megabyte per client.^[17]

It ran as a beta at what the company described as a major Silicon Valley chip manufacturer, shipped as IOS Express 1.0 in October 2001, and peaked commercially when StreamCast announced Morpheus 2.0 — the file-sharing giant's successor, then claiming over 30 million users — would be built on IOS technology.^[18]

For a moment the pitch was winning. There were books in two languages — REBOL for Dummies (Ralph Roberts, 2000) and Olivier Auverlot's REBOL Programmation (Eyrolles, 2001) — and a Webby nomination in 2002 as a top-five technical achievement alongside Google and Sony, the community mounting a People's Voice campaign that had Sassenrath himself posting "REBOL is second" to the mailing list.^[19] An SDK with /Base, /Pro, and /Face kernels plus encapsulators followed in November 2002; Mac OS X support in 2003; the View desktop environment was opened in June 2003; a browser plug-in arrived in 2004; REBOL/View 1.3 in June 2005.

And the community itself was already shipping what the roadmap hinted at. Maarten Koopmans' Rugby — a remote-procedure-call broker written in REBOL — let one interpreter invoke functions on another across the wire with stub-free, message-native calls: distributed computing as a library, a decade before microservices needed a name. It remains one of the neatest proofs that the messaging thesis was not vapor.

Then the momentum simply stopped compounding. The Morpheus deal dissolved with StreamCast's troubles. The market consolidated around the LAMP stack and the browser. And underneath it all sat the decision that would define the next decade: the interpreter stayed closed.

Why it lost: an autopsy

Every REBOL retrospective eventually confronts the same paradox: technically superior in a dozen measurable ways, commercially invisible in every one that counted. The causes are not mysterious once listed, and none of them is "the language wasn't good enough."

The licensing math never worked. REBOL/Core was free but the interesting tiers — /Command's database and library access, the SDK's encapsulators, IOS itself — were paid products from a six-person company competing against Perl, Python, PHP, Tcl, and Java, all of which were free all the way down. You could learn REBOL for nothing; you could build a business on it for a fee. In 1999 that model was already dying.

Closed source meant closed distribution. No source meant no Linux distribution packages, no BSD ports, no vendor rebuilds — which meant REBOL was absent from the one channel that made languages ubiquitous in that era: the default install. PHP and Perl won the web not by being better but by being already there on every hosting account on earth. REBOL was a download you had to seek out, a binary you had to trust, and a language you couldn't inspect.

The platform pitch outran the language pitch. Selling "an Internet Operating System" to a market that had just learned what a web browser was, required evangelists, documentation, and sales cycles REBOL Technologies never had. Developers found a brilliant scripting language; the company needed them to buy a vision. The gap between what REBOL was and what it was sold as never closed.

And it was one man. Every design decision, every port, every alpha, every licensing debate flowed through a single architect — the same bottleneck that produced the coherence also produced the stall. When Sassenrath's attention moved on, the language had no institution left to carry it. Python had a community infrastructure; REBOL had a fan club locked outside the walls.

The cruellest summary is the simplest: REBOL bet everything on being a product when the industry had already decided languages would be commons.

The closed-source years

Sassenrath's position on source was explicit and, to him, principled: even for the forthcoming REBOL 3, he said in 2007, "there will still be a kernel of REBOL that is not open source. This factor lets us keep the language 100% compatible between different computers and operating systems."^[20] Compatibility through a single implementation — the same argument Java made in the same era — except Java had Sun's marketing budget and a million enterprise salesmen, and REBOL had six people in Ukiah.

The community kept building anyway. AltME — the Alternative Messaging Environment, an encrypted private-world chat system from SafeWorlds, written in REBOL — became the movement's headquarters from 2002: user groups, dev rooms, announcement boards, a self-hosted parallel universe years before Slack made the idea mainstream. Nenad Rakočević built Cheyenne, a full web server written entirely in REBOL, reaching beta in October 2006. The faithful ran conferences — the REBOL Collaboration at Davis, California in 2004; DevCon 2005 in Treviglio, Italy; a Paris gathering in 2007 — and kept rebol.org's script library stocked through the lean years.

But a closed interpreter on 32-bit binaries in a 64-bit world has a half-life. R2 releases thinned: View 1.3 in 2005, and then mostly silence punctuated by 2.7.x maintenance builds — the last, 2.7.8, in January 2011. REBOL 3, announced as the ground-up rewrite, spent years as semi-public alphas circulated among the AltME faithful from 2007 onward: UTF-8, 64-bit integers, a proper module system, a new AGG-based graphics engine, a leaner kernel — perpetually next year. Development happened where the community lived: on private AltME worlds, behind the same walls that kept the source. In October 2008 Sassenrath posted a plan to eventually open it; the promise, like the interpreter, stayed pending.^[21]

The wilderness had its own texture. The company still answered mail and still sold licenses; the binaries still ran; the community still shipped libraries, games, and business tools into a shrinking niche. REBOL became the language people discovered, loved for a summer, and reluctantly filed under "brilliant but abandoned" — a reputation that was simultaneously unfair to a living codebase and entirely earned by a steward who could not be moved to free it.

The tragedy of the closed years is precisely what the architecture had argued: the language was so easy to carry that the community kept porting the idea — Cheyenne, Boron, World, and eventually Red — while unable to port the implementation. The interpreter couldn't move; so the ecosystem moved without it.

R3 goes open source: December 12, 2012

The opening finally came on December 12, 2012: after discussion with open-source attorney Lawrence Rosen, REBOL Technologies released the complete REBOL 3 interpreter source under the Apache License 2.0, hosted on GitHub as rebol/r3.^[22] Fifteen years of closed development ended in a single commit. R1 and R2 remain binary-only to this day — no source release for them is planned — but R3 was the rewrite, the future, and it was free.

The response was immediate and characteristic: the community did not throw a party; it started porting. Within months there was rebolsource/r3, the "community" build — maintained builds, 64-bit support, continuous integration on Travis — organized by long-timer Andreas "earl" Bolka, with Ladislav's review queue shepherding outside pull requests.^[23] Saphirion brought the R3-GUI toolkit and an experimental Android View port — REBOL on phones, the place a messaging language was always supposed to live.^[24] Oldes' fork kept the Windows graphics and multimedia edge sharp. And Atronix, an industrial-automation company, adopted R3 commercially — real revenue, real deployments, real upstream contributions, the enterprise story REBOL had wanted a decade earlier.

The open source came a decade late for the market and exactly on time for the community. What happened next proved the language could, at last, be carried.

Red, Ren-C, and the successor languages

The most ambitious descendant is Red, begun by Nenad Rakočević — the Cheyenne author — in 2011: a REBOL-descended language that compiles to native code, with a low-level companion dialect (Red/System) and the explicit goal of being a full-stack platform from metal to GUI — what REBOL might have been with a compiler and a foundation behind it. Red inherited the dialects, the datatypes, the VID dream (a native cross-platform GUI built in), and the rhetoric of economy, funded through a French company and later — a sore point worth noting neutrally — a 2018 blockchain-token venture that split opinion in the community.^[25]

Ren-C — the fork most faithful to the source itself — began in June 2015 when Brian Dickens ("HostileFork") sent Coherence One, the first pull request of what became the metaeducation fork: a disciplined modernization of the actual R3 codebase. Ren-C reconciled the drifted Atronix and community builds, hardened the C source under Valgrind and AddressSanitizer, pushed the console into userspace, added a real FFI, and kept the executable honest — the un-fork, maintaining REBOL 3 by maintaining its engineering.^[26]

Around the core forks, the diaspora kept flowering: Boron, Karl Robillard's C-library REBOL-like (2007), used in 3D demos; World, John "Geomol" Niclasen's clean-room REBOL dialect (2010); Oldes' R3 builds; the Saphirion GUI line. A language whose own interpreter couldn't be ported for a decade ended up ported a half-dozen different ways — which is either vindication or irony, and in REBOL's case it is both.

The community that wouldn't let go

Every overlooked language has a forum; REBOL has a congregation. The REBOL community is small, ancient, multilingual, and indestructibly devoted — the kind of group that responds to its interpreter going unmaintained not by leaving but by writing new interpreters.^[27]

Its geography is a museum of messaging: the original rebol.com mailing list, then AltME worlds (encrypted, self-hosted, REBOL-written, running since 2002 — the community built its clubhouse out of the product it was discussing), the rebol.org script library and archives — tended for years by Sunanda, whose stewardship of that archive is its own act of preservation — the Stack Overflow REBOL chat room and its RebolBot, rebolforum.com, and the modern forum.rebol.info. Through the closed years these rooms coordinated conferences, translated documentation, kept tutorials alive — Nick Antonaccio's free Learn REBOL ("business programming") guide alone brought in a generation — and argued, endlessly and productively, about what the language should become.

The names are worth recording, because the community was always small enough to name: Andreas "earl" Bolka's community builds and CI; Ladislav's review queue and theoretical precision; Graham Chiu's build-farm wrangling; DocKimbel — Nenad Rakočević — whose Cheyenne server became the Red lineage; Cyphre's graphics work; Brian "HostileFork" Dickens' Ren-C discipline; Oldes' Windows builds; Gabriele Santilli's documentation; and dozens more whose AltME handles outlived the products they discussed. A language with a congregation this small gets to be written about in first names.

The devotion has a texture outsiders find baffling until they try the language. REBOL attracts a specific person: the one who read a one-liner that fetched, parsed, and mailed a web page and felt something click. The community is full of those people, and twenty-five years of waiting made them fluent in a skill most communities never learn — keeping a language alive as an idea while its reference implementation drifted. When R3 finally opened, the build farms, the review queues, the forks, and the roadmap arguments were already running. They had been rehearsing for a decade.

Is REBOL dead? Trying it today

The honest answer is that REBOL died the way good languages die: commercially, officially, and incompletely — while remaining technically alive in a way that never quite stops. Your field guide to what's runnable:

• REBOL 2.7.8 — the final R2, still downloadable from rebol.com; it runs on modern Windows and Linux, a half-megabyte time capsule whose network examples still mostly work. Binary-only, forever.
• REBOL 3 — the Apache-2.0 source at github.com/rebol/r3; community builds cover 64-bit Linux, Windows, and macOS. The interpreter the company promised in 2007, deliverable now by the community.
• Ren-C — the actively-maintained R3 line at rebol.metaeducation.com; the recommended interpreter for the faithful, with a real FFI and a hardened core.
• Red — red-lang.org; the compiled full-stack descendant, the most batteries-included way in for newcomers who want the ideas without the archaeology.

A first session is fifteen minutes:

REBOL [Title: "First contact"]

; fetch a page and count its bytes
page: read https://example.com
print ["bytes:" length? page]

; a GUI counter in five lines
count: 0
view layout [
    t: text "0"
    button "++" [t/text: to-string (count: count + 1) show t]
]

What you will feel — most people who try it report the same disorientation — is a language where the distance between thought and expression keeps collapsing, where the boilerplate is missing and nobody replaced it. What you should not expect is a modern ecosystem: no package manager of note, thin library coverage, documentation scattered across archived sites, and a bus factor you could count on one hand's fingers.

And a few honest gotchas, so the first session doesn't become the last: REBOL series are mutable by default — append modifies in place, and a shared series is a shared surprise until you learn copy. Prefix function calls and infix operators interleave in ways that bite (a + 1 2 is not always the arithmetic you assumed). Words bind* to contexts at load time in a way that produces famously subtle bugs until the day it clicks and you understand why REBOL programmers talk about binding the way lispers talk about macros. And parse is case-insensitive on strings unless you ask for /case — a default with a body count.

The documentation is archaeology, so here is the map: rebol.com still hosts the R2 docs — the Core dictionary is genuinely excellent and still one of the best-written function references in any language — plus Sassenrath's original essays on dialecting and the X Internet. rebol.org keeps the script library, the mailing-list archives back to 1998, and the AltME transcripts (primary sources for the R3 era, which was developed in AltME rooms). Antonaccio's re-bol.com hosts Learn REBOL, the most practical beginner tutorial ever written for it. ren-c builds and docs live under rebol.metaeducation.com, Red under red-lang.org, and the current water cooler is forum.rebol.info. Budget an afternoon just to browse rebol.org's script library — it is a museum of solved problems, each in a page of code or less.

REBOL today is a language you learn for the same reason you read Latin: not for the libraries, but because it teaches you what a language can be.

REBOL terminology, quick reference

The vocabulary you'll meet in the docs, the forums, and this article:

Term	What it means
dialect	a purpose-built mini-language evaluated by the same engine — PARSE, VID, DRAW, SECURE, or one of your own
series	the universal sequence abstraction — strings, blocks, files, ports all share one navigation vocabulary
block	[...] — an unevaluated sequence of values; both "array" and "source code"
word	a symbolic name; comes in flavors: set-word x:, get-word :x, lit-word 'x
refinement	a /slash option on a function — copy/part, parse/case — or on a path
reblet	a REBOL applet: program + UI + data synchronized as messages in an IOS world
IOS	the Internet Operating System — REBOL's 2001 collaboration platform of networked reblets
world	a permissioned IOS collaboration space; AltME borrowed the concept for its chat worlds
scheme	a protocol plugin for the port system — http://, pop://, tcp://, or your own
mold / load	serialize a value to source form / parse source back into live values — the whole "serialization" story
bind	re-point a word's context — the metaprogramming primitive under objects and dialects
VID	the Visual Interface Dialect: view layout [...] — a GUI described in its own grammar
PARSE	the pattern-matching dialect — PEG-family rules over strings and blocks
AltME	the Alternative Messaging Environment — the community's encrypted home since 2002
Ren-C	the actively maintained open-source R3 fork (metaeducation)
Red	the compiled full-stack REBOL-descendant language by Nenad Rakočević

REBOL in dates

For the scannable record — the whole arc in one place:

• 1985 — Carl Sassenrath writes Exec, the Amiga's multitasking kernel
• 1996 — Sassenrath devotes himself full-time to a distributed-computing language
• 1997–98 — REBOL Technologies founded in Ukiah, California (incorporated March 1998)
• October 1, 1998 — REBOL/Core 1.0 released free, seven platforms
• 2000 — /Command (September), Core free redistribution, REBOL for Dummies published
• April 6, 2001 — REBOL/View 1.0: graphics, sound, the VID dialect
• October 2001 — IOS Express 1.0 ships; StreamCast announces Morpheus on IOS tech
• 2002 — Webby nomination; AltME becomes the community's home; SDK ships
• 2004–05 — Davis and Treviglio conferences; REBOL/View 1.3
• 2006–07 — Cheyenne web server; R3 alpha builds begin circulating on AltME
• October 2008 — Sassenrath posts a plan to open the source — pending
• January 2011 — 2.7.8, the final R2 release
• 2011 — Nenad Rakočević begins Red, the compiled successor
• December 12, 2012 — R3 interpreter open-sourced under Apache 2.0
• 2013 — rebolsource community builds, 64-bit ports, Saphirion's Android View
• June 2015 — Coherence One: Ren-C begins modernizing the R3 core
• 2023 — Sassenrath retires from Roku; the forks and forums carry the language on

Why REBOL still matters

Strip away the counterfactuals — what if it had opened in 2000, what if the company had been in San Francisco, what if Morpheus had shipped — and REBOL's actual legacy is specific and provable.

It demonstrated, end-to-end and in production, that a language, its data format, and its wire protocol can be one artifact. JSON made a subset of that idea universal; Crockford's own attribution keeps the lineage on record. It showed that datatypes belong in the syntax — that 12-Dec-2012 and [email protected] are values, not strings awaiting regex. It proved a GUI dialect and a parser dialect could share an evaluator with the code that hosts them, an idea that quietly shadows every "language-oriented" tool since. And it kept a record, in shipping software, of the road not taken by the early web: messaging over documents, reblets over pages, an executable internet instead of a readable one.

Its echoes are everywhere once you look — and the echoes are worth naming. Every chat-centric workspace that treats conversation as the computing substrate is walking territory AltME and IOS mapped in 2002. Every configuration format that wants to be a tiny readable language — every HCL, every DSL pitch citing "readable by domain experts" — is re-deriving the dialect argument badly and piecemeal. Every engineer who has stared at a 900 MB container image and wondered what the runtime actually needs has independently reinvented Sassenrath's half-megabyte objection. PEG parsers went mainstream; REBOL's parse had been writing them in blocks since 1998. The industry didn't adopt REBOL — it slowly re-invented it, worse and piece by piece, the way industries do.

Mostly it matters because it is complete. REBOL is one mind's coherent answer to the whole question — what computing should feel like when it is honest about being networked — from kernel instinct to wire format to GUI dialect to community platform. Languages like that do not become obsolete; they become reference. The cult endures because the artifact is good.

Knowledge is only ever lost when the world stops looking — and for a quarter-century, a small, stubborn congregation has refused to stop looking at REBOL.

See also

• SNOBOL and Icon — the other great string-and-pattern lineage; Icon's goal-directed evaluation is REBOL's nearest old-world cousin
• Forth — the stack-and-word evaluation tradition in REBOL's ancestry (Sassenrath wrote an NGS Forth before the Amiga)
• LISP — code-as-data, the grandmother idea dialecting inherits
• History of Programming — the larger map this branch belongs to
• AdaLogic BASIC — a living language keeping the small-interpreter, anti-complexity faith
• Chevalier de Saint-Georges — on preserving people history nearly lost; languages deserve the same

Footnotes

1. ↑ REBOL Technologies press release, "New Messaging Language REBOL Transforms Information Exchange over Networks", October 1, 1998
2. ↑ Douglas Crockford, on JSON's influences; quoted in the Wikipedia article "Rebol" and in his JSON/JavaScript talks
3. ↑ rebol.com, "What is REBOL?" — mission page
4. ↑ Sassenrath, C., REBOL documentation and rebol.com essays, 1998–2005
5. ↑ Carl Sassenrath, on dialecting being REBOL's most notable property; REBOL documentation and interviews
6. ↑ Wikipedia, "Carl Sassenrath"
7. ↑ Sassenrath biography, rebol.com/bio-carl.html; Wikipedia, "Carl Sassenrath"
8. ↑ rebol.com/bio-carl.html; rebol.com/mission.html
9. ↑ REBOL Technologies press release, October 1, 1998: "REBOL Technologies was incorporated by Carl Sassenrath in March 1998. Based in Ukiah, Calif."
10. ↑ sassenrath.com, "Past Products and Inventions"
11. ↑ Wikipedia, "Carl Sassenrath"; sassenrath.com
12. ↑ Wikipedia, "Carl Sassenrath" — Sassenrath on REBOL as an experiment in context and symbolism
13. ↑ REBOL Technologies press release, October 1, 1998
14. ↑ Carl Sassenrath, "the X Internet" concept, REBOL Technologies essays and talks, 2000–2001
15. ↑ Carl Sassenrath on dialecting, REBOL documentation and developer interviews, 1998–2005
16. ↑ REBOL Technologies product pages and press releases, 2000–2001; CodeArchaeology REBOL timeline
17. ↑ REBOL/IOS product documentation and contemporary coverage, 2001–2002
18. ↑ CodeArchaeology, "REBOL" timeline: IOS beta, Express 1.0 (October 2001), StreamCast Morpheus announcement
19. ↑ rebol.org mailing-list archive, "RE: REBOL momentum builds," May 16, 2002
20. ↑ Carl Sassenrath, 2007 — quoted in the CodeArchaeology REBOL history
21. ↑ CodeArchaeology REBOL history, "Products, plateau and the long road to REBOL 3"
22. ↑ Wikipedia, "Rebol"; REBOL Technologies announcement, December 2012 — github.com/rebol/rebol
23. ↑ rebol.org AltME archive, Ladislav, March 30, 2013: accepting the first pull requests to rebolsource/r3
24. ↑ rebol.org AltME archive, April 13, 2013: first R3-View Android alpha
25. ↑ red-lang.org; CodeArchaeology REBOL history
26. ↑ Ren-C 2018 Roadmap and Retrospective, rebol.metaeducation.com; rebolforum.com
27. ↑ community record: rebol.org, rebolforum.com, forum.rebol.info archives