Liquid Markup

Understanding Liquid as a Client‑Side Markup Language

When a new web technology first appears, people tend to be skeptical. Liquid, announced in 2003, offers a different take on how to embed interactive features in a page without writing full‑blown JavaScript code. It does so by extending the standard HTML vocabulary with its own custom tags. The approach looks similar to the way VML and CSS work together to create graphics, but Liquid goes further by enabling animation, state handling and even simple physics. This section unpacks the core concepts behind Liquid and clarifies how it differs from conventional client‑side scripting.

Liquid is built on top of a small runtime library that browsers download when a page first loads. The runtime recognises the custom tags it finds in the markup, parses their attributes and then executes the behaviour that those tags declare. Because the tags are declarative, a developer can mix several small pieces together and create a larger, more intricate behaviour. Think of each tag as a building block: <clip> moves an element around; <slide> fades it in or out; <clip> can be nested inside a <slide>, and so on. The tags don’t exist as separate script files; they exist inside the HTML document, just like any other element.

One of the first questions people ask is whether Liquid requires a new programming paradigm. The answer is it is more of an extension of the familiar HTML structure. In the same way you add <div> or <img> tags to mark up content, you can add <clip>, <slide>, <cliploop> and other custom elements. The runtime is responsible for turning these elements into behaviour, which makes it possible to write a simple animation by just writing markup. You can add a new tag to your own library, host the runtime locally, and the new behaviour will automatically be available in every page that uses the tags. Liquid is not a replacement for JavaScript; it works alongside it, and sometimes it is easier to use a Liquid tag instead of writing the same behaviour in JavaScript.

For those who have experience with VML or CSS animation, Liquid might feel like a familiar tool. But Liquid differs in a few subtle ways that make it easier to reason about. VML animations rely on script callbacks to reposition elements on each frame. Liquid, on the other hand, takes the frame of reference into account once, and then it uses the runtime to move the element. If you ask a Liquid tag what the final coordinates are, it can compute them and animate the element to that point. This shift of logic from script to markup has two side effects: a markup that is easier to read and a runtime that runs more efficiently on the client.

To use Liquid in practice, you need to add a reference to the runtime library. The reference can point to a server that hosts the library or a local copy on your own machine. The runtime is lightweight, around a few megabytes in size. The tags are defined in XML, so a developer can create new tags using a simple schema. The schema shows which attributes a tag accepts and how those attributes map to behaviour. For example, a <clip> tag might have attributes like src for the image source, destx for the X coordinate to move to, and dur for the animation duration. The runtime reads these values and starts the animation. Once the animation is complete, the runtime can fire events that other tags or scripts can listen for. By combining multiple tags, developers can create interactive applications, games and even more complex user interfaces without writing loops or timers in JavaScript.

Liquid is currently supported in Internet Explorer 5 and above, with early plans for cross‑browser support. The runtime can be configured to use a commercial license, which adds more tags and detailed documentation. The free version already contains enough tags to start creating games and interactive presentations. The runtime works with the same markup as ordinary HTML, so developers can continue using Notepad or other simple editors to write Liquid code. Once a page is loaded, the runtime takes over and interprets the custom tags. If you prefer to host the runtime locally, you can download the library and place it on your own server. The commercial version also offers SDK tools and support for integrating Liquid with C++, Java, and other languages. This integration expands Liquid beyond the browser, allowing you to build richer applications for PDA and mobile environments. The key point is that Liquid does not force you to learn a new language: it leverages your existing HTML skills and extends them in a way that feels natural for web developers.

In practice, Liquid offers an elegant way to build interactive content while avoiding the boilerplate that usually accompanies JavaScript. Because the runtime is declarative, you can write the markup once and reuse it across projects. You can also nest custom tags to create more complicated behaviours. For example, a <clip> tag inside a <slide> tag will move an image while fading it in. Liquid’s design also makes it possible to create new behaviours as custom tags, which then become part of the language for all projects that use Liquid. That means if you discover a new animation trick that you want to reuse, you can define it once, and then drop the custom tag into any page. The runtime will take care of turning the tag into the right behaviour. This approach reduces duplicated code and gives a clear separation between the markup that declares the behaviour and the runtime that implements it.

In short, Liquid is a client‑side markup language that lets developers build interactive experiences by declaring behaviour in the markup itself. By treating behaviour as reusable tags, it offers a simpler entry point for web developers who might be intimidated by the intricacies of JavaScript, while still keeping the power and flexibility of scripting. The next sections break down the essential tags you’ll need for a basic animation, walk through a simple game example, and explain how you can create new tags to extend Liquid’s capabilities. These sections aim to give a practical roadmap for building interactive web content with Liquid, from setup to execution, without pulling your attention into a generic overview or abstract discussion. This practical approach helps developers focus on the real work: adding custom tags, configuring the runtime, and testing the animations in the browser. The result is a concise, but thorough, introduction to Liquid’s core concepts and how they come together in a functional page. This is the best way to understand how Liquid differs from other web technologies, and how it can be used to create interactive web experiences.

Setting Up the Liquid Runtime and Writing Your First Page

The first step in using Liquid is to bring the runtime into your web page. Liquid works by looking for a specific tag in the head of the document and then loading the corresponding script file. The syntax for this looks like an ordinary JavaScript include: a <script> tag that references the Liquid engine. That file is a small library that the browser reads when the page loads. If you host it on your own server, the browser will request the file from that address; otherwise, it is served from a default host. In either case, the file must be available before the browser tries to interpret any Liquid tags. In a real-world scenario, you can place the script reference right after the opening <head> tag. Keep it at the top of the page so the runtime is ready before any tags appear in the body. The runtime itself is platform independent, but the current official releases work only on Internet Explorer 5 and newer. Future versions will target other browsers, but for now, you need an IE5 environment or newer to see Liquid tags in action.

Once you have the runtime loaded, you can start writing Liquid tags in the body. Liquid tags are written just like any other element: self‑closing or paired. For example, a <clip> tag is a single element that contains no inner content; it simply declares that an image should move somewhere. A <cliploop> tag, on the other hand, is a container that can contain other tags inside of it. Liquid tags are parsed by the runtime, which looks at the attributes on each tag to decide what to do. You can use attributes to declare the source of an image, its initial position, where it should move to, how long the animation should last, and what should happen when the animation ends. In a simple example, you could write a <clip> that displays an image of a house and moves it across the screen.

With a basic page set up, you can test the runtime by opening the page in Internet Explorer. The browser will load the runtime script, parse the tags, and execute the animations. If you had defined a <clip> tag with an image source and destination coordinates, you would see the image slide from its starting point to its target. If you included a <slide> tag, you would see the element fade in or out. Liquid tags are quite forgiving: if you leave out an optional attribute, the runtime falls back to a default value. For example, if you omit the dur attribute from a <clip>, the default duration might be 500 milliseconds.

Testing Liquid tags in a local environment is simple. You do not need a server that can process tags: the runtime does all the heavy lifting. The only requirement is that you keep the script reference at the top of the page, and then the browser will run the Liquid engine automatically. Once you’re satisfied that the animations work as expected, you can start layering more tags on top of each other. For instance, you can nest a <clip> inside a <slide> to move an image while it fades. Or you could add a <cliploop> to make an image repeat its movement forever. These nested tags can create more complex animations, and Liquid’s syntax is designed to let you declare them in a clean, structured way. That structure becomes the foundation for more advanced behaviour: event handlers, triggers, and conditional logic.

At this point, you have the runtime loaded, your first page defined, and a simple animation running. The next section will build on that foundation by adding more tags to create a basic game. That game will use a <clip> tag to move a house image, a <slide> tag to show and hide an image, and a <cliploop> to keep the game running in a loop. By combining these tags, you’ll be able to create a playable web game that runs entirely in the browser. The next sections will walk you through the steps required to do that, including setting the attributes for each tag, placing the tags in the correct order, and testing the result in the browser. That way you can see how the runtime reads the tags, interprets them, and drives the animation.

Common Liquid Tags for Animation and Interaction

