Hubbry Logo
LiveCodeLiveCodeMain
Open search
LiveCode
Community hub
LiveCode
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
LiveCode
LiveCode
LiveCode
View on Wikipedia
from Wikipedia

LiveCode
DeveloperLiveCode Ltd.
Initial releaseJuly 11, 2001; 24 years ago (2001-07-11)
Stable release
9.6.4 / August 31, 2021; 4 years ago (2021-08-31)[1]
Preview release
9.6.5RC2 / October 25, 2021; 4 years ago (2021-10-25)[1]
Repository
Operating systemmacOS, Windows, Linux, Unix, Android, iOS, HTML5
TypeProgramming
LicenseGPL (until version 9.6.3),[2] Proprietary
Websitelivecode.org livecode.com Edit this at Wikidata
LiveCode Script
ParadigmObject-oriented
Familyscripting language
DeveloperLiveCode, Ltd
First appeared1993 (1993)
Platformi386, AMD64, ARM
OSWindows, macOS, Linux, Unix, Raspberry Pi
LicenseProprietary, GPL
Websitelivecode.com Edit this at Wikidata
Influenced by
HyperTalk

LiveCode (formerly Revolution and MetaCard[3]) is a cross-platform[4] rapid application development runtime system inspired by HyperCard. It features the LiveCode Script (formerly MetaTalk) programming language which belongs to the family of xTalk scripting languages like HyperCard's HyperTalk.[5][6]

The environment was introduced in 2001.[7] The "Revolution" development system was based on the MetaCard engine technology which Runtime Revolution later acquired from MetaCard Corporation in 2003.[8][9] The platform won the Macworld Annual Editor's Choice Award for "Best Development Software" in 2004.[10] "Revolution" was renamed "LiveCode" in the fall of 2010. "LiveCode" is developed and sold by Runtime Revolution Ltd., based in Edinburgh, Scotland. In March 2015, the company was renamed "LiveCode Ltd.", to unify the company name with the product. In April 2013, a free/open source version 'LiveCode Community Edition 6.0' was published after a successful crowdfunding campaign at Kickstarter.[11] The code base was re-licensed and made available as free and open source software with a version in April 2013.

LiveCode runs on iOS, Android, OS X, Windows 95 through Windows 10, Raspberry Pi and several variations of Unix, including Linux, Solaris, and BSD. It can be used for mobile, desktop and server/CGI applications. The iOS (iPhone and iPad) version was released in December 2010.[12][13] The first version to deploy to the Web was released in 2009.[14] It is the most widely used HyperCard/HyperTalk clone,[citation needed] and the only one that runs on all major operating systems.

A developer release of v.8 was announced in New York on March 12, 2015. This major enhancement to the product includes a new, separate development language, known as "LiveCode Builder", which is capable of creating new object classes called "widgets". In earlier versions, the set of object classes was fixed, and could be enhanced only via the use of ordinary procedural languages such as C. The new language, which runs in its own IDE, is a departure from the transitional x-talk paradigm in that it permits typing of variables. But the two environments are fully integrated, and apart from the ability to create new objects, development in LiveCode proceeds in the normal way, within the established IDE.

A second crowdfunding campaign to Bring HTML5 to LiveCode reached funding goals of nearly US$400,000 on July 31, 2014. LiveCode developer release 8.0 DP4 (August 31, 2015) was the first to include a standalone deployment option to HTML5.

On 31 August 2021, starting with version 9.6.4, LiveCode Community edition, licensed under GPL, was discontinued.[2]

Description

[edit]

The LiveCode software creates applications that run in many supported environments, using a compile-free workflow. The same computer code in LiveCode can play across multiple devices and platforms. LiveCode uses a high level, English-like programming language called Transcript that is dynamically typed. Transcript and compile-free workflow generates code that is self-documenting and easy for casual programmers to comprehend. For example, if the following script was executed when the system clock was at 9:00:00 AM: 

  repeat ten times
    put "Hello world at" && the long time & return after field 1
    wait 1 second
  end repeat

Ten lines will be loaded into the first text field. (denoted as "field 1"), and seen as: 

Hello world at 9:00:00 AM
Hello world at 9:00:01 AM
Hello world at 9:00:02 AM
...

Notes:

  • repeat (and the associated end repeat) is a control structure, illustrated here in just one of its various forms.
  • put is a command
  • "Hello World at" is a literal
  • the long time is a function that calls the system time
  • return is a constant equal to ASCII character 10 (linefeed)
  • after is a keyword that is involved with a system known as "chunking", a hallmark of xTalk languages.
  • field 1 is an object reference, here denoted by the layer number of a text field. Almost all standard object classes are supported, and may be referred to in several, highly-intuitive ways.

LiveCode's natural English-like syntax is easy for beginners to learn. Variables are typeless, and are typed at compile time based purely on context. This makes the language simple to read and maintain, with relatively minimal loss of speed. The language contains advanced features including associative arrays,[15] regular expressions, multimedia, support for a variety of SQL databases, and TCP/IP libraries. The LiveCode engine supports several common image formats (including BMP, PNG, GIF, and JPEG,), anti-aliased vector graphics, HTML-style text hyperlinks, chained behaviors and embedded web browsers. Accessing these higher-level functions is designed to be straightforward.

Examples

[edit]
  • To load the source code of a web page into a variable takes one line of code:
put url "http://www.wikipedia.com" into MyVariable
  • Uploading a file to an FTP server uses similar syntax:
put url "binfile:picture.jpg" into url "ftp://john:passwd@ftp.example.net:2121/picture.jpg"

Depth

[edit]

LiveCode has around 2,950 built-in language terms and keywords, which may be extended by external libraries written in C and other lower level languages.[16][17]

Outcomes

[edit]

LiveCode project files are binary-compatible across platforms. They inherit each platform's look-and-feel and behaviors. Buttons, scroll bars, progress bars and menus behave as expected on the target platform without any intervention on the part of the one authoring a LiveCode application.

Compiling a LiveCode "standalone" produces a single, executable file (minimum size ~1.5MB) for each platform targeted. There is no separate runtime necessary.

The Wikipedia article on HyperCard contains a more detailed discussion about the basics of a similar development environment and scripting language. Modern LiveCode is a vast superset of the former HyperCard yet retains its simplicity. LiveCode includes a number of features missing from the original HyperCard program, including multiple platform deployment, communication with external devices and many fundamental language extensions. The LiveCode toolkit, as compared to HyperCard, has the ability to access internet-based text and media resources, which allows the creation of internet-enabled desktop applications.[18]

Compatibility

[edit]
Version Macintosh Windows Linux
9.x[19] 10.9.x – 10.13.x Intel 7, 2008, Windows 8.x, Windows 10.x (Desktop) 32 or 64 bit, 32-bit ARMv6 (Raspberry Pi) glibc glib gtk/gdk lcms pango/xft gksu esd mplayer
8.x[20] 10.6.x – 10.12.x Intel XP SP2+, 2003, Vista SP1+, 7, 2008, Windows 8.x, Windows 10.x (Desktop) 32 or 64 bit, 32-bit ARMv6 (Raspberry Pi) glibc gtk lcms pango/xft gksu esd mplayer
7.x[21] 10.6.x – 10.9.x Intel XP SP2+, 2003, Vista SP1+, 7, 2008, Windows 8.x, Windows 10.x (Desktop) 32 or 64 bit, 32-bit ARMv6 (Raspberry Pi) glibc gtk lcms pango/xft gksu esd mplayer
6.7.x[22] 10.6.x – 10.9.x Intel XP SP2+, 2003, Vista SP1+, 7, 2008, Windows 8.x, Windows 10.x (Desktop) 2.4.x+ 32 bit X11R5 glibc 2.3.2 gtk lcms pango/xft gksu
6.6.x[23] 10.5.8 – 10.9.x Intel/PPC XP SP2+, 2003, Vista SP1+, 7, 2008, Windows 8.x, Windows 10.x (Desktop) 2.4.x+ 32 bit X11R5 glibc 2.3.2 gtk lcms pango/xft gksu
6.0.x – 6.5.x[24] 10.4.11 – 10.9.x Intel/PPC XP SP2+, 2003, Vista SP1+, 7, 2008, Windows 8.x, Windows 10.x (Desktop) 2.4.x+ 32 bit X11R5 glibc 2.3.2 gtk lcms pango/xft gksu
5.x[25] 10.4.11 – 10.8.x Intel/PPC 2000 SP4, XP SP2+, 2003, Vista SP1+, 7, 2008 2.4.x+ 32 bit X11R5 glibc 2.3.2 gtk lcms
4.6.x[26] 10.4.11 – 10.8.x Intel/PPC 2000 SP4, XP SP2+, 2003, Vista SP1+, 7, 2008 2.4.x+ 32 bit X11R5 glibc 2.3.2 gtk lcms
4.5.x[27] 10.3.9 – 10.8.x Intel/PPC 2000 SP4, XP SP2+, 2003, Vista SP1+, 7, 2008 2.4.x+ 32 bit X11R5 glibc 2.3.2 gtk lcms
4.0.x ? ? ?
3.x ? ? ?
2.6.x[28] 10.2.7 – 10.6.x Intel/PPC, 9.2.2 PPC 98, Me, NT, 2000, XP, Vista 2.4+ 32 bit X11R5 glibc 2.2.4 gtk lcms

iOS and Android targets are available in some versions.

