SWI-Prolog is neither a commercial Prolog system nor a purely academic enterprise, but increasingly a community project. The core system has been shaped to its current form while being used as a tool for building research prototypes, primarily for knowledge- intensive and interactive systems. Community contributions have added several interfaces and the constraint (CLP) libraries. Commercial involvement has created the initial garbage collector, added several interfaces and two development tools: PlDoc (a literate program- ming documentation system) and PlUnit (a unit testing environment). In this article we present SWI-Prolog as an integrating tool, supporting a wide range of ideas developed in the Prolog community and acting as glue between foreign resources. This article itself is the glue between technical articles on SWI-Prolog, providing context and experience in applying them over a longer period

When developing a (web) interface for a deductive database, functionality required by the client is provided by means of HTTP handlers that wrap the logical data access predicates. These handlers are responsible for converting between client and server data representations and typically include options for paginating results. Designing the web accessible API is difficult because it is hard to predict the exact requirements of clients. Pengines changes this picture. The client provides a Prolog program that selects the required data by accessing the logical API of the server. The pengine infrastructure provides general mechanisms for converting Prolog data and handling Prolog non-determinism. The Pengines library is small (2000 lines Prolog, 150 lines JavaScript). It greatly simplifies defining an AJAX based client for a Prolog program and provides non-deterministic RPC between Prolog processes as well as interaction with Prolog engines similar to Paul Tarau's engines. Pengines are available as a standard package for SWI-Prolog 7. 1

Programming environments have evolved from purely text based to using graphical user interfaces, and now we see a move toward web-based interfaces, such as Jupyter. Web-based interfaces allow for the creation of interactive documents that consist of text and programs, as well as their output. The output can be rendered using web technology as, for example, text, tables, charts, or graphs. This approach is particularly suitable for capturing data analysis workflows and creating interactive educational material. This article describes SWISH, a web front-end for Prolog that consists of a web server implemented in SWI-Prolog and a client web application written in JavaScript. SWISH provides a web server where multiple users can manipulate and run the same material, and it can be adapted to support Prolog extensions. In this article we describe the architecture of SWISH, and describe two case studies of extensions of Prolog, namely Probabilistic Logic Programming and Logic Production System, which have used SWISH to provide tutorial sites.

The World Wide Web Consortium (W3C) has a standard in the pipeline – called SCXML – that may turn out to be very suitable for the design and implementation of games, in particular games featuring (possibly multimodal) natural language dialogue. We see three main reasons why SCXML may be a good fit for the game industry: 1) SCXML is all about statecharts – a powerful extension of finite-state machines – and we argue that statecharts has the right kind of expressivity for game design and de-velopment, 2) SCXML is an XML dialect (soon to be) endorsed by the W3C, and will thus become a part of a web infrastructure comprising speech technology and telephony, as well as other useful technologies for building games of certain genres, and 3) SCXML is designed for extensibility and it appears that it would be fairly straightforward – and very worthwhile – to build a game oriented extension (“profile”) around the SCXML core. The paper also presents an experimental implementation of SCXML, accessible from a user-friendly web-interface.

This short paper describes-and in fact gives the complete source for-a tiny Prolog program implementing a flexible and fairly efficient Transformation-Based Learning (TBL) system: