ZPE 1.14.3 is another big update, and it's coming at the end of this week.
x509_pem_fingerprint
There is a new predefined function in ZPE, x509_pem_fingerprint, previously available only through the new zpe.lib.security library.
In addition, the direct inclusion of X.509 fingerprinting means that ZPE now supports different types of plugins and libraries. Some libraries are what are called trusted libraries - they are signed by me. Then there are untrusted libraries. ZPE will soon block these on their first load, but they can still be used after approval. These untrusted libraries will also not have the same access in sandbox mode, with restrictions on system files and being limited to the sandbox folder. In addition, certain activities, such as reflection, executing commands, and networking, will be banned. If the sandbox is disabled, they are free to do what they want. Sandbox is now enabled by default in ZPE 1.14 and later.
Stricter lockdown procedures
Lockdown is a feature added in July 2025 that allows ZPE to run in a safe mode, ensuring that certain features cannot be run or loaded. Lockdown is stricter than before in ZPE 1.14.3, as plugins will not load at all during lockdown.
Further module improvements
Modules also received a major update. When modules were first introduced, they worked fine with a main function, unless the code was compiled using the YASS Compiler in ZPE and saved to an executable file. Now that's all changed. During compilation, the main function is identified and referenced, thus ensuring that main functions within a module load correctly.
Plugin and library updates
With all the work I've been doing on plugin and library security over the last few versions, this update further improves how libraries are integrated into ZPE.
Libraries have deep access to ZPE, and they are core to expanding its possibilities even further. However, in recent versions, due to the number of plugins and libraries available to ZPE on the rise, and the inclusion of trust checks within them, plugin loading has become a burden on startup times. As a result, I realised that plugins and libraries should be loaded asynchronously on startup. This, however, causes another issue: if a library is loaded after a program is run in ZPE, it will throw an error. To combat this, I've added an additional form of loading - using the already included import command:
import "zpe.lib.sqlite"
This means you can force the loading of a plugin right there and then, and if it's already been loaded asynchronously, the import statement does nothing. Nice!
Check out the new plugins
Several new plugins are under development. These new plugins, which are currently mostly libraries, are designed to extend ZPE's functionality and were one of the key goals when ZPE was first conceptualised. A couple of the new libraries are:
libMSAccess, libSQLite, libUI, libSerial, libSystemInfo, libMQTT, libMySQL
Plugins can now be added via ZULE (ZPE Uploads, Libraries and Extensions) package manager (which is getting an update in the next version) using the --plugins option:
--zule install --plugins
You can find out more about the libraries and plugins available on my GitHub page, where I share all the source code and the latest trusted builds.
New compiler feature
Previous versions of ZPE did not support using the arrow operator (->) to access an object after a function call, such as print(get_wikipedia_reference("USB")->title). This has been a problem for a while, but after a five-minute look at the compiler, it was an easy fix. So you can now probe the result of a function with an arrow operator.
ZPE 1.14.2 has been released this weekend. The new version brings a ton of new enhancements including the ability to view variables at certain points in the program through proper debugging tools that offer step over and execution pausing - not just termination.
ZIDE v.0.1.0-alpha has also been released, and this is the first version to be properly released. You can download the JAR from my GitHub and the individual binaries from my website (Linux coming soon).
ZIDE is not like ZPE in the sense that ZIDE is still in very early days. Each time a new binary is built, it will automatically be uploaded to my website for downloading. GitHub also will continue to feature release tags for each version. You can see the full source code for ZIDE on my GitHub as well.
ZPE 1.14.2 brings three major features.
Universal template parsing
Template parsing was introduced some time ago, but was released only in January 2026 with ZPE version 1.14.1. In the latest release, version 1.14.2, template parsing is available anywhere, including in parameters and return values.
Scope blocks
Many languages have scope blocks, and now YASS does too. They are nice and easy to use as well. Simply using the double brace syntax ({{ }} or the block syntax (block . . . end block), you can create an isolated scope block:
// Everything here runs inside the implicit GLOBAL function $total = 100 print("Start total: " & $total) block // This variable exists ONLY inside the block $total = 25 print("Inside block: " & $total) // Blocks can still see outer variables $discount = 10 $total = $total - $discount print("After discount: " & $total) end block // Block variables are discarded print("End total: " & $total)
Variable scoping
Additionally, variables declared as private in a function are scoped to the containing function and no longer modify parent or global variables, allowing safer encapsulation while preserving YASS’s simple scoping model.
As the title suggests, ZPE 1.14.1 is just about ready. This version is more of a bug-fix version, but it does bring some nice new changes.
For a start, ZPE no longer relies on native access for the command-line interface jLine. It also introduces tabbing in the command line via jLine. This is a really welcome addition. Changes to ZPEX mean that the -g and -q modes are no longer included in those builds. Minor performance improvements have also been brought to ZPE and, best of all, the JAR is more than 4MB smaller than before.
It's been a while since I uploaded a new version of ZPE, and it's not because I'm done with it or anything.
ZPE is mature, powerful and robust, and I'm not desperately in need of updating it right now. I am, however, working on adding code blocks to the YASS language but that's not due until the end of December.
As a result, I've released the version planned for the end of October, which has now been rebranded as ZPE 1.13.11 Walmgate.
ZPE 1.13.8 is only just out, and we've already got the headline feature of ZPE 1.13.9, and it's all about security.
Plugin security has been non-existent over the last few versions due to changes and deprecations in the underlying Java language. Anyway, today I decided it's time to relook at this and I've come up with my own way of doing this. Simply put, it forces plugin developers to develop an alternative way of accessing files, and that's using the new ZPE Sandbox Security file system. It also prevents access to certain other things, like running commands on the command line through the shell and restricts users to the built-in ZPE shell.
Overall, this is the first step to a more secure plugin-based environment and I'm really happy with it.
Most of the focus of the new Colliergate release is on the new and improved parser. The parser claims up to 24% increases in performance, and that's because it finally brings a new means of peeking.
What I'm talking about is that the Zenith Parsing Engine version 1.5 no longer wastes parsing time when peeking - once a token has been read, it is stored and it's never reparsed. Because of this, when ZPE asks the parser to peek ahead, the parser checks if the token has been parsed, and if not, it parses it, then returns that token. See, whenever you do a K(n) peek ahead, you parse n tokens, but in previous versions of the Zenith Parsing Engine, these tokens were discarded and reparsed again when the parser re-peeked at them or tokenised them, thus, storing a token cache, we can easily discern its value without reparsing it.
It's just astoundingly fast, and this improves CSV, XML, JSON, TOML, JBML and INI parsing too.
What this means is that ZPE is catching up to competitors for parsing speed, and there's still room for further enhancements that are planned for version 1.6.
The new version of ZPE will be released on Friday, marking one of the most exciting updates to date. Spanning three months rather than the usual one, it brings a slew of new features and changes designed to improve performance, add functionality, tighten the syntax, and enhance the UI.
It contains several significant changes, including the headline feature: a new parser, the Zenith Parsing Engine version 1.5, which offers up to 24% faster parsing speed by reducing backtracking in the parser.
Constructs
Labels and GoTo have been added to YASS. This is something I have tried to implement in the past, but have always disliked the way I've done it. I also think that, given YASS is meant to be object-oriented and unprocedural, it's not something that fits in with the standard, but it is here anyway.
$i = 0 label openloop print($i++) if ($i < 10) goto openloop end if print("Done")
Assertion has seen a massive change to make it more like other languages:
assert($a == [5, 8, 13, 21, 34])
Not only that, but the error identification is so much better than before when using assertions.
Bugs
Many bugs have been fixed, including:
- All properties of anonymous objects are now always accessible.
- Fixed a bug in the list_zpe_properties function to ensure it always returns all functions
- Added a new and more effective means of determining whether the program is run from a command line/headless
- Fixed the JSON parser to ensure it no longer double-checks every string for quote marks
Functions
Several new functions have been added:
- get_environment_variables
- get_percentile
- base64_encode
- base64_decode
- histogram
The beep function has also been significantly improved with more accurate frequencies.
Objects
Added two new objects:
- Colour
- Point
GUI
The GUI has been updated considerably:
- The rogue white line at the bottom has finally been removed!
- The curved UI has been improved further, as has the menu.
- The macOS icons are now manually rendered rather than relying on PNGs (this was always temporary)
- There's now support for BalfLaf Themes (blt) files
- There's now a property editor dialog for changing properties of ZPE
- There's now a lockdown option that can be set on individual installations of ZPE
- Symbols are no longer highlighted as part of the keyword set in the editor
- Built-in objects and imported objects are now highlighted
- New, clean and straightforward white icons are used at the top right of the GUI instead of the multi-coloured ones
- There is now an option to run ZPE Native if it is found in the correct place
- There's no longer an option to run code locally, and without running it through a separate ZPE process, which makes it easier to work with and prevents the GUI from crashing. The 'local' option is only used as a fallback.
The Quick Fire Command Window (-q) has also undergone significant improvements in both form and functionality.
ZPE Macro Interface Editor
There's a lot to discuss here, but in short, the macro editor has improved significantly over the last few months to the point that it's now become a key part of my other software. It has always been able to act on an object provided to it, but now it can give information on functions provided in the object, it can be used to not only make simple code and execute it, but also provide code back to the calling program that can be used call a macro when a button is clicked for example. See eTraxion for more information on how this is used.
Other changes
ZPE now stores data in a new folder on the system. For macOS, this is the Library/Application Support folder; for Windows, it is AppData; and for Linux and other operating systems, it remains the home directory.
Mathematical functions have been split into two separate categories: Numerical and Arithmetic, and Scientific Mathematics. This is because the Mathematics category was getting too large.
New ZPEKit methods have been added to provide more comprehensive access to the ZPE Core.
That's just been a quick overview of the main new features coming to ZPE in version 1.13.8, which will be released on Friday. I'm exceedingly excited!
Ten years ago today, in May 2015, I rebuilt ZPE from the ground up, developing a parser that still powers it today. That parser, the Zenith Parsing Engine, completely changed ZPE and made it possible to create large programs that didn't experience slowdown. It also allowed me to develop more complex constructs and statements and build in backtracking, a once fundamental step in ZPE as a program.
It was also the day I introduced the YASS language (known back then as Zenlang).
ZPE 1.3 was the foundation of what ZPE is today. It completely changed ZPE. It's incredible to think how far it's come, and it's also amazing to believe that it's been a project for ten years!
I also intentionally timed it so that the next version of ZPE would be released today. So, ZPE 1.13.7 was also released today. This is an anniversary edition since it marks the ten-year anniversary.
You may also notice that I pushed a few more versions this year to try and get to 13.7 for this release, and that's because my birthday is 13-7-1991, so I wanted that to coincide with this release.
I will launch modules for the YASS language in a very near future release. These modules will further compartmentalise the YASS language and add to its object-oriented paradigm.
Modules are the parents of structures, objects, and functions. Their primary purpose is to use static methods, like the library system currently does, but in a far more flexible manner. This will involve many underlying changes to the systems of the ZPE Programming Environment core. It's currently planned for a July release.
