ZPE 1.14.4 release

March 2026 has been a hugely important month for ZPE, with changes that go far beyond small fixes or minor additions. The overall direction is clear: ZPE is continuing to evolve from a scripting engine into a much broader and more capable platform, with major improvements to performance, web functionality, tooling, deployment, and the YASS language itself.

One of the biggest themes throughout the month has been performance. A great deal of work has gone into improving execution speed, especially in the runtime, the ZEN Web Parser, and ZPEC. The parser has seen repeated optimisation work, and the runtime itself received considerable performance improvements later in the month. ZPEC, the ZPE Performance Enhanced Cache, also saw major gains. It is now enabled by default, can be listed and purged more easily, and is robust enough that cached files can now be run through ZPEKit as well. Altogether, these changes make repeated execution and web-driven workloads significantly faster and more practical.

In addition to the performance improvements noted earlier, ZPE performance got an additional improvement that made it around 2 times faster than it was even after that improvement at the end of the month. This improvement speeds up both development as well as the runtime.

Another of the most significant developments has been the rapid growth of ZPE’s web capabilities. The ZEN Web Parser was extended to support sessions, cookies, and GET and POST parameters, making it much more suitable for real-world web applications. A particularly important design change was the introduction of the RequestObject, which redefines the role of the ResponseObject. Incoming data now comes from a RequestObject, while outgoing data is represented separately in the ResponseObject. This is a much cleaner and more logical model for web execution.

Session handling has also advanced considerably. Sessions can now store full ZPE values rather than being restricted to strings, which is a major improvement in flexibility. That change also led to updates in how VWS stores objects in sessions, bringing things more into line with the capabilities of the ZPE runtime. Session persistence bugs were fixed, expiry times were added, and responsibility for session handling was shifted away from VWS and into ZPE-PM. This is one of the clearest signs that the web architecture is maturing quickly.

A major new addition this month is ZPE-PM, the ZPE Process Manager. This is one of the standout features of the entire changelog. ZPE-PM allows scripts to be run over a socket, streams output directly, caches .yas files, and now handles sessions as well. It also accepts parameters through JSON requests and has effectively replaced the old JSON communication mode, which has now been removed. This is a major architectural step because it gives ZPE a much stronger service-based execution model and opens the door to cleaner integration with web servers and other tools.

The relationship between ZPE-PM and the VelocityWebServerModule also developed further. Both now handle sessions, and when ZPE is used with Apache, session information is passed to ZPE-PM through the JSON request. VWS also now passes the request over to ZPE itself for handling, so VWS no longer manages sessions directly. This centralisation makes the overall design more coherent and should make the platform easier to maintain and extend.

There were also important changes for YASS as a language. The new arrow expression syntax is one of the most exciting additions for day-to-day coding. Expressions such as x.where(n => n % 2 == 0) are now fully implemented, and the feature has also been extended to work with maps, allowing forms such as x.where(k, v => v > 40). This is a very modern addition to the language and makes working with collections far more expressive and convenient.

March also introduced compiled YASS webpages through the new .yep file format. This is another major milestone because it strengthens ZPE’s role as a web platform rather than simply a scripting environment. Alongside that, LAMEX3 was added in experimental form as an AI-improved version of LAME, showing that experimentation and forward-looking development are continuing alongside the core runtime work.

Tooling and usability have also improved noticeably. A new Interactive Actions feature was introduced, allowing interactive code sessions. New ZAC tools were added, including --tools and --zpec, and there was some useful command-line tidying too, such as moving properties help from -p to -h properties. These are the kind of improvements that make the platform easier and more pleasant to work with as it grows in complexity.

Installation and deployment have become simpler as well. The old createInstallScript approach has been removed, and ZPE now installs itself. A dedicated ZPEInstaller class was introduced to support the growing range of installer responsibilities. This is an important quality-of-life change because it reduces friction and helps the system feel more complete and self-contained.

There were also several internal architectural changes that, while less flashy, are very important. Undefined is now internally defined as a singleton, which is a cleaner and more efficient design. Aliases have been moved out of the runtime and into the compiler, meaning they are now compiled down to their real function calls rather than being resolved dynamically at runtime. This should improve both performance and compatibility. The runtime was also updated to use its own standard output, and native methods now include checks for returned data types.

Parsing and reliability also received attention. The JSON parser was improved, syntax errors now report proper line numbers, and a CSV parser bug was fixed so that line breaks are handled correctly. There was also a fix for a recent bug that caused the first argument in an executable to be ignored. These may sound like smaller details, but they make a big difference to the day-to-day experience of using and debugging the platform.

Several smaller additions round out the month’s work. A new directory_is_empty function was added, and list_add_element now has the append and list_append aliases. These are not as fundamental as the web and runtime changes, but they still help make the language and standard library more convenient to use.

Looking across all of these updates together, the biggest story is that ZPE is becoming broader, faster, and more mature. Performance has improved significantly, caching is now a central part of the system, web support has become much more capable, session handling has been redesigned in a more scalable way, and ZPE-PM introduces a powerful new execution model built around sockets and structured requests. At the same time, YASS is gaining more modern language features, and the surrounding tooling is becoming easier to use and deploy.

In short, March 2026 has been one of the most substantial periods of development for ZPE in quite some time. The platform now feels far closer to a complete application environment, with serious web capabilities, stronger architecture, better performance, and a more modern developer experience. There is still more to come, but this month has laid down some very important foundations for where ZPE is heading next.