Liquid offers a wide range of tags that can be used to animate elements, create interactive triggers, and even build simple games. While the language contains many tags, only a handful are required to get started. Below are the core tags you’ll need for a typical animation or a basic game.

1. <clip> – The <clip> tag is used to move an image from one point to another. The src attribute defines the image file to display; destx and desty declare the target coordinates; dur declares how long the animation takes; and easing can specify the animation curve.

2. <cliploop> – The <cliploop> tag is a container that can contain one or more child tags. When you use a <cliploop>, the runtime will keep looping its child tags automatically. This is useful for creating repeating movements or continuous animation.

3. <slide> – The <slide> tag controls opacity changes. If you use a <slide> tag with an in or out attribute, the element will fade in or fade out over a defined duration.

4. <clipgroup> – The <clipgroup> tag allows you to group several images and apply a single transformation to the group. It’s similar to a <clip>, but it works on a group of elements, which can be handy when you want to move multiple images in unison.

5. <clipmove> – The <clipmove> tag is used for more advanced movements that require intermediate points or non‑linear paths. The runtime can interpret a path described as a series of coordinates.

With these tags, you can create a small animation or a simple game. For example, you can write a <clip> that moves an image across the screen, wrap it inside a <cliploop> to keep moving it back and forth, and then add a <slide> that fades the image in or out. Liquid’s syntax is intentionally straightforward, and you can skip complex JavaScript functions if you only need a few simple behaviours. The runtime handles the heavy lifting, so you can concentrate on laying out the page.

Creating a Basic Game with Liquid Tags

With the runtime loaded and some basic tags in place, the next step is to build an interactive game that demonstrates Liquid’s full capabilities. A typical small game is built around a single image that moves across the screen and checks whether it hits a particular region. In a simple example, a house image moves across the screen, and a <clip> tag keeps track of the movement. When the image reaches the right side of the screen, the runtime fires a custom event that indicates the game state has changed.

In a real-world scenario, you’d use a <cliploop> tag to keep the animation running. The loop runs continuously and can be stopped by an external event or by the user. The <cliploop> tag contains other tags, such as a <clip> that declares the movement of an image, and a <slide> tag that fades it in. Because Liquid tags are declarative, you can simply write the <cliploop> in the page, and the runtime takes care of the loop logic.

For a more advanced game, you can create a <clipgroup> that contains several <clip> tags. The group might contain an image of a house, an image of a tree, and an image of a sun. The <clipgroup> could then be set to rotate around a centre point. The rotation is defined as an attribute on the group: rotate and duration. The runtime interprets the rotation attribute, applies the transformation to each child, and then updates the positions on each frame. The game engine can also keep track of collisions: if the house image reaches the left side of the screen, the runtime fires a collision event that triggers a function. That function might change the colour of the house, or it might reset the house to its initial position.

To build a playable game, you also need a user interface for interaction. Liquid offers the <clip> tag as a container for <clip> tags that can respond to user input. For instance, you can use a <clip> tag that listens for mouse clicks and moves an element accordingly. The onclick attribute on the tag can specify a function that runs when the user clicks. In the runtime, you would register a function that changes the target coordinates. For a simple game, you could create a small image that represents the player’s character and make it respond to arrow key presses. The character would move to the left or right when the user presses the left or right arrow keys. Because Liquid tags are declarative, you can express this logic directly in the markup, instead of writing a full keydown event handler in JavaScript.

In addition to basic movement and collision detection, a small game can also show how to create custom triggers in Liquid. Liquid offers the <trigger> tag, which listens for a custom event from the runtime and executes a block of tags when that event occurs. For example, when the house image reaches the right side of the screen, the runtime could fire a custom event called houseReached. A <trigger> that listens for that event could then add a <slide> tag that fades out the house and then fades in a message that says “House delivered!”. The <trigger> tag is a container: it encloses one or more tags that run when the event fires. You can also use a <trigger> to start a new loop or to reset the game state.