Note: Complete Linux requirements for 4.5.x–6.x are the following:

  • 32-bit installation, or a 64-bit Linux distribution that has a 32-bit compatibility layer
  • 2.4.x or later kernel
  • X11R5 capable Xserver running locally on a 24-bit display
  • glibc 2.3.2 or later
  • gtk/gdk/glib (optional – required for native theme support)
  • pango/xft (optional – required for PDF printing, anti-aliased text and Unicode font support)
  • lcms (optional – required for color profile support in JPEGs and PNGs)
  • gksu (optional – required for elevate process support)

See also

[edit]
  • MetaCard, Runtime Revolution acquired the MetaCard technology, on which its development system is based, in 2003.
  • HyperCard, Progenitor of all xTalk languages.

References

[edit]

Bibliography

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

LiveCode

View on Grokipedia
from Grokipedia
LiveCode is a cross-platform (RAD) environment that uses a high-level, English-like called LiveCode Script to enable the creation of native applications for desktop, mobile, and server platforms, as well as web applications via , including Windows, macOS, , , Android. It features visual drag-and-drop tools for building user interfaces, live editing of running applications, and an extensible architecture with built-in support for , databases, and networking, allowing developers to write up to 90% less code than in traditional programming languages. Designed for accessibility, LiveCode emphasizes ease of use, making it popular among educators, independent developers, small businesses, and enterprises for and full-scale software development. Developed by LiveCode Ltd., a company based in , , the platform originated from earlier tools aimed at democratizing software creation, with the company founded in 1999 and the core development system first released in 2001 under the name . Renamed LiveCode in 2010 to reflect its focus on live, interactive coding, it evolved into a comprehensive IDE supporting a single codebase for multi-platform deployment. The , known for its readable and memorable syntax that mirrors , draws from a legacy of over 25 years in making programming intuitive and efficient. LiveCode gained prominence for its role in education and indie development, with schools reporting doubled uptake in computer science courses using the tool, and applications built with it grossing over $100 million worldwide, including #1 best-sellers, games, productivity apps, and enterprise systems for companies. Although an open-source version was available from 2013 to 2021 to foster contributions, maintenance challenges led to its discontinuation, shifting focus to commercial subscriptions starting at $36.67 per month (billed annually). Today, it continues to support modern features like Android App Bundles, enhanced web rendering, and mobile widgets, positioning it as a versatile alternative for full-stack app development without platform-specific recompilation.

History

Origins and Early Development

Runtime Revolution Ltd. was incorporated on October 13, 1999, in , , by Kevin Miller and a small team of developers with the goal of creating accessible tools. The company, led by Miller as CEO, initially focused on building upon existing technologies to develop a modern (RAD) environment. This effort culminated in the release of the software known as in 2001, which served as an emphasizing ease of use for creating applications across multiple desktop platforms, including Windows, macOS, and . Revolution's foundations trace back to earlier hypermedia and scripting technologies, particularly Apple's , released in 1987, and its associated language from the late 1980s. MetaCard, a commercial clone developed by MetaCard Corporation and first commercially released in June 1992, provided the core engine for Revolution, with its MetaTalk scripting language—debuting around 1993—evolving into what would become LiveCode Script. In July 2003, Runtime Revolution acquired MetaCard's technology and , allowing full integration and further enhancement of the platform without reliance on the original vendor. From its inception, positioned itself as a direct successor to , targeting non-programmers through an English-like scripting syntax that simplified complex tasks like GUI design and integration. This approach enabled and deployment of cross-platform applications, filling a gap left by HyperCard's discontinuation and the limitations of more traditional programming languages. Early versions prioritized desktop environments, supporting seamless development and execution on Windows, macOS, and without requiring code recompilation for each platform.

Key Milestones and Recent Updates

In 2010, the product formerly known as Runtime Revolution was renamed to to better reflect its focus on live scripting and cross-platform development. The company behind it, Runtime Revolution Ltd., underwent a to Ltd. in March 2015, aligning its corporate identity more closely with the product's name. A significant shift occurred in April 2013 with the launch of the open-source LiveCode Community Edition (version 6.0), funded through a successful campaign that raised £493,795 from 3,342 backers to support educational access and community-driven enhancements. This edition, licensed under GPLv3, facilitated free development until its discontinuation on August 31, 2021, with the release of version 9.6.4, after which maintenance ceased and the codebase was archived on . The introduction of deployment in 2015 marked a major expansion for web-based applications, enabled by a 2014 crowdfunding campaign on the company's platform that met its $395,000 goal and raised approximately $400,000 to port the engine to browser environments. Concurrently, the first developer preview of version 8.0, announced on March 12, 2015, introduced LiveCode Builder, a new C++-based language for creating custom widgets and extensions to integrate platform-specific APIs. Version progression continued with stable release 9.6.4 on August 31, 2021, coinciding with the Community Edition's end; this was followed by 9.6.5 RC-2 on October 25, 2021, adding support for compliance. In 2023, version 9.6.9 stable arrived on April 10, incorporating over 75 features, bug fixes, and security updates, including Android API 31 support and 14.2 compatibility. The LiveCode 10 series began with the stable release of version 10.0 on October 9, 2024. Recent updates in 2025 have focused on modern platform support and new tools. LiveCode Classic 10.0.1 stable was released on April 17, enabling builds with any version from 12.4 onward. Version 10.0.2 stable followed on June 13, with further refinements. On August 21, 10.0.3 RC-1 introduced Android 35 support, 15 compatibility, enhancements, and fixes for issues like menus and date/time controls. On October 27, 2025, version 10.0.3 RC-2 was released, enhancing Store compliance with further Android 35 support and bug fixes. Additionally, LiveCode Create, a web-based IDE for cross-platform editing, advanced with developer preview 7 (DP-7) in June 2025 and DP-8 in August 2025, emphasizing deployment and datastore improvements.

