Learn How You Can Make Your App Building Talent Go 3X Further
Our customers save an average of $38,250 per project
data gathered from customer survey – sample size 421
Whatever software you build – native mobile apps, desktop apps, cloud, client-server tools, data front-ends, data aggregators, consumer apps, we guarantee that we can help you to save a great deal of development time. But don’t take our word for it.
Our customers told us that their savings started from a thousand dollars on micro projects, up to $2 million on one large-scale project. We believe this comparison stacks up against all other tools and frameworks. We asked our customers to make this comparison to any other tool or language – whatever they thought would be the next best tool or language of their choice for their project if LiveCode had not been available
We’ve been able to deliver these cost savings because we take a unique approach to software development. Please read on to learn about some of the main issues with software development today and how we solve them for you.
How will you benefit from saving two thirds of your development time and cost?
It’s a competitive marketplace. Our customers told us that being able to build your software faster helps them to be much more competitive. In some cases small LiveCode-based development teams are taking on teams 3x or 4x their size. If you are like our customers, we know you can benefit:
- Get your software to market much quicker
- Make your small team competitive with a large team
- Do projects which would otherwise not have been commercially viable
- Do three times more with your valuable development budget
- Adapt in near real time to rapidly to changing client requirements
- Demonstrate changes to clients in front of them
- Spend more time doing other things inside or outside your organization
How Can LiveCode Deliver You Greater Productivity
To understand the answer to that question you need to understand what LiveCode is and where it is positioned. LiveCode is both a language and a framework. It delivers executable native apps with the LiveCode Virtual Machine embedded. It occupies a unique position in the software development tools space.
There are many fantastic drag drop app tools (Cookie cutters) where no programming experience is required but there are limits to what you can achieve. The basic tool can only do so much.
There are some wonderful programming languages (some of which we use to build LiveCode), more traditional in nature, that are quite slow to develop with, you need to be a programmer to use them, but there are no limits to what you can achieve.
LiveCode sits in the middle. It offers a visual development environment to quickly bring an idea to life. The programming language is as powerful and as fully featured as most traditional languages like C and Java, but LiveCode is based on English making it intuitive and quick to learn.
What are the Everyday Benefits of Live Editing?
Consider the traditional software development cycle. You’re probably familiar with it, it goes something like this: Edit, compile, run, navigate, debug, repeat. How about just edit your app live? No distractions, just:
Uninterrupted productivity. This is LiveCode’s alternative and it is so simple. This is an obvious benefit, familiar to you if you have spent days, weeks or months in the more traditional cycle. Beyond this obvious benefit, many of the benefits of live editing only truly become apparent to you when you have tried it for yourself. The feeling the whole process delivers is less taxing, smoother and easier to use. Did you know that changing context is one of the most expensive cognitive operations for humans to do? If you’re working on a task that takes high concentration, it can take 20 minutes to get back into the zone if you are interrupted, for example by a phone call or a colleague. That’s why many software developers like to turn off their phones and work alone to concentrate on a tricky problem.
Yet what you may not realize is that the traditional software development cycle has these interruptions built right into the process! When you move from making a change on your software to recompiling it and running it, recompiling introduces an interruption of a few seconds right up to an hour depending on the size of your application. Then you need to find your place again in the software and reset the state of the application to whatever state you need it to be in. Perhaps you need to reload data, download information from the cloud or click through what might be a sophisticated user interface screen by screen, to run the part of your application you need, to finally see if your code works.
Once you’ve done that, you have to go back to your editing environment and make changes. You may then need do that over and over again. It’s not just the time it takes to do this that is lost, it is the increased cognitive load on you, the developer. You have to store more in your head to handle this context switching over and over every day. Modern day compilers do have facilities like fix and continue to help with this, but they work in limited circumstances.
You’ll Love Editing Logic & Your UI Live
The LiveCode workflow is designed to be granular from the ground up. You can literally edit the user interface while the program is running, together with the code itself.
You will benefit from:
- Making changes to your code and continuing immediately
- Retaining the state of your variables during code editing
- Making hundreds or thousands of changes in a day without having to ever start at the beginning
- Never waiting for a compile
- Never losing your place
- Changing your user interface live while your library code retains the state of all of your variables, calculations and current context
- Building an entirely new set of views for data and being able to start populating the from an array you built and left in memory at the start of the week
- Breaking things and fixing them faster without fear of breaking your whole application
Once you try it and get used to it we know you won’t want to go back.
Independent Research Proves LiveCode is Simpler
According to independent research carried out by the Southern Cross University Australia and the University of Newcastle, when using LiveCode you require less brain power to achieve the same tasks as other programming languages
A 2016 peer reviewed study conducted at Southern Cross University Australia and University of Newcastle found dramatic differences in the total cognitive load – i.e. the ongoing cognitive effort required – to develop applications in LiveCode compared to other tools. LiveCode did not sponsor this study and was not involved in any way in its creation.
The following extract from the results shows that while LiveCode has only slightly fewer steps involved in completing a given task, the cognitive impact of doing each of those steps is very greatly reduced.
“The process described in this paper has been used to compare the relative cognitive loads imposed by several language/IDE combinations in performing a range of programming tasks. The objective is to enable normalised comparisons and contrasts between combinations”
“LiveCode has the fewest steps, and the fewest above the threshold. LiveCode scaffolds tasks well using code skeletons, the code is more like English than in many programming languages, and there is extensive on-screen context-sensitive help, all of which contribute to this result.”
This all means less effort for you each day to achieve the same results. Which means you will enjoy much higher productivity and less frustration, day in, day out.
Write Fewer Lines of Code
If I had included a programming language specification when we introduced the World Wide Web, it would have been like LiveCode. Millions of man hours of productivity would have been saved.”
Robert Cailliau
Co – developed the WWW at CERN with Tim Berners-Lee
How Does LiveCode’s English Programming Language Compare to Other Languages?
Traditional programming languages are very powerful and have enabled millions of software applications to be written. However it is our passionate belief that for many software projects they are over complicated, requiring you to go to a great deal of effort to learn them, write code and read it later. For example, the human mind is not naturally good at working with symbols. Every semicolon or bracket required by a language introduces another potential source of error, each one of which takes time to locate and correct. Each symbol essentially adds another step, similar to adding another word to the sentence.
LiveCode reduces this friction as you work by striving to be as close to English as possible. This mirrors how you think and communicate naturally every day. We have reduced symbols to a minimum. This reduces the number of inadvertent errors you can make during the development process. Even more importantly, it makes reading code far more rapid. Programmers spend more time reading code than writing it, so this is very important, especially when it comes to sharing or maintaining code.
There is a popular myth in some programming circles that an English-like language is verbose, and that this verbosity is slower to write and reduces developer performance. As you can see from the LiveCode examples below, nothing could be further from the truth.
You can see why Robert Cailliau said what he did from the following code comparisons, between LiveCode, JavaScript, PHP and Java.
It may be that you are familiar with one of these languages and so when you look at the code it looks and feels familiar and easy to create the example we show. That’s perfectly natural and these languages have their strengths. However please try to keep an open mind when you compare the language to the LiveCode comparison. While the LiveCode example does take a little effort to learn, it replaces an entire block of code in each case with a single sentence. Hopefully it is clear that taking the time to learn it now will greatly boost your productivity and the readability of your code.
Compare The Code
In the following example we show you how to sort the lines of comma separated text in reverse alphabetical order. An “item” in LiveCode is text separated by comma (comma is the default, you can choose any delimiter including a word).
Here’s how you do this using just 1 line of code in LiveCode
sort lines of theText descending by last item of each
You use 90% less code with LiveCode. Here’s what you have to do in other languages to achieve the same result
theText = theText.split(”\n”);
theText = theText.sort(sort_item_3).join(”\n”);
function sort_item_3(line1, line2){
line1 = line1.split(”,”);
line2 = line2.split(”,”);
if(line1[2] == line2[2]) return 0;
else if(line1[2] > line2[2]) return -1;
else return 1;
}
Why would you choose a Very High Level Language?
Traditionally, the view of high-level languages is that they tend to make complex programming simpler, while lower level languages tend to produce more efficient code. And traditionally very-high-level languages tend to be limited to use within a very specific application. LiveCode sits uniquely within this spectrum in that it provides a very-high-level language, yet one that can be used for an unprecedentedly broad range of software development tasks.
LiveCode is unique in this respect, no other language is as high-level as LiveCode while supporting the same breadth of features and GUI capabilities. In comparison to LiveCode, JavaScript is a low level language and Java a very low level language! Yet LiveCode has similar capabilities to these languages. The language is much closer to English than other scripting languages such as Python and includes rich, sophisticated GUI capabilities and a drag-drop editor not present in these alternatives.
How can you be sure you choose the Right Language for the Job?
If you’re like many software developers, it is quite natural to want to choose a language that you are familiar with in order to complete a task. After all, you probably spent considerable time and effort learning that language and rightly feel good about that effort and your level of knowledge. Familiarity with a tool or language is consistently listed as one of the primary factors given by most developers when choosing a solution to a given task.
Here at LiveCode we understand that reason for choosing to use a language. It is only natural to use what you know. Yet we also see time and again software projects written in a language that is more complex than truly necessary to complete that task. And we hear stories of developers who come to LiveCode having spent months working on a given project, only to complete it from scratch within a few days.
In one case I recall a story of a developer who had spent a year working on an application in C. The company hiring him ran out of budget and was going to abandon the project. They discovered LiveCode and completed the app within two weeks. Now using C is an extreme comparison, as any higher level language will be faster, however if you look at the code examples on this page you’ll see that LiveCode compares very favourably to all the other high level languages available today – it is a level higher.
The best and most successful programmers are the ones who are naturally curious, and who therefore are able to consistently choose the right language for the job. As a rule of thumb, you should always choose the highest level language that you can for any given task, but no higher. In other words, you want a language that is as simple as you need it to be to complete that task but no simpler.
If you’re able to make that choice consistently you will save countless hours throughout your career. It does mean learning and becoming familiar with a number of languages. As the highest level, most English-like language available today with such a broad range of features for app development, can you afford not to have the LiveCode option in your toolbox? We’re not suggesting you stop using anything you have learned, instead we would like you to add LiveCode to your toolbox so you can benefit from it when the right projects come along.
If we had chosen C++ to do it we would be looking at year or two of effort..we were way over budget. So I said…we’ll do it in LiveCode and get it done in about 8 weeks”
Charlie Faddis
Technology Director and co-founder of Prototek Corporation
10 Things to Save You Effort in LiveCode Script
1. Enjoy The Simplest Text and Data Manipulation in the World
It’s a bold claim. It’s one of LiveCode’s greatest strengths. And it is something that you can learn to use really quickly because it is so simple and easy. Unique among multiplatform programming languages, LiveCode understands text in the same way you do: characters, words and lines
Imagine retrieving words from a paragraph, inserting text after a line, or finding whether text begins with a particular phrase using simple natural language. That’s exactly how LiveCode works. It’s hard to appreciate how useful this feature is until you’ve tried it. It will save you time over and over every day.
put "Hello" is in "Hello World" — outputs true put word 3 to 6 of "The quick brown fox jumped over the lazy dog." — outputs brown fox jumped over put "Hello World" begins with "Hello" — outputs true put "Z" is among the lines of theAlphabet — outputs true if Z is found on a line within theAlphabet exactly
We call this type of text and data manipulation “chunk expressions”. Unlike their cousin regular expressions, chunk expressions read like natural language and so are very easy to create and debug. Remember, natural language means far less thinking and far fewer lines of code. Want more evidence? Compare more text processing examples to familiar languages. They scale up well to larger data sets and inputs in just about any format.
In addition to chunk expressions, LiveCode has full support for regular expressions, XML, JSON and a wide variety of other formats. The language supports nested arrays so you can make constant time access to large data sets. A full set of array processing commands is present, including split and combine to convert arrays to and from text, add, matrix multiple, transpose, union and more.
2. Your Code is Simpler with Automatic Variable Type Conversion
As you will be aware, most software requires manipulation of both strings and numbers. LiveCode supports both with a twist – type conversion is internal and automatic. You can refer to a variable or parts of it as either a string or a number. For example:
put 1 + 1 into tSum — puts 2 into tSum put " is the sum of 1 + 1" after tSum — tSum is now “2 is the sum of 1 + 1” add 5 to word 1 of tSum put “+ 5” after tSum — tSum is now “7 is the sum of 1 + 1 + 5”
If you need to work with data coming in and out of LiveCode we provide you the full range of features for converting binary, compressing and decompressing, encoding, generating digests and so forth.
3. You can Execute a String Containing Language Statements
The ability to build up a list of commands as a string and then execute that string is an incredibly important feature of LiveCode. Although you may not need to use it very often, when you do need it this one feature can save you from writing dozens or even hundreds of lines of language statements. In LiveCode, you can use the “do” command to execute strings, and the “value” function to evaluate strings as expressions.
4. Programming Errors Don’t Waste your Time Crashing
The worst use of your time is going around in a loop as your program crashes and having to keep restarting it while debugging. In LiveCode an error will break into the debugger showing the issue and state of the current execution context. Crashes are rare. And if you do encounter a crash that should always be reported as we consider those to be a bug in our code and our responsibility to fix!
5. Enjoy Our Super Flexible GUI Toolkit
With LiveCode you get full native theme support for desktop (Windows, Mac & Linux), together with a subset of native mobile controls such as native scrollbars, fields and web view. The web view allows you to wrap and interact with web content using the latest web technologies. Third party toolkits are available covering a range of natively themed mobile controls. We also include full support for bitmap and vector graphics, interactive multimedia, table, form and grid views, a tree view and dozens of other controls out of the box.
<
LiveCode gives you deep flexibility over your GUI, including complete capabilities to create, edit and delete controls at run time and the ability to create your own controls that perform any function you may require. There are two ways to create your own controls: for simpler objects you can aggregate LiveCode script objects, and for more complex reusable controls you can create widgets (see below).
The GUI toolkit also includes everything you would expect to work with the range of devices and operating systems that LiveCode supports. We support building responsive user experiences, including the ability to automatically scale content, format it to fit a variety of screen formats or use resolution independence on retina and high DPI devices.
6. Connect Your App to Anything
No matter where your data is stored, no matter what system you need to connect to or what format the information is in, you can access it with LiveCode. You can connect to Web services and Restful API starting from one line of code.
put URL "https://www.livecode.com" — retrieves the HTML source of this web page ready for manipulation OAuth is included out of the box. So is support for sockets. A chat application starts in under 10 lines of code: accept connections on port 1987 with message chatMessage And to intercept the corresponding message that is generated: on chatMessage s read from socket s with message chatMessage end chatMessage
tsNet, the networking layer in LiveCode, gives you efficient, multi-threaded, asynchronous requests to any web service using all popular protocols, including http, https, ftp, sftp, SMTP and more. Secure versions of all protocols are included, as is the ability for you to directly manipulate encrypted data using the security layer. You can encode and decode data in all popular formats.
While we generally recommend that SQL database access takes place through a web service, direct access drivers for SQLite, Postgres and MySQL is also included.
You can also access serial ports on desktop platforms, Bluetooth on Mac/iOS (Business only), inter-process communication, the terminal, and connect to lower level APIs written in other languages such as Java or C (see below).
7. Each Line of Script You Write Benefits from Highly Optimized C++
There is a lot of code in the LiveCode engine, which is all code that you don’t need to write. The LiveCode virtual machine sits somewhere between a compiled and interpreted language. LiveCode script statements call directly into the LiveCode engine, running highly optimized C++ code. A single line of LiveCode Script might execute dozens or hundreds of lines of C++ which have been carefully optimized for performance.
This approach delivers your app incredibly high performance that is an order of magnitude faster than a purely interpreted language. Yet LiveCode achieves efficient resource usage. When building a single-file, native executable app, LiveCode includes the virtual machine within the executable.
8. Object-Oriented Behaviors Give Your Team Code Reuse
If you are designing a simple application or writing throwaway code it is generally quicker to include your user interface code directly within the objects. However as you’re probably aware, when you’re building complex software that is intended for production use or for work within a team, in common with other frameworks we recommend the separation of interface elements from code.
LiveCode makes this easy for you with our support for Object-Oriented Behaviors. Object-oriented behaviors allow you to create behaviors for objects that are stored outside your user interface and reused.
Behaviors themselves can be chained together to create complex reusable objects (for example you can include data access features in one layer and platform specific UI interactions in separate chained layers).
We recommend you structure your behaviors to store your scripts in text files (using “Script only stacks”) so that you can work with this code within standard source control systems such as Git.
In addition to building object-oriented behaviors in LiveCode Script, you can also create fully reusable objects from scratch using widgets and LiveCode Builder (see below).
9. Fully Unicode Compliant for Easy International Apps
Everything in LiveCode is 100% Unicode compliant.. We support conversion into and out of all character sets for interacting with external data sources, other systems and APIs. Within LiveCode manipulation is automatic. LiveCode’s trueWord feature correctly detects word boundaries in any language, using the international Unicode standard (implemented using IBM’s ICU library).
The sentence construct processes sentences correctly for any language. This support for Unicode also extends to within the scripting language itself. You can declare variable names in any language (even in Chinese or Japanese), or embed international strings directly within scripts and everything will just work.
10. Rich and Deep Language Saves You Effort
While you only need to learn a few dozen simple terms to start to be productive in LiveCode, in total there are around 5000 keywords built-in. That is 5000 less things for you to have to write, source a library for or think about.
Having access to so many built in features means you are able to work with a huge range of data formats, device operating systems, graphic types and more, all without having to leave LiveCode’s incredible live editing environment. Run, edit and interact live with a rich and deep language that gives you power and control over the operating system and device APIs.
You can Extend LiveCode with Widgets, Java, C and System APIs
I hope that by now LiveCode Script (LCS) is sounding really interesting. It is a fabulous language with a rich and set of built-in capabilities, all of which will save you so much time and effort. You can join our customers and build sophisticated applications with hundreds of thousands of lines of code – typically replacing millions of lines of code that would be needed in another language. Many applications are implemented from beginning to end in LCS without any need to go outside LiveCode at all. That’s great – if you remember my rule above, to always use the highest level language you can for a given task but no higher, you’ll want to stay in LiveCode Script for as much time as possible.
However there are times when you simply have to get under the hood and have more access to the machine, for example to interoperating with an API written in another language. For this purpose we have LiveCode Builder, a systems level variant of the LiveCode language which is lower level than LiveCode Script. It has features that are more familiar to traditional programmers, such as optional strict variable typing. You can use it to create reusable “black box” functionality in the form of new objects, libraries, access less frequently used OS APIs, or wrap a specific library written in another language such as Java or C.
LiveCode Architecture
Reusable Widgets
The widget architecture in LiveCode Builder allows you to implement native LiveCode objects that behave in the same way as objects implemented within the core LiveCode engine, but without having to use C or C++. Widgets use a 2D canvas syntax with 2D vector paths, standard geometric primitives, sub pixel positioning, colors, gradients, patterns, bitmap effects, affine transforms, image painting and text measurement. Widgets can be installed into your standard tools palette using the Extension manager.
This allows you to build robust, flexible objects that work on any platform with any type of user interaction you or your customer can imagine.
Reusable Libraries
LiveCode Builder libraries allow you to add new “engine” commands to the LiveCode language without having to resort to using C or C++. You can use the lower level Builder language to implement functions and commands that are not suited to being implemented in LiveCode Script.
Java & C Connectivity
LiveCode Builder allows seamless integration of libraries written in C and Java (Java support is NEW from LiveCode 9 DP6 onwards). You can easily wrap libraries written in C or Java directly within LCB with a little glue code, without having to use platform specific tools or compilers to do so. (In addition to the LCB bridge to C you can also wrap C code using the old style Externals interface.)
For an example of how you can use LCB to connect directly to Java on Android and access the Battery Status Indicator Android API, check out our blog.
Integrates with your Standard Workflow Tools
LiveCode integrates well with whatever source / version controls tools you may use. However it is important that you design your project to be used with these tools from the start so that your scripts are structured to be stored in text files and not in binary stacks so your team can see differences when using tools such as Git. We recommend you start by using the free Levure framework to start to structure your application in this way.
Outstandingly Multi-Platform
There are many multi-platform frameworks available, yet few bring you the same diversity of platforms and modes of operation as LiveCode. LiveCode builds GUI applications for Windows, Mac and Linux desktops. It also builds GUI applications for iOS and Android devices. In addition to GUI mode, LiveCode applications can run from the command line, can run as background processes and run server side. The server side engine can be used to automate tasks, provide web services or bridge LiveCode (or other) GUI applications to any backend service. The server engine can also run embedded within an HTML web page like PHP, with the tags being executed and replaced on the server as the page loads. Finally, LiveCode can also build web apps with HTML5 deployment .
In practice this flexibility means you can use LiveCode anywhere in your application process, or indeed use it throughout your entire application suite – i.e. reusing the same code libraries in your client, server and cloud application code.
Learn and Benefit from a Proven Return on Effort
I would like to tell you that you’ll be up and running in LiveCode and productive within a few minutes. But the reality is that anything that is worth doing requires some effort. If you’re an experienced software developer then typically our experience is that you can learn LiveCode and start to be productive within about two weeks.
If you’re busy then the easiest way to pick it up is to devote a couple of hours a week to starting out writing an app, using our learning materials, our lessons portal and the forums. The process is fun, interesting and rewarding. Once you’ve mastered the basics you’ll find the process of adding to your application enjoyable. You’ll add a fabulous new tool to your toolbox which you can use time and again to gain countless hours of productivity throughout your career.
We Also Recommend These Books
Companies Who Have Used LiveCode
Take a look at these success stories
Over 9/10 customers recommend us
“In some cases we’ve delivered feature requests in just a few hours after hanging up the phone with the customer; if we were using Java we would have still been defining our classes.”
Richard Gaskin, Webmerge
“I planned to develop the app within three months and ended up finishing it within three days.”
Konstantinos Blatzonis, Apptaurus
“If we had chosen C++ to undertake this work we would be looking at year or two of effort to design such a thing. And we were way over budget and behind schedule. So I said, we’re not going use C++, we’ll do it in LiveCode and get it done in about 8 weeks. Which we achieved – well perhaps in 12 weeks!”
Charlie Faddis, Prototek
“LoadChecker performs all the checks in under 5 seconds that used to be done, by three people for two hours each.”
Ivar Tillotson, Landsat
“A powerful advantage of using LiveCode is the ability to deploy to multiple platforms from a single source base. It has enabled us to build our software with a much smaller team and kept us agile. Our time to market is shorter than our competitors and our costs are considerably lower.”
Mark Talluto, Canela Software
“We had the idea of the graphic novel app but with all our engineers committed to our 3D game, we could only spare one developer. With just 3 months to complete the app we went looking for a tool suited to the task. LiveCode was perfect, with visual authoring and high level scripting: we were able to work quickly and iterate often.”
Alex Seropian, Midnight Rises
“This was all developed without a single line of code being written by a software engineer. The entire application was conceived, designed and authored by a single Naval Warfare subject matter expert in just a few of months. This could only have been done using LiveCode. The richness of the LiveCode command library and the simplicity of its IDE has made it possible.”
Gregory Warneford, US Navy
“I think LiveCode made it possible for our organization to produce this app. Without it, we wouldn’t have had the ability to do it. No one in our organization would have had the time that would be required to do an app from scratch using Xcode or one of those other options. The development time was relatively quick. …The experience was really good. With the forums, I was able to get answers to the major questions I had during the development process.”
Adam Hyde, Safe Boating
“We chose LiveCode because it addressed all of our needs. It is cross platform, can run on the server side, and was an ideal choice for our thin client and cloud based software architecture.”
David Beck, Rotunda Software
“We started looking around for solutions to make our development efficient, scalable, and versatile. We are a relatively small team … so we needed one solution to cater for our time constraints and the team’s capacity. LiveCode seemed like a suitable solution… After doing some trials,we were convinced … so we continued!”
Neal Taylor, Hands on Turkish
“LiveCode is a cost cutting tool that allows us to provide a far better experience to our users than the alternatives.”
Encres Dubuit, ERP Systems
Awards Include…
Best Coding Tool
Jolt Productivity Award for Best Coding Tool: Presented by Dr Dobbs, the annual Jolt Awards have honored software products since 1990, highlighting those tools that are truly functional and ahead of the curve.
Editors Choice – 5 Stars
LiveCode is what we imagine that old Apple freebie, Hypercard, would be like today. It has a similar drag and drop interface, the same card metaphor for application screens and object based programming tools. It can even import old HyperCard stacks.
Editors Choice
“Whatever software you want to create, LiveCode makes it possible.” As stated by MacUser Magazine, the UK’s preeminent technology magazine focused on Apple products and services, which awarded LiveCode its Editor’s Choice Award for scripting languages.
As Featured In…
Join our Community of
Over 100,000
When you learn LiveCode, you are not just adopting a new platform, you are joining a community – a vibrant and growing community. I’ve been told over and over again that we have perhaps the most friendly and welcoming community in the software development world. Join our Forums, or check out our Resources page for other ways to get involved.
Free Trial
Try a free trial of LiveCode with interactive tutorials to get you started.