With a simple game in place, you can test the behaviour in the browser and confirm that the tags are working as expected. If you used the <cliploop> tag to create a continuous loop, you will see the image move back and forth until the page is closed. If you used a <trigger> tag to react to the houseReached event, you would see the fade animation appear only when the image reaches the target. That demonstrates the core logic of Liquid: declarative tags combined with a runtime that interprets them and drives the animation. Once you’re satisfied with the game, you can add additional features such as a score counter, a timer, or a background sound. Liquid offers a <sound> tag that plays audio files. You can embed a <sound> tag in a <trigger> to play a sound effect when the event occurs. All these features show how Liquid can replace complex JavaScript logic with simple markup. That simplicity is its key advantage: developers can build interactive web applications without writing complex JavaScript.

Extending Liquid: Adding Custom Event Handlers

Once you’ve built a small game with Liquid tags, the next step is to extend the language by adding custom event handlers. Liquid’s runtime includes a set of event handlers that can be used to create triggers and to react to the user’s actions. The on and do attributes on a tag are used to define the event type and the action to be performed.

For example, the <trigger> tag is a container that listens for a custom event from the runtime. The runtime can fire a custom event called houseReached when the house image reaches the right side of the screen. Inside the <trigger> tag, you can write a block of tags that run when that event occurs. For instance, you might want to add a <slide> tag that fades in a message that says “Delivery complete”. The on attribute of the <trigger> could be houseReached, and the do attribute could contain a block of tags. The runtime interprets those attributes and starts the block when the event fires.

Because Liquid tags are declarative, you can express that logic in the markup instead of writing a JavaScript function that listens for the event. That means you can keep the game logic in the page, and the runtime handles the logic behind the scenes.

Another feature of Liquid is that you can add custom functions that run when an event is triggered. The <clip> tag supports the onclick attribute, which can be used to call a custom JavaScript function. That function could change the coordinates of the image or could add new tags to the page. You could also write a <clip> tag that triggers when the user presses the space bar and then changes the background colour of the page. With Liquid tags, you can define all that logic declaratively, and the runtime takes care of executing it. The runtime will automatically interpret the onclick attribute, register an event handler, and then run the tags inside the <clip> container.

With custom event handlers in place, you can create more advanced interactions in your game. For example, you can use a <clip> tag that listens for the user’s arrow key presses and then moves a small image accordingly. The runtime will handle the keydown event, and the onkeydown attribute on the tag would be set to a custom function that changes the target coordinates. In a real-world scenario, you would also need a <clipgroup> that contains the image you want to move. That group might contain an image of a house and an image of a tree. The <clipgroup> could then rotate or move in unison. With that structure, you can create a game that runs entirely in the browser, using only Liquid tags and the runtime.

Best Practices for Using Liquid Tags

Liquid tags are designed to be declarative and simple. The following best practices can help you use Liquid tags effectively.

1. Keep your tags in a logical order. The tags should be nested inside containers in a way that the runtime can interpret them correctly.

2. Use <clip> tags for movement. Keep the tags in the same order, and use the destxdesty attributes to set the target coordinates.

By following these guidelines, you can build a simple animation or a basic game that runs in the browser.

Conclusion

In this tutorial, we’ve covered the fundamentals of Liquid programming. We’ve seen how to load the runtime, how to write a simple animation, and how to create a small game with triggers. By using Liquid’s declarative syntax, you can build interactive web applications without writing complex JavaScript. That makes it easy to create web pages that are both dynamic and responsive. You can use Liquid to add custom events, triggers, and conditional logic. And you can keep your tags organized so that the runtime can interpret them correctly. By following the steps outlined in this guide, you should now have a solid foundation for building dynamic web applications with Liquid. The next step is to practice creating more complex logic and to experiment with custom functions that can be triggered by user events or by the runtime.

The best way to get comfortable with Liquid is to start building your own web applications, experiment with new tags, and see how the runtime interprets the tags. Happy coding!

Thus we must implement from scratch.

We need to implement all functions in src/cli/handler.js: registerHandlers, handler, printUsage.

We need to look at README or docs to understand command-line arguments. Search for 'cli' usage. Search for 'node' or 'package.json' script. open package.json.