SCAR

SCAR is a Pascal-based scripting environment built for a very specific job: watching a Windows screen, recognizing colors, shapes, and bitmaps on it, and driving the mouse and keyboard in response. It was created in 2003 to automate play in the MMORPG RuneScape, and it became one of the longest-running tools in that game’s automation (“botting”) scene - not because it was clever about reading the game’s internal state, but because it never had to. By treating the screen purely as pixels and coordinates, SCAR sidestepped the need to reverse-engineer RuneScape’s client or network protocol, and its Pascal-derived scripting language let a large community of amateur scripters write, share, and refine automation routines for years.

History and Origins

SCAR’s creator, Aivars Irmejs, better known by his online handle Kaitnieks, was an early and prolific figure in RuneScape’s cheating and automation community. In 2002 he released AutoRune, one of the first scriptable bots for the game. In 2003, Kaitnieks set AutoRune aside and built SCAR as its more flexible successor: rather than a purpose-built bot with a fixed set of behaviors, SCAR was a general Pascal-flavored scripting environment with a built-in API for locating colors and bitmaps on screen and simulating input, so that end users could write their own automation scripts instead of waiting on the tool’s author.

That openness is what let SCAR outlive AutoRune. By the time AutoRune’s source was sold off and leaked in 2004, SCAR already had a growing base of scripters writing and trading routines for it. Kaitnieks continued developing and supporting SCAR until 2006, when he retired from the scene and shut down his forums. Development passed to Frederic Hannes, known online as Freddy1990, who rebranded the project SCAR Divi and packaged it as a full CDE (Complete Development Environment), releasing CDE 3.0 in 2007 with an integrated script editor, debugger, and the color/bitmap recognition and input-simulation API that had defined SCAR from the start. Much of the existing user community, meanwhile, regrouped on what became the Villavu/SRL forums to keep maintaining a shared library of Pascal scripting routines - a library that outlasted several changes of ownership in the tooling built around it.

Tension between the community and Freddy1990’s closed-source direction for SCAR Divi eventually led a group from the SRL community, led by the developer known as Wizzup, to start Simba around 2010 as a free, open-source clone of the SCAR scripting model. Simba kept the Pascal-like syntax and the same color/bitmap-and-input approach to automation, but built it on an openly developed codebase. SCAR Divi itself continued to see updates from Freddy1990 well into the 2010s, but the center of gravity in the RuneScape scripting community shifted steadily toward Simba, which remains the actively developed carrier of SCAR’s ideas today.

Design Philosophy

SCAR’s core idea is that you don’t need access to a program’s internals to automate it - you only need to see what a human would see and act the way a human would act. Its scripting language exposes functions like FindColor and FindBitmap to locate visual features within a defined screen region, with tolerance parameters to handle anti-aliasing and lighting variation, alongside MoveMouse, MoveMouseSmooth, and similar routines meant to approximate human-like cursor movement rather than instantaneous, obviously mechanical jumps. This is automation built entirely at the presentation layer: the target application - RuneScape, or in principle any other Windows program - never needs to be aware that it is being driven by a script rather than a person, and the tool needs no cooperation from, or knowledge of, the target’s internal data structures.

Wrapping that API in a Pascal-derived language was a deliberate accessibility choice. Pascal’s structured, readable begin/end syntax was familiar to hobbyist programmers of the era and easy to teach, which mattered enormously for a tool whose value depended on a community of non-professional scripters being able to read, adapt, and share each other’s routines.

Key Features

• Color and bitmap recognition via FindColor, FindBitmap, and tolerance-based variants for locating on-screen features under imperfect, real-world rendering conditions
• Simulated mouse and keyboard input, including smoothed and “human-like” mouse-movement routines intended to avoid the obviously robotic motion of naive automation
• Basic optical character recognition, with functions for loading custom bitmap fonts and reading text directly from the screen
• A Pascal/Delphi-derived scripting syntax, familiar and approachable to hobbyist programmers, with an integrated script editor and debugger in the SCAR Divi CDE
• A community script-sharing model, built around the shared SRL routine library rather than scripts written from scratch by each user

Evolution

SCAR moved through three overlapping eras: Kaitnieks’s original SCAR (2003-2006); Freddy1990’s SCAR Divi, which formalized it into a packaged CDE and continued its development while gradually closing its source; and Simba, the open-source clone the SRL community built around 2010 in response. Each generation kept the same essential model - a Pascal-like scripting language over a screen-color-and-input API - while changing who controlled the tooling and, eventually, who was still actively improving it.

Current Relevance

The original SCAR and SCAR Divi lines are effectively dormant as sites of active development; the community’s energy moved to Simba years ago, and Simba - not SCAR Divi - is the project still receiving regular updates today. RuneScape’s own bot-detection systems have also grown far more sophisticated since SCAR’s early-2000s heyday, changing the practical risk calculus for this style of automation. What survives is the underlying idea and its lineage: a Pascal-scripted, screen-color-driven approach to automating a game client without touching its internals, still visible in Simba’s continued use of the same core API decades later.

Why It Matters

SCAR is a case study in how a scripting tool can outlive its original author and even its original application by being genuinely extensible. Kaitnieks built SCAR as an open-ended Pascal scripting environment rather than a fixed bot, and that choice let a community of amateur scripters carry the project’s ideas forward - first through shared libraries like SRL, then through an entire open-source successor in Simba - long after SCAR itself stopped being the tool anyone was actively developing. It is also a reminder that some of the most durable pieces of “unofficial” software history live not in mainstream compilers and standards bodies but in narrow, purpose-built tools built by hobbyists for a single game, whose techniques (screen scraping, simulated input, community-maintained script libraries) turn out to generalize far beyond the game that motivated them.