Skip to content
This repository

LILCard is a painting, hypermedia and database hybrid aka a HyperCard clone

branch: master
LILCard: A painting, hypermedia and database hybrid

0. Contents
  1. About
  2. Documentation
  3. Building
  4. Contact

1. About
   LILCard is a "painting, hypermedia and database hybrid", or in short, a
 HyperCard clone.  HyperCard was a fairly popular... painting, etc program of
 the late 80s and early 90s that was (at least initially) distributed for free
 with every Macintosh computer.  LILCard is the product of a few days of work
 after i learned about HyperCard and what it was all about.  Because of that,
 do not really expect any well thought environment or stable performance :-)

   LILCard is written in Lazarus and FreePascal and uses FPLIL, the FreePascal
 implementation LIL and the LazHelp hypertext documentation viewer which
 enables a program to have the documentation embedded in the executable.  This
 was a major goal with LILCard (i mean, beyond just wasting time...): to be
 self-contained in a single executable file.  The make-<system>-release scripts
 create single executable files (or DMGs in the Mac OS X case) that contain
 everything needed for LILCard to run.  Because of this, both the Windows and
 the Linux versions are released as plain executable files instead of archive
 files (however to save space they are compressed using the UPX executable

2. Documentation
   LILCard contains both a guide and a reference in its help site, accessible
 from the "Contents" option in the "Help" menu.  The documentation contains a
 simple introduction to LILCard (although a tutorial is currently missing) and
 a simple introduction to the LIL scripting language.  For further details on
 the language, a link to the latest readme.txt file in LIL's GitHub repository
 is provided.

   The reference contains documentation for every function available to LIL
 scripts under LILCard, including the functions that LIL itself provides.  For
 every function, a brief description, syntax, full information and a simple
 example are provided and most of the functions also contain links to other
 functions of similar interest.  This should make learning the scripting
 language easier.

3. Building
   To build the source code of LILCard you will need the latest release
 version of Lazarus and the FreePascal version that Lazarus designates as
 being supported under it (that would be the latest FreePascal version in most
 cases, but sometimes a new FreePascal version is released between Lazarus
 releases and it takes a while for a compatible version to appear).  Under
 Windows all releases of Lazarus come bundled with a proper FreePascal
 release.  Please note that many Linux distributions include older or badly
 configured Lazarus versions (threads about how to make Lazarus run under
 Ubuntu are very common in the Lazarus forums and mailing list).  The best
 option is to download and install manually the FreePascal binaries and build
 Lazarus from source (after FreePascal has been installed, building Lazarus is
 a matter of typing "make" and waiting some seconds).  You don't need to have
 Lazarus installed system-wide (i usually don't do that under Linux).  However
 you might need to modify the make-blah-release scripts a bit to point to the
 proper directories.

   Once you have Lazarus and FreePascal properly installed (if you are not sure
 just try to make a simple app with a window and a button that displays a
 message by calling ShowMessage('Hello, World!') from the OnClick handler - to
 create the handler just double click on the button) you need to download and
 install the LazHelp, FPLIL and ChunkIO packages.  The packages can be found
 as repositories in my GitHub account at:
 Use the Package -> Open Package File menu option to open the .lpk files from
 each repository and press the Install button on each of them (for the ChunkIO
 package just press the Compile button since it will not install any component
 but just the package itself).  In both cases, Lazarus will be recompiled to
 include the new components (this is where most bad Lazarus installations fail
 because they either do not setup permissions correctly so that Lazarus can
 overwrite itself or they do not include the full source code so that Lazarus
 can rebuilt itself).  This will only take a few seconds (ChunkIO will be
 almost instant).

   The next part is to generate the LazHelp documentation from the files under
 the doc/ subdirectory.  Go into that directory from a command line or terminal
 program and type "python".  The script is written for Python 2.x and
 will probably not work under Python 3.x.

   With LazHelp, FPLIL and ChunkIO built, open the LILCard project file (the
 lilcard.lpi file) from the LILCard source code.  Using the "build mode" button
 (the arrow button between the button with the blue gear and the play button
 at the top left side of the main window) you can select between Default and
 Release mode (Default mode is used for debugging and Release mode is used for
 release builds).  Additionally you can use the make-blah-release scripts, but
 i recommend to make a build from inside Lazarus first so that Lazarus has all
 the packages and paths properly configured.

   Note that under Mac OS X you will need to configure the macro under the
 Project -> Project Options -> Build macros -> Conditionals to point to the
 proper Mac OS X SDK.  In my setup it is /Developer-3.2.6/SDKs/MacOSX10.5.sdk
 but this will probably differ for you (especially if you do not have the
 older Xcode installed).

4. Contact
   You can contact me at my email:

 and my GitHub account:

 where you'll also find the latest version and binary releases for Windows,
 Mac OS X and Linux.

 Kostas "Bad Sector" Michalopoulos

Something went wrong with that request. Please try again.