LiveCode Script

Core Syntax and Structure

LiveCode Script is a dynamically typed, object-oriented that belongs to the xTalk family of languages, which includes from Apple's as a foundational influence. This heritage gives it an English-like syntax designed for and , enabling developers to write procedural with familiar constructs similar to those in languages like English prose or early multimedia scripting environments. At its core, LiveCode Script operates on a message-passing , where the system sends messages in response to events—such as user interactions or system triggers—and scripts define handlers to process these messages. For instance, a common event handler might respond to a mouse click with the structure on mouseUp ... end mouseUp, allowing the script to execute specific actions like updating interface elements or performing calculations. The basic structure of LiveCode Script revolves around attaching scripts to objects within a hierarchical, stack-based model, where stacks serve as containers for cards, and cards hold interactive elements like , fields, and groups. This object hierarchy defines the message path: when an event occurs, the message starts at the originating object and travels upward through objects (e.g., from a to its card, then to the stack) until a handler intercepts and processes it, or it reaches the engine level. Scripts are written directly in the object's script editor and consist of handlers, commands, and control structures; for example, the put command assigns or outputs values to variables or containers, as in put "Hello" into field "Greeting", while set modifies object properties, such as set the text of [button](/page/Button) "Submit" to "Done". is managed through structures like repeat, enabling loops for iteration, as shown in this example for repeating an action three times:

repeat with i = 1 to 3 put "Iteration" & i into field "Log" end repeat

repeat with i = 1 to 3 put "Iteration" & i into field "Log" end repeat

Variables in LiveCode Script require no explicit declaration and can hold various data types, including numbers (integers or floating-point), (sequences of characters), (associative collections indexed by keys), and lists (return- or comma-delimited sequences). For example, a might store a string like put "user input" into tName, while an could map keys to values as put "red" into tColors["primary"]. Operators support arithmetic operations (e.g., + for , as in put 5 + 3 into tSum), string concatenation (&), comparisons (=, <), and logical evaluations (and, or). Unlike compiled languages, LiveCode Script executes interpretively, and running code directly at runtime without a separate compilation phase, which facilitates and live modifications during development.

Advanced Language Features

LiveCode Script supports advanced data structures including arrays, which can be multidimensional or associative, allowing developers to manage complex datasets efficiently. Multidimensional arrays enable grid-like storage, such as a two-dimensional array for tabular data, while associative arrays use keys for flexible indexing beyond numerical positions. Lists provide ordered collections for sequential data handling, and support facilitates processing non-textual content like images or files directly in strings marked with the "*b" indicator. For , the filter command integrates regular expressions to selectively process lines, items, or elements in containers, enabling operations like extracting addresses from text via regex patterns such as [\w\.-]+@[\w\.-]+\.\w+. Multimedia capabilities in LiveCode Script include built-in commands for handling images, audio, and video. The import command loads graphics into image objects from various formats, supporting bitmap pictures for visual elements. Audio playback is managed through the play command for sounds or the play file command for external audio files, with options to control rate and synchronization using properties like playRate. Video and animations leverage player objects, where commands like play video handle playback, pausing, and stepping through media clips. Database integration is provided via the Database library, formerly known as revdb, which supports SQL operations across engines like , , and . The revExecuteSQL command executes queries for inserts, updates, or deletes, while revDataFromQuery retrieves records into arrays, streamlining data persistence without external dependencies. Networking features encompass TCP/IP sockets opened with the open socket command for low-level connections and HTTP requests via the put command into URLs, which handles GET/ operations with customizable headers. JSON and XML parsing are facilitated by built-in functions jsonEncode and jsonDecode (introduced in 2024 for faster engine-level performance) and dedicated libraries: the Library offers additional capabilities for converting between LiveCode values and JSON strings, supporting encoding; the XML Library provides tree-based parsing with functions like revXMLCreateTreeFromFile for structured document handling. Error handling in LiveCode Script uses a try-catch construct with the try, catch, and end try keywords to trap execution errors and execute alternative code paths. Custom handlers can intercept errors via the errorDialog message or by locking error dialogs with lock error dialogs, allowing programmatic recovery without default UI interruptions. For , custom functions and commands are defined as handlers within scripts, and libraries are created by designating stacks with start using to encapsulate reusable code across applications.

Development Environment

Integrated Tools and Workflow

The (IDE) of LiveCode provides a visual stack editor centered around the Canvas Area, where developers design user interfaces by dragging and dropping widgets such as buttons, fields, and cards from the Tools Palette. This drag-and-drop approach enables of stack-based applications, with the Project Browser offering a hierarchical view for navigating and managing objects across cards and substacks. Complementing the visual tools is an integrated script editor that supports for keywords and variables, auto-indentation for code alignment, suggestions for LiveCode Script elements, and real-time error checking to identify syntax issues during development. LiveCode's workflow emphasizes compile-free development, allowing developers to edit scripts or UI elements and immediately test changes in run mode without compilation steps, facilitating an iterative process of , coding, and refinement. The Property Inspector panel, accessible upon selecting an object, provides a dedicated interface for modifying attributes such as appearance (e.g., colors, fonts, positions), (e.g., states like focused or disabled), and data bindings to variables or sources, with changes reflected instantly in previews. For runtime debugging, tools like the Message Watcher monitor incoming messages to objects, while the Variable Watcher tracks global and local variable states during execution, enabling efficient troubleshooting without halting the application. Prototyping is supported through built-in preview modes, including a simulator for desktop and mobile interfaces that launches the app in a live environment to test responsiveness and interactions across screen sizes. Version control integration with systems such as is possible through external tools or by exporting project elements manually for diffing and merging. Stack files, saved with the .livecode extension, use a binary format that ensures compatibility across all supported platforms, allowing seamless sharing and opening of projects without format conversion. As of November 2025, the primary IDE is LiveCode Create, which is in developer preview (version dp-8), while remains available for ongoing development and deployment.

Extension Development with LiveCode Builder

LiveCode Builder (LCB) is a specialized programming language introduced in LiveCode 8.0 in May 2016, designed to enable developers to create custom extensions for the LiveCode engine, including widgets and libraries that extend core functionality at the system level. Unlike standard LiveCode Script, LCB emphasizes strict type handling, modular structure, and integration with native code, allowing for the development of high-performance components such as custom elements or computational libraries. This extensibility feature addresses limitations in scripting by permitting direct access to engine internals and external APIs, facilitating the creation of reusable, engine-embedded modules. The syntax of LiveCode Builder closely resembles LiveCode Script but incorporates systems-oriented enhancements for robustness and efficiency. It supports optional static typing for variables, parameters, and return values, with core types including Boolean, Integer, Real, String, Data, List, and Array, alongside a flexible any type for dynamic usage. Modules form the building blocks, organized in reverse DNS naming conventions (e.g., com.example.myWidget), and contain public or private declarations for constants, types, variables, and handlers. Handlers define behavior with explicit input/output parameters (e.g., in, out, inout) and can bind to foreign functions in languages like C via the foreign handler syntax, enabling seamless integration with platform-specific libraries for tasks requiring low-level access. For instance, a simple widget module might declare its type and implement core events like on create for initialization or on paint for rendering:

module community.livecode.example.simpleWidget public type SimpleWidget public handler SimpleWidget.onCreate() // Initialization logic here end handler public handler SimpleWidget.onPaint(pSurface as [Canvas](/page/Canvas), pRect as [Rectangle](/page/Rectangle)) // Drawing code using the [canvas API](/page/API) canvas.drawLine pSurface, point(0,0), point(100,100) end handler end module

module community.livecode.example.simpleWidget public type SimpleWidget public handler SimpleWidget.onCreate() // Initialization logic here end handler public handler SimpleWidget.onPaint(pSurface as [Canvas](/page/Canvas), pRect as [Rectangle](/page/Rectangle)) // Drawing code using the [canvas API](/page/API) canvas.drawLine pSurface, point(0,0), point(100,100) end handler end module

This structure ensures compile-time checks for , reducing runtime errors in extension code. Developing extensions with LiveCode Builder involves writing code in .lcb files within the LiveCode IDE's Extension Builder tool, which provides templates, , and compilation support. Developers declare the extension type (widget or ) and identifier at the module level, import necessary APIs (e.g., com.livecode.canvas for graphics or com.livecode.[engine](/page/Engine) for core interactions), and implement event handlers tailored to the extension's purpose, such as geometry changes or data exchange with LiveCode stacks. The IDE compiles the LCB source to platform-agnostic bundled in a .livecodescript , which is then into a .lce file for distribution and integration—extensions can be loaded dynamically into stacks via commands like widget add or installed globally through the Extension Store. Cross-compilation is supported across LiveCode's platforms (desktop, mobile, server), with the handling runtime execution, though foreign bindings may require platform-specific adjustments. Testing occurs directly in the IDE by simulating the extension in a preview stack, allowing iterative refinement before final . Common use cases for LiveCode Builder extensions include performance-critical applications where scripting alone is insufficient, such as implementing advanced data visualizations (e.g., interactive charts with real-time updates) or hardware integrations (e.g., custom sensor interfaces via native APIs). For compute-intensive tasks like , developers can create widgets that offload processing to bound C libraries, achieving native-like speeds while maintaining LiveCode's cross-platform deployment. Libraries extend non-visual functionality, such as optimized mathematical routines or database connectors not natively supported. These extensions enhance the engine's capabilities without altering core code, promoting a modular for specialized needs.

Platform Support

Supported Platforms and Compatibility

LiveCode supports a wide range of desktop operating systems for both running the (IDE) and deploying standalone applications. On macOS, the IDE and engine are compatible with versions from 10.9 () through 15.x (Sequoia), including native support for M1 and later processors introduced in LiveCode 9.6.8 and continued in version 10. Recent updates in LiveCode 10 address specific compatibility issues, such as menu rendering and date/time item display on macOS Sonoma and later, with general support for Sequoia reported as of 2025 though some features may require workarounds. For Windows, support extends to versions 7, 8.x, 10, and 11, with both 32-bit and 64-bit builds available, including 32-bit compatibility via the WoW layer on 64-bit systems. Linux compatibility covers major modern distributions requiring glibc 2.13 or later and GTK/GDK 2.24 or later for graphical interfaces, such as recent , , and releases; various Unix variants, such as those based on BSD or Solaris, are also supported through the engine's Unix underpinnings. Additionally, LiveCode enables deployment on and Unix-based servers without a graphical interface. The latest release, LiveCode 10.0.3 RC-2 (October 2025), includes enhancements for platform stability. For mobile platforms, LiveCode provides robust support for and Android app development and deployment. compatibility includes devices running up to iOS 18, with LiveCode 10.0.2 (April 2025) introducing support for 18.2 and 15 and later versions (from 12.4 onward for broader compatibility), allowing builds that meet Apple's requirements as of 2025. Android support in LiveCode 10.0.3 RC-2 (October 2025) targets API level 35 (Android 15), ensuring compliance with Store policies effective August 31, 2025, and includes updates to use 11 or later instead of requiring Java 8. Deployment to mobile platforms requires a Mac for iOS builds but supports Mac, Windows, and hosts for Android. Beyond traditional desktop and mobile, LiveCode extends to web and embedded environments. HTML5 deployment has been available since the first alpha release in August 2015, enabling standalone web applications that run in modern browsers without plugins, leveraging integration for enhanced interactivity. devices are supported via ARM builds, allowing both IDE operation (on compatible distributions) and standalone app deployment for embedded projects. A key advantage of LiveCode's platform support is that deployed applications are fully standalone, requiring no separate runtime or installation beyond the target OS, which simplifies distribution across all supported platforms. LiveCode maintains strong , ensuring that stacks and scripts created in earlier versions (from 1.0 onward) can be opened, edited, and deployed without modification in current releases like version 10, preserving developer workflows over time. Version-specific updates, such as those in LiveCode 10 for menu fixes, iOS 18 support, and Android API 35 compliance, focus on enhancing stability and adherence to OS vendor requirements while avoiding breaking changes to core functionality.

Deployment and Distribution Options

LiveCode applications are built into standalone executables directly from the (IDE) by selecting the "Save as Standalone Application" option in the File menu, where developers configure settings such as the product name, file description, and target platform before generating the output. These executables have a compact footprint, typically starting around 10-16 MB for basic applications, embedding the LiveCode engine and required resources without additional runtime dependencies. For platforms requiring , such as , developers must integrate Apple provisioning profiles obtained from the Apple Developer Portal to enable distribution and device installation. Deployment formats include native binaries tailored to specific platforms: executable files (.exe for Windows, .app for macOS, binaries for ), APK packages for Android, and IPA files for , allowing seamless execution on desktop and mobile devices. For web-based applications, LiveCode supports HTML5 output, which compiles the app into and HTML5-compatible code runnable in modern browsers without plugins. Additionally, backend scripts can be deployed to servers using the LiveCode Server engine, supporting CGI processing, middleware, and database interactions for web services. Distribution options encompass submission to major app stores like the Apple and for native mobile apps, web hosting services for builds, and direct sharing of self-contained desktop executables via downloads or installers. LiveCode's commercial licensing model enables unlimited distribution without royalties or per-device fees, facilitating broad deployment for both personal and enterprise applications. Recent enhancements include LiveCode 10.0.1 (released April 2025), which removes Xcode version dependencies for iOS builds, allowing compatibility with any from version 12.4 onward to support iOS targets up to 18. For Android, updates in LiveCode 10.0.3 RC-2 (October 2025) added support for API level 35 and improved JDK 11+ detection on Windows, ensuring compliance with Google Play Store requirements for new apps and updates targeting Android 15.

Applications and Impact

Common Use Cases and Examples

LiveCode finds extensive application in educational environments, where its intuitive scripting enables the creation of interactive simulations and e-learning tools that teach without requiring prior coding experience. At , instructors used LiveCode in introductory programming courses for non-technical majors in fields like , , and as of 2015, allowing students to build custom applications tailored to their career needs, such as teaching aids or data analysis tools for . This approach has led to increased student engagement, with some participants advancing to advanced projects or altering their professional paths based on acquired skills. Additionally, organizations like OneBillion.org have developed gamified educational apps with LiveCode, achieving 2 million downloads and ranking #1 on app stores while advancing learning outcomes by up to 18 months in six weeks for disadvantaged children. In business contexts, LiveCode supports the rapid development of database front-ends, interactive kiosks, and multimedia presentations, leveraging its cross-platform capabilities for efficient deployment. For example, ScreenSteps, a platform built with LiveCode, serves companies from small businesses to enterprises by enabling customizable training modules and documentation tools. Similarly, KLM's flight booking system, powered by LiveCode, processes over 70,000 daily reservations for 28 million annual passengers, demonstrating its reliability in high-volume data handling and user interfaces. These applications often include custom CRM systems or reporting tools, where LiveCode's English-like syntax accelerates prototyping and iteration for non-specialist developers. For mobile development, LiveCode excels in prototyping and Android applications, particularly for utilities and casual games, building on its heritage as a successor to for card-based, stack-oriented user interfaces that facilitate quick visual iterations. The Gluggy app, developed for sole traders to manage invoices and expenses, was created rapidly with LiveCode to incorporate user feedback and deploy across platforms. In gaming, ' Midnight Rises achieved over 600,000 downloads and top-5 App Store ranking within three months of development, highlighting LiveCode's efficiency for multimedia-rich mobile prototypes. A representative example of LiveCode's strengths is a script that dynamically builds a list from user input, showcasing how minimal code can handle events and update interfaces iteratively. In a stack with an input field named "InputField" and a list field named "ListField", the 's mouseUp handler might use the following script:

on mouseUp put the text of field "InputField" into tNewItem if tNewItem is not empty then put tNewItem & return after the text of field "ListField" put empty into field "InputField" -- Clear input for next entry end if end mouseUp

on mouseUp put the text of field "InputField" into tNewItem if tNewItem is not empty then put tNewItem & return after the text of field "ListField" put empty into field "InputField" -- Clear input for next entry end if end mouseUp

This code captures user-entered text on button click, appends it as a new line to the list field, and resets the input, enabling instant feedback and extension for more complex list management.

Community, Licensing, and Limitations

LiveCode maintains an active user community primarily through its official forums at forums.livecode.com, which feature dedicated sections for beginners, advanced scripting discussions, documentation improvements, and tutorials, with 134,716 registered members and ongoing threads as of November 2025. Tutorials and learning resources are hosted on livecode.com, including lessons and user-contributed examples that support both novice and experienced developers. Following the discontinuation of the free Community Edition on August 31, 2021, the platform shifted to a fully proprietary model, reducing open contributions but preserving legacy open-source access via livecode.org, where the final version (9.6.x) is archived on GitHub without further maintenance. Licensing for LiveCode operates on subscription-based tiers tailored to different users, including a Create/Standard plan at $36.67 per month per seat (billed annually) for in-house development, an Apps for Sale option with a 5% revenue share on earnings plus $36.67 per month per developer, and plans starting at $500 annually for up to 20 seats. A free trial is available for new users to test the platform. The model has been fully commercial since the 2021 end of open-source editions, though it originated from a successful 2013 campaign that funded the initial Community Edition release. Despite its strengths in , LiveCode has limitations in performance for high-compute tasks, such as processing large datasets or complex graphics, where it can exhibit slowdowns compared to natively optimized languages like C++. These issues can be mitigated through LiveCode Builder extensions, which allow integration of C++ code or OS APIs for enhanced speed in demanding scenarios. The remains smaller than that of mainstream languages like or Swift, with a niche user base limiting third-party libraries and community-driven tools. The discontinuation of the free edition has created a notable gap, as it previously fostered broader participation and contributions. LiveCode's English-like scripting enhances accessibility for non-coders entering app development, enabling quick prototyping without deep programming knowledge. However, advanced integrations, such as custom APIs or high-performance modules, present a steeper requiring familiarity with its stack-based architecture. In comparison, the 2023 no-code tool Xavvi, built on LiveCode and incorporating AI for app generation, further reduces barriers for beginners while maintaining compatibility with LiveCode's code for hybrid workflows.

References

  1. https://livecode.com/
  2. https://livecode.com/about/
  3. https://pitchbook.com/profiles/company/64689-04
  4. https://www.theregister.com/2021/09/06/livecode_interview/
  5. https://beta.docs.livecode.com/docs/
  6. https://livecode.org/
  7. https://livecode.com/pricing/
  8. https://find-and-update.company-information.service.gov.uk/company/SC200728
  9. https://livecode.com/new-york/speakers/kevin-miller/
  10. https://www.macworld.com/article/163740/revolution-4.html
  11. http://www.metacard.com/faq1.html
  12. https://www.mactech.com/2003/07/08/runtime-revolution-acquires-metacard-technology/
  13. https://www.macworld.com/article/165072/revolution-5.html
  14. https://www.kickstarter.com/projects/1755283828/open-source-edition-of-livecode
  15. https://forums.livecode.com/viewtopic.php?t=14667
  16. https://forums.livecode.com/viewtopic.php?f=4&t=36261
  17. https://livecode.com/livecode-to-html5/
  18. https://www.crowdfundinsider.com/2014/07/43324-livecode-raises-26000-within-first-24-hours-new-crowdfunding-campaign/
  19. https://forums.livecode.com/viewtopic.php?t=23580
  20. https://forums.livecode.com/viewtopic.php?f=4&t=36401
  21. https://livecode.com/livecode-9-6-9-released/
  22. https://www.facebook.com/livecodesoftware/posts/920009903456932
  23. https://livecode.com/livecode-classic-10-0-1-stable-and-10-0-2-rc-1-released/
  24. https://livecode.com/2-releases-deployment-begins-with-dp-7/
  25. https://livecode.com/android-support-updated-new-create-preview-release/
  26. https://livecode.com/livecode-10-0-3-rc-2-play-store-compatibility/
  27. https://nestria.org/pages/language-livecode
  28. https://livecode.byu.edu/transcript/Transcript1.php
  29. https://lessons.livecode.com/m/4603/l/565724-the-livecode-message-path
  30. https://beta.docs.livecode.com/docs/LiveCode%20Script/Control%20Structures/on
  31. https://beta.docs.livecode.com/docs/LiveCode%20Script/Control%20Structures/repeat
  32. https://livecode.byu.edu/arrays/introToArrays.php
  33. https://ia804503.us.archive.org/11/items/livecode-byu/Beginners%2520Guide%2520%25EF%2580%25A7%2520LiveCode.pdf
  34. https://future.livecode.com/dp2-json/
  35. https://docs.livecode.com/guides/Platform/Key%20Concepts/
  36. https://docs.livecode.com/guides/Platform/LiveCode%20Create%20Platform/App%20Building%20Environment/Script%20Editor/
  37. https://docs.livecode.com/guides/Platform/LiveCode%20Create%20Platform/App%20Building%20Environment/Property%20Inspector/
  38. https://livecode.com/introducing-livecode-8/
  39. https://livecode.com/topic/livecode-builder-language-reference/
  40. https://livecode.com/topic/extending-livecode-guide/
  41. https://forums.livecode.com/viewtopic.php?t=39606
  42. https://lessons.livecode.com/m/4603/l/44282-building-standalone-applications
  43. https://forums.livecode.com/viewtopic.php?t=35269
  44. https://lessons.livecode.com/m/4069/l/32957-how-do-i-create-a-distribution-profile-for-ios
  45. https://lessons.livecode.com/m/4071/l/800867-how-do-i-put-my-first-app-on-the-web
  46. https://forums.livecode.com/viewtopic.php?p=139504
  47. https://lessons.livecode.com/m/4069/l/32692-how-do-i-create-an-android-app-for-distribution
  48. https://livecode.com/store/livecode/livecode-pro
  49. https://livecode.com/wp-content/uploads/2013/05/brigham-young-university-white-paper.pdf
  50. https://livecode.com/brigham-young-university/
  51. https://livecode.com/studies/
  52. https://lessons.livecode.com/m/4603/l/565738-using-fields
  53. https://lessons.livecode.com/m/4603/l/565728-scripting-a-button
  54. https://forums.livecode.com/
  55. https://www.reddit.com/r/livecode/comments/pf9ox6/livecode_community_edition_no_longer_available_as/
  56. https://livecode.com/standard-plan/
  57. https://www.getapp.com/development-tools-software/a/livecode/
  58. https://livecode.com/education-plans/
  59. https://www.g2.com/products/livecode/reviews?qs=pros-and-cons
  60. https://forums.livecode.com/viewtopic.php?t=35526
  61. https://forums.livecode.com/viewtopic.php?t=36111&start=150
  62. https://www.quora.com/What-are-the-pros-cons-of-using-Livecode-6-0-for-app-development
  63. https://livecode.com/xavvi/
  64. https://livecode.com/xavvi/xavvi-vs-livecode/
Add your contribution
Related Hubs
User Avatar
No comments yet.