Curl

Curl is a multi-paradigm programming language created at MIT in the mid-1990s with the ambitious goal of unifying web markup, scripting, and full application programming into a single coherent language. Rather than requiring developers to juggle HTML, CSS, JavaScript, and a server-side language, Curl aimed to provide a “gentle slope” from simple text formatting to complex, interactive applications – all within one language and runtime.

History & Origins

The Curl project began in 1995 at the MIT Laboratory for Computer Science (LCS), funded by DARPA. The research team was led by Steve Ward, a professor in MIT’s Department of Electrical Engineering and Computer Science, along with David Kranz (a principal research scientist who had previously worked on the T compiler at MIT), Chris Terman, Cotton Seed, and M. Hostetter. Their goal was to address a fundamental problem with web development: the proliferation of separate languages and technologies needed to create rich web content.

The foundational paper, “Curl: A Gentle Slope Language for the Web,” was presented in 1997 and outlined the team’s vision. The name “Curl” reflected the language’s use of curly braces as its primary syntactic delimiter, drawing from its Lisp heritage.

In 1998, twelve researchers from the MIT project founded the Curl Corporation to commercialize the technology. The first commercial release didn’t arrive until August 2001, when it was launched at the Software Development Forum in Palo Alto, California.

Acquisition and Japanese Market

In 2004, Sumisho Computer Systems Corporation (SCS), a Japanese software firm, acquired Curl Corporation. This acquisition proved pivotal – under SCS’s stewardship, Curl gained significant traction in Japan, with reportedly over 500 companies eventually adopting the platform. In October 2011, SCS merged with CSK Corporation to form SCSK Corporation, a subsidiary of Sumitomo Corporation, which continues to maintain Curl today.

Design Philosophy: The Gentle Slope

Curl’s central design principle is the “gentle slope” – the idea that incremental functionality should require only incremental skill acquisition. A developer should be able to start by writing simple formatted text (similar to HTML) and progressively add interactivity, logic, and full object-oriented programming without switching languages or paradigms.

This stands in contrast to traditional web development, where moving from static content to interactive applications requires learning fundamentally different technologies. In Curl, a document that starts as simple markup can gradually incorporate:

• Styled text and layout
• Event handlers and user interaction
• Data binding and reactive values
• Full object-oriented class hierarchies
• Concurrent programming with threads

All within the same language and file.

Key Features

Unified Syntax

Curl uses curly-bracket expressions in the form {operator arguments...}, inspired by Lisp’s S-expressions but with a more familiar appearance. This single syntactic pattern scales from simple text formatting to complex programming:

{paragraph
    This is simple formatted text with {bold emphasis}.
}

{define-proc {factorial n:int}:int
    {if n < 2
     then 1
     else n * {factorial n - 1}
    }
}

Object-Oriented Programming

Curl provides a full object-oriented system with class-based inheritance, including support for multiple inheritance. Classes are optional – developers can write procedural code without them, supporting the gentle slope philosophy.

Functional Programming

The language supports closures and anonymous procedures, enabling a functional programming style alongside its object-oriented and procedural capabilities.

Dynamic Values

Curl provides a reactive programming model through “dynamic values” that automatically propagate changes through the user interface, enabling real-time data display without manual refresh logic.

JIT Compilation

Rather than interpreting code, Curl’s runtime (the Surge RTE) compiles applets to native machine code using just-in-time compilation, targeting performance-sensitive enterprise applications.

Security Model

Curl implements a sandbox security model for untrusted code, with a privilege system that allows trusted applets to access local resources. This was designed for enterprise deployment scenarios where applications needed both security isolation and system access.

Offline Capability

Curl applications support local storage and can operate in both online and offline modes, a feature that was ahead of its time in the early 2000s, predating similar capabilities in modern web applications.

File Types

Curl uses several file extensions for different purposes:

• .curl – Applet files (web-deployed applications)
• .dcurl – Detached applet files
• .scurl – Source code files
• .mcurl – Manifest data files

Evolution

Curl evolved significantly over its lifetime:

• Version 6.0 (2008) added JavaScript and Ajax integration along with JSON support, acknowledging the rise of these web technologies
• Version 8.0 (2011) introduced multitouch and gesture support, PDF export, and other modern features
• Caede (2012) was a mobile development environment built on Curl, targeting iOS and Android platforms

However, in March 2019, SCSK announced the discontinuation of Linux and macOS support, making Curl a Windows-only platform from version 8.0.10 onward. This reflected the language’s narrowing user base, concentrated primarily in Japanese enterprise environments.

Type System

Curl’s type system is notable for its flexibility. The language is strongly typed, but offers an any type that allows developers to opt out of strict type checking when desired. Type enforcement uses a combination of compile-time and run-time checks, providing safety guarantees while maintaining the dynamic feel that the gentle slope philosophy demands.

Current Status

Curl remains actively maintained by SCSK Corporation, with version 8.0.15 released in October 2025. However, the language occupies a niche position:

• Its primary user base is concentrated in Japan
• It requires a proprietary browser plugin (the Surge RTE) for web deployment, which is increasingly problematic as modern browsers restrict plugin architectures
• It is Windows-only since 2019
• The language is proprietary with a custom license

Despite these limitations, Curl continues to serve its existing enterprise customers, particularly in the Japanese financial and manufacturing sectors.

Why Curl Matters

Curl represents one of the most ambitious attempts to solve the fundamental fragmentation of web development technologies. Its “gentle slope” philosophy – that a single language should span from simple markup to full application development – anticipated ideas that would later appear in frameworks like React and tools that blur the line between content and application.

The language also demonstrated that a unified web content language could provide strong performance through JIT compilation and rich interactivity years before modern single-page application frameworks achieved similar capabilities. While Curl never achieved mainstream adoption outside of Japan, its design philosophy remains a thoughtful critique of the multi-language complexity that still characterizes web development today.

Curl’s text-procedure style has been compared to Groovy’s “builder” pattern, which uses similar ideas about mixing markup-style declarations with procedural code, though a direct influence relationship has not been established. The language stands as an interesting case study in how technical merit alone doesn’t guarantee widespread adoption – factors like proprietary licensing, plugin requirements, and market timing proved equally important.