WebDNA

WebDNA is a declarative, tag-based server-side scripting language with a database built directly into the language engine. Created at Pacific Coast Software in 1995 as the syntax inside the WebCatalog e-commerce server, it belongs to the first generation of web scripting languages — the same mid-1990s wave that produced PHP and ColdFusion — and it embodied an idea that was radical at the time: a web designer who knew HTML should be able to build a database-driven store by adding a few English-like tags to a page, with no separate database server, no SQL, and no compiled CGI programs. Three corporate owners and three decades later, WebDNA is still maintained by WebDNA Software Corporation, which continues to publish releases in the WebDNA 8 series.

History & Origins

WebDNA’s origin story is unusually concrete: according to Pacific Coast Software co-founder Grant Hulbert, it began as a set of C macros he built for website work, first put to use selling stock photography on the early web. That problem demanded exactly the pieces that would define the product — a searchable fixed-field database for photo metadata, page templates to display results, and a shopping cart to sell the images. Pacific Coast Software recognized that this machinery generalized far beyond photography, and in 1995 released it as WebCatalog, debuting on the Macintosh — then a popular platform for web publishing and design shops.

The naming took a path worth untangling: WebCatalog was the server product, while WebDNA referred specifically to the square-bracket scripting syntax embedded in its templates. The WebDNA name was registered as a trademark in 1998. In the late 1990s the company aimed squarely at online commerce, shipping StoreBuilder and WebMerchant to help merchants migrate traditional product catalogs to the web.

In September 1999, Smith Micro Software acquired Pacific Coast Software, and under Smith Micro the whole product took the name of its language: WebCatalog became WebDNA. The years around the turn of the millennium were the language’s high-water mark — sites for Disney, Chrysler, Kodak, Ben & Jerry’s, the Pillsbury Doughboy shop, the NCAA Final Four, and the Museum of Television and Radio reportedly ran on WebDNA during its roughly 1999–2004 peak. A period of stagnation followed in the mid-2000s as Smith Micro’s attention moved elsewhere and the broader market consolidated around PHP and its LAMP-stack peers.

The revival came from the community itself: in June 2008, people from the original WebDNA development circle formed WebDNA Software Corporation, bought the technology from Smith Micro, and restarted development — releasing WebDNA 6.2 “Cicada” in 2009 and carrying the platform forward into the WebDNA 8 series.

Design Philosophy

WebDNA’s core bet is that most database-driven websites are, at heart, formatting exercises: find some records, loop over them, and merge the values into HTML. So instead of a general-purpose language bolted onto a separate database, WebDNA offers a template language where searching, looping, and formatting are native operations, and where the database lives inside the same engine that renders the pages.

Three principles follow from that bet:

1. Look like HTML. WebDNA instructions are tags in square brackets, interwoven directly into HTML files and interpreted by the server engine before the page is sent to the browser. Anyone comfortable with angle-bracket markup can read [showif]...[/showif] on sight.
2. Batteries included. The database, the search engine, the shopping cart, email sending, and encryption are built into the language rather than delegated to external services. A stock WebDNA install can run a complete store with no other moving parts.
3. Declare, don’t program. A WebDNA page states what should appear — the records matching a search, a price formatted to two decimals — rather than spelling out how to fetch and transform it. Loops and conditionals exist, but the idiom is declarative template markup, not procedural code.

Key Features

WebDNA has just two kinds of instruction:

• Tags — single self-contained commands that return a value, like [date] or [ipaddress].
• Contexts — paired opening and closing tags that act on everything between them, like [showif]...[/showif] or [search]...[/search].

A few representative examples:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

<!-- Display the current server date -->
Today is [date].

<!-- Conditional display -->
[showif [ipaddress]=127.0.0.1]
  You are browsing from the server itself.
[/showif]

<!-- Formatting: pads 7 to three digits, producing 007 -->
[format thousands .3d]7[/format]

<!-- Search a database and loop over the results -->
[search db=catalog.db&gePRICEdata=10]
  [founditems]
    <p>[title] — $[price]</p>
  [/founditems]
[/search]

Other notable capabilities:

• Hybrid in-memory database. WebDNA’s native databases are RAM-resident for speed, with automatic persistence to disk — a design that predates the modern fashion for in-memory data stores by many years. No separate database server, connection pool, or SQL layer is required, though MySQL integration and ODBC-style access to external databases have been offered for sites that want them.
• Two syntax styles. Alongside the classic square-bracket notation, WebDNA has offered an XML-like “WYSIWYG-safe” syntax so that visual HTML editors don’t mangle the code.
• E-commerce primitives. Shopping cart handling descends directly from the WebCatalog days and remains part of the platform.
• Modern additions. Later releases in the 8.x series added full regular expressions, session management, JSON storage (JSONstore), TLS email, encryption methods from AES and SHA-256 through bcrypt, multi-byte character handling, and BioType, a keystroke-dynamics biometric authentication system.

Because everything is text merged into templates, WebDNA is effectively dynamically typed: values are handled as text and interpreted numerically where context demands it, which keeps the mental model simple for its target audience of designer-developers.

Evolution

WebDNA’s technical evolution tracks its ownership history:

• Pacific Coast Software era (1995–1999) — WebCatalog on Macintosh and then Windows; the e-commerce focus with StoreBuilder and WebMerchant; the WebDNA trademark in 1998.
• Smith Micro era (1999–2008) — the product renamed WebDNA; peak corporate adoption early in the period, followed by slowing development in the mid-2000s.
• WebDNA Software Corporation era (2008–present) — the 2009 6.2 “Cicada” release restored cross-platform support across Windows Server, Mac OS X, and Linux. The FastCGI edition (December 2011, with the 7.x line running on Linux, OS X, Solaris, and FreeBSD and 7.1 following in November 2012) was a significant architectural shift, freeing WebDNA from Apache-module deployment and adding process isolation. The WebDNA 8 series (8.0 in April 2014 through the current 8.6 and 8.7 releases) has concentrated on security and interoperability: TLS email, modern encryption, regex, sessions, JSON storage, automatic database encryption, and a Windows FastCGI build.

Current Relevance

WebDNA today is a niche but living platform. WebDNA Software Corporation maintains the engine, documentation, and community site at webdna.us, offers a free developer edition, and continues to ship maintenance and feature releases — currently 8.6.5, with an 8.7.1 build for macOS. The user base is small compared to the PHP-scale mainstream — largely long-running sites and developers who value the language’s all-in-one simplicity — but the software runs on modern server operating systems (installers cover recent Ubuntu LTS releases and Apple-silicon macOS), and the free developer edition has lowered the barrier for trying it out.

For the code archaeologist, WebDNA is notable as one of the few first-generation web languages that is neither dead nor mainstream: unlike many mid-1990s contemporaries, you can download a current release and run it.

Why It Matters

WebDNA matters as a well-preserved specimen of the web’s first scripting era — and as a reminder that several “modern” ideas are older than they look. Its RAM-resident database with disk persistence anticipated today’s in-memory data stores; its batteries-included model — template language, database, cart, and email in one engine — prefigured the integrated developer experience that platforms now compete on; and its designer-first, tags-in-HTML philosophy is a direct ancestor of the accessible, low-code spirit that runs from ColdFusion-era tag languages to today’s site builders.

It is also a story about software stewardship. WebDNA passed from a startup to a larger acquirer, languished, and was then rescued by its own community, which formed a company to buy it back and has kept it alive ever since. Languages rarely get second acts; WebDNA’s ongoing maintenance three decades after its Macintosh debut is one of the quieter success stories of the early web.