The changelog for ZPE 1.14.8 is looking quite big, and that's because this version itself is huge in ZPE's story.
At the same time, I'd also like to mention that the Zenith Parsing Engine version 6 has been released today as well - you can download this early, ahead of the release of ZPE 1.14.8, which will come on the 1st of August. Version 6 continues to bundle the legacy version 4 (deprecated last year) and version 5 (recently deprecated) parsers. This will be the last version to bundle version 4 of the parser - any old programs using it will now need to move to version 5, or better, version 6 (although both versions break compatibility with version 4 and with each other).
In addition, I've released the YASS AST whitepapers on my website today. There are several ways to access these: first, go to the documentation section of ZPE under Projects here. Alternatively, you can download the PDF from the Download Center on my website.
01.07.2026
The ZPE Console now has a new look.
Due to the update to BalfLaf, the window resizes naturally.
Fixed an issue in which the macOS Menu Bar would not allow clicking on items.
02.07.2026
Improved the Windows and Unix installers.
04.07.2026
Fixed an issue in BalfLaf that caused the file editor to scroll slowly in Details view.
08.07.2026
Major performance improvements in LAMEX3.
Added a guard for setting properties, if -k is left empty nothing will happen.
Added a guard for setting properties, if the the key does not exist, nothing will happen and an error will be printed.
ZPEOrderedAssociativeArray is now called ZPEOrderedMap.
Added the new [=>...] syntax for representing ordered maps.
13.07.2026
Improved the speed of calls to the built-in functions.
16.07.2026
Assert only now runs in functions with test in front and only run in debug. E.g. test function() { assert(3 > $v); }.
17.07.2026
Added the compare method to the Image object.
Added the compare_files predefined function.
18.07.2026
Added the is_native image module method to the ZPE module.
Added the to_boolean method to the Utilities module.
Updated the file_copy predefined function to copy files with their attributes.
Updated the directory_create predefined function to create directories recursively.
Improved compiler syntax errors to report the unexpected token that was found.
Fixed a compiler issue in which a closing brace followed by a function could be incorrectly treated as a scoped function declaration.
Fixed braced else-if chains consuming the closing braces of their enclosing loops and functions.
Fixed the compiler distinction between an else-if chain and a genuinely nested if statement inside an else block, preserving both braced and end-if syntax.
Redesigned ZPEC to store each compiled source in its own file within the ZPE zpec directory instead of rewriting one monolithic cache file.
Fixed logical negation mutating shared boolean values.
Fixed numeric negation mutating the original number.
Improved performance of the ZenithJSONParser, making it approximately 200% faster.
19.07.2026
Added support for prefix and postfix increment and decrement operations on object properties and indexed values.
Added the get_zpe_time method to the ZPE module, which returns the time elapsed since ZPE started.
Changed plugin loading so that plugins are loaded when imported rather than automatically during startup.
Changed the background update check so that it only starts for commands that require it.
Improved startup performance by avoiding repeated settings and lockdown configuration checks.
Improved block performance by reusing isolated block runtimes instead of creating a new runtime for every block.
Significantly improved structure and module performance by removing unnecessary temporary runtime creation.
Fixed structure and record lookup failing to terminate when a requested definition could not be found.
Improved numeric comparison performance by avoiding temporary BigDecimal allocations.
Reduced unnecessary numeric copying during increment, decrement and compound assignment operations.
Changed by-reference variable assignments to alias the underlying variable container directly.
Added support for bare return statements in both braced functions and end function syntax.
Fixed unterminated functions and other code blocks repeatedly compiling the end-of-file token until the Java heap was exhausted.
Improved compiler errors for unterminated functions, blocks and loops to report the unexpected end of file.
20.07.2026
Significantly improved compiler performance by reducing allocations and repeated work in the Zenith token stream.
Reduced compiler memory usage by retaining byte tokens while reconstructing word data only when required.
Replaced the compiler's continuously rebuilt program-so-far string with a lighter representation.
21.07.2026
Removed the legacy Native suffix from the predefined-function dispatcher.
Removed obsolete reflective constructor caching from predefined functions now that function instances are created during initialisation.
Changed runtime variable resolution so that unqualified variables inside object methods remain local and object properties require an explicit this accessor.
Improved object method performance by avoiding implicit parent-object variable lookups.
Fixed the standard library timer assigning its start time to a local variable instead of its object property.
22.07.2026
Ordered maps now use the braces for their syntax and are much cleaner: {=>} or {4 => "Four"}.
23.07.2026
Significantly improved compiler and runtime performance through constant folding, compiled expressions, integer variable slots, faster function invocation and loop execution.
Replaced legacy compiled-program and ZPEC serialisation with compact, versioned binary formats.
Improved startup performance by reducing repeated filesystem and path work and replacing JSON compiler constants with properties.
Improved object property, method, and nested accessor performance by reducing repeated lookups and returning values directly.
Added predicate arrow expressions to inline ranges, such as from 0 to 1000 : n => n % 2 == 0.
Improved predefined-function performance by resolving non-overwritable functions to cached integer identifiers.
Reduced predefined-function dispatch overhead using identifier-indexed command metadata while preserving plugin overrides.
Replaced Java serialisation for YASS Executable Pages with a compact, versioned byte format.
Added the Storage module with open and save methods for versioned, Java-serialisation-free ZPE value storage (one of my new favourite features!).
24.07.2026
Added nanosecond-precision runtime timing that excludes time spent waiting for user input, with compile and runtime completion messages controlled by SHOW_COMPLETE_MESSAGES.
Significantly improved startup performance by lazily creating predefined functions (once again), built-in modules, byte-code metadata and the background executor only when required.
Improved predefined-function dispatch using generated, reflection-free factories that remain compatible with native-image builds.
Improved launcher performance for run mode and directly supplied programs by using faster JVM startup settings and avoiding unnecessary initial heap allocation.
Greatly expanded YASS Unfold with structured module, structure and function reports, typed signatures, parent context and AST-based recognition of common searching, sorting, graph, sequence and cipher algorithms.
Moved update checks into the background and avoided unnecessary introductory output when running programs.
Reduced native-image reachability by excluding desktop-only built-in objects from ZPEX.
I'm not saying much; this post speaks for itself:
ZPEX
All: 26.449, 24.766, 24.764, 23.458, 24.775, 24.326, 24.694, 23.347, 23.642, 23.805, 23.537, 24.524, 36.397, 27.322, 26.400, 29.528, 26.261, 24.890, 28.138, 35.016, 31.776, 25.566, 24.986, 23.452, 24.375, 23.610, 24.100, 24.536, 24.620, 24.208, 24.343
Python 3
All: 30.093, 30.297, 29.567, 29.024, 29.126, 28.232, 29.098, 29.045, 28.279, 28.109, 29.296, 31.022, 30.010, 29.900, 29.773, 29.896, 29.706, 29.242, 29.819, 30.404, 30.392, 30.285, 30.099, 30.159, 29.626, 30.205, 33.647, 36.448, 34.320, 31.158, 29.901
No scientific stats in this post, but ZPEX hit an average of 13ms with the Standard Algorithms when passing it through the runtime. After a lot of profiling and working with ChatGPT to give me ideas for places to look for performance issues, I discovered some bugs that I fixed, such as calling the garbage collector when destroying a ZPE variable. As a result, standard ZPE can now run it through the runtime in 54ms on average. It's compiled in less than 60ms too due to the new version 6 of the Zenith Parsing Engine that powers the compiler.
I still cannot believe this; the performance of ZPEX overall is astounding - it takes just 8ms more than Python's best result to compile and run the exact same code translated to Python, running the whole ZPEX in just 52ms - compiling in 12 milliseconds, 14 milliseconds for running it, and so the rest is start-up.
ZPE is actually becoming exceedingly useful and powerful. I'm now actively converting all my web server scripts from PHP to YASS and compiling them as native scripts.
ZPE version 1.14.8, the absolute biggest release of ZPE in a long time (which I considered bumping up to ZPE 2.0 because it's so significant), will be released on the 1st of August. More will follow on release day, but I honestly mean this: this version of ZPE is incredible.
ZPE UI, the official plugin, has been maintained from time to time because, to be honest, it works quite nicely. But the biggest problem with it is that is a plugin, which means no ZPEX.
In addition to this, since ZPE UI is built in Swing, it cannot be used by ZPEX, even if it were embedded straight into ZPE.
So here's the plan:
- ZPE UI will continue to be a plugin for ZPE itself
- ZPE will soon begin to bundle its own UI building toolkit
- ZPEX will be able to use the new UI building toolkit
This will require a lot of work. I'm hoping this will be ready for release in September at the earliest, with previews running through August.
To be clear, this will not be replacing the standard editor built into the ZPE package yet, but at some point it might. For that, I'd direct you to ZIDE, which is already an excellent IDE for ZPE.
ZPE 1.14.8, already shaping up to be the best release in ZPE history, is getting even better: this time, it's getting the newly completed Python, PHP and the new JavaScript transpilers built in.
The main reason behind this is to provide ZPEX with the ability to use transpilers.
One big benefit is that these are very lightweight, so they add very few additional storage requirements to the ZPE JAR or the ZPEX binary.
And, best of all, I'm going to continue to maintain and update the plugins, which can overwrite the built-in transpilers (and actually, when updates come to the plugins, they'll also come to the release version of ZPE, since ZPE itself just bundles the actual plugins).
There is one breaking change in ZPE 1.14.8, and one that I should have broken years ago:
If you're working in an object, and you reference a property of the object in a function just by using its name (e.g. $begin), ZPE will no longer treat this as an object property, just a local variable. You must explicitly reference it with this, (e.g. this->$begin).
I shall let this post from my Bluesky account summarise this:
I honestly cannot believe this, but the new ZPEX 1.14.8 has brought compile time right down. I mean, right down, we're talking from ~390ms to 7ms after I made a few little changes here and there! This is one of the most revolutionary moments in ZPE's history.
— BALF (@jamiebalfour.scot) July 18, 2026 at 9:10 PM
This is a remarkable result, and one I most definitely did not expect. ZPE compiles considerably faster due to improvements to the Zenith Parsing Engine (now version 1.6). This also improves:
- The JSON parser - used frequently in the ZPE Runtime Environment (ZRE).
- The CSV parser
- The XML parser
- The TOML parser
- The INI parser
- The JBML parser
- The YAML parser (coming this year)
This is, without a doubt, one of the biggest improvements in ZPE's history, especially in the compiler. This all goes back to ZPE version 1.5.3 back in 2017, when I introduced a separate parser and compiler, which led to performance gains back then. But the next big improvement was tonight's improvement, and I still cannot believe it.
It means that there will likely be no need for any more improvements to the compiler unless they benefit the runtime.
I turned 35 today at 10:30. I'm actually shocked that I'm now half my dad's age as well.
If I look back to my late teens, when my health was grim compared to now, things have improved a lot.
This was, however, also the first birthday without my auntie Deirdre. I still can't believe I don't have her anymore.
Anyway, from tomorrow onwards, I'll be closer to 40 than 30. That's absolutely nuts!
I am shocked to be saying this, but ZPE 1.14.8 is already up to five times faster than ZPE 1.14.7, which was already up to three times faster than ZPE 1.14.6!
This improvement has come from many changes in the runtime, ranging from variable and function lookups to how expressions are evaluated.
For comparison, here are the times for running the Standard Algorithms library:
Timer finished : 53ms
zpex -r stdAlgorithms.yas 0.56s user 0.04s system 95% cpu 0.623 total
Timer finished : 136ms
zpe -r stdAlgorithms.yas 2.22s user 0.24s system 336% cpu 0.733 total
After countless hours of development and over 3,000 builds, VWS has finally left beta and is now available as a working web server, supporting a variety of different features. Here are some of the key features (as well as some of my favourites):
- HTTPS and TLS support (at last)
- Unix socket support for connecting to PHP FPM
- ZPE PM support from the box
- Easy to write handlers
- Web assets and bundles; /__vws_asset/ and /__vws_bundle/ (more below)
- A control server (vws --control)
- A Let's Encrypt installer
There are caveats to its use currently, however. For example, the Let's Encrypt installer is not perfect and is more Unix-oriented than Windows-oriented.
Now I mentioned vws_assets and vws_bundles. These are among my favourite features in VWS. These are clever little ways of simply including a library and VWS includes many by default. For example, let's just say I want jQuery on my website. I simply include the URL,
/__vws_asset/jquery/
and VWS will provide jQuery. It will have jQuery pre-fetched, since the bundle will be downloaded first.
But bundles are even better. We use them as follows:
/__vws_bundle/jquery,react,vue/
and VWS will combine these into a single file, thereby reducing HTTP requests and maintaining optimal speed. Not only that, but VWS will also keep a cache of these bundles to ensure it can quickly find them again.
Back when I was at school, especially during Higher and Advanced Higher Computing, my teacher (who is also now my colleague) inspired me to use mind maps. Throughout my own time going through education, my undergraduate Computer Science, my PHd and my Post-Graduate Diploma in Education (PGDE), I have used mind maps in one way or another.
I was initially familiar with Mind Genius and obtained a copy from Heriot-Watt when I started my undergraduate degree. Whilst I found my undergrad easy enough and second nature, some elements of it were not. Particular areas around mathematics in computer science were the key points where I struggled. Mind-mapping the key ideas was really useful for revising and understanding the issues I might have.
Anyway, fast-forward twelve years, and I'm teaching and finding that mind maps are a great resource to help pupils, just as they did for me. However, I'm limited.
So this is where it gets fun. Three or four weeks ago, I was making my final preparations to present my practitioner enquiry, which focused on recalling key information. My main focus here was using mind maps to help pupils recall information from what they already know before we start a new unit of work. I had been using draw.io for making mind maps and found it's very powerful, but not specific enough for anything - it's more of a UML application than anything.
So, as I do with most things, I decided to break the wheel. And then reinvent it.
What I mean is, meet Balf Mind Map. It's free, no data is collected, and no login is required, which is crucial for schools.
