Welcome stranger, miss us ? Yeah we know, we haven't been updating the site a frequently as some of you or I would like, but there's an up side, we're been stuck in the trenches improving PlayBasic just for you ! So it's not all bad. If you want the very latest up to date news/bets, then your best bet would be to join the forums or via facebook. I post pretty frequently on both, so either way you'll be kept in the loop.
Anyway, so what has been going on ? - Well, there's a way too much for me to cover in every tiny little detail, jump on the forums for that, so I'll just go over the major bullet points. Which basically breaks down into three topics, Most recently focus has been on a new retail update called PlayBasic V1.64N2, prior to that we're been secretly working on a new graphics engine and third generation runtime technology called VM3. The later I can't really talk too much about, but are quietly confident that any successor to PlayBasic will be a major step forward and not small one.
PlayBasic V1.64N2 Work In Progress
First, lets kick around what you'll find in PlayBasic V1.64N2 update. This upgrade was originally slated to address some small bugs in V1.64N, but has since been expanded to include a number of new compiler and runtime performance improvements. Performance is something we care a lot about, from the compile time speeds, through to execution and command set performances, Every little detail matters. The classic versions of PlayBasic (V1.64 and bellow) run on the hybrid runtime technology. This is the engine that runs your game code, so the faster it is, the better your game performs. Back in the early days of PlayBasic, improving the runtime performance was often fairly trivial. But over time, the vast majority of the fat has been cut off the bones. Making, tweaking it up more and more difficult. To the point where most improvements today come more from changes to the compiler, rather than any micro optimization to the runtime.
The compiler process in PlayBasic takes the users source code and builds a byte code representation from it. The byte code is like a custom machine language that runs exclusively on the runtime, or virtual machine. Now the thing is, often when the compiler assembles the user code, it can output sequences of instructions that are perhaps more might be needed. To counter this, we added a set of expression optimizers to PlayBasic a number of years ago. Which helps the compiler produce a more stream lined sequence of instructions that represent the same logic. The general rule is, the less instructions or the more work the instruction does, the faster your end program executes.
So the optimizer gives a good boost for at what it does, but it's limited to operating within certain expressions, but not anymore. My current work revolves around adding a new optimizer mode that caches type accesses throughout user code. Generally when the compiler sees a Typed Array or LIST, it drops the required code to read or write to that data structure. The thing is, when you look through user source codes, such accesses are generally serialized across groups of lines. So what the optimizer does, is it tries to cache accesses of that sequential type data, reducing the work the runtime has to do. Performance wise, we're seeing some staggering results in the brute bench marks, where V.164N2 is anywhere from 25% to 50% faster than V1.64N retail. Which in turn is much quicker than the V1.64L learning edition, I might add.
What's even more interestingly is that these changes significantly close the gap to some of our so called native machine code BASIC compilers. I would expect those to be at least 10,20,30 or more times faster than our 10 year old virtual machine, but V1.64N2 closes the gap to as little as 5->6 times, PlayBasic can often beat them in certain tests. Which is very encouraging, but I think that just demonstrates how poorly some native BASIC compilers are at generating code. Which makes you wonder.
PlayBasic FX - VM3 and OpenGL Based graphics Engine
What's PlayBasicFX ?, well it was designed to be the successor of PlayBasic, you can think of it as PlayBasic V2.00 really. Originally the concept was to built a more modular edition of the PlayBasic language. Allowing the compiler / runtime & command sets to evolve individually. This would allow many things, such as the ability to swap standard command sets could, allowing programmers to the pick what command sets they want to use, or allow 3rd parties to build wrappers for their engines. To date, there's a number prototype editions of the package floating around testing alternative command sets and runtimes. Some are released, some not. The the thing is, since the project was first designed, the computing landscape has changed dramatically. Forcing us to rethink the core priorities for the project.
When the idea of PB first revolved, gaming and indie game programming were very much Windows based activities. But today, being Windows based is a placing limitation on our fellow game programmers, who might way to build apps for MAC, LINUX or even mobile devices. Now that goal conflicts with the original editions of PBFX which were using Direct3D, making them Windows Only. As such, we've taken the very difficult decision to discontinue the old line of development and build fresh new edition out of it's ashes.
Which brings us to our third generation runtime technology, creatively called VM3. While the VM3 runtime is designed to be platform independent, it also includes all the best features from our previous generations and more. Giving it some real performance punch, which is pretty necessary given how slow some hand held devices are (budget tablets). Unlike older editions of the runtime, VM3 is stand alone. So there's no attached built in command sets. If we're talking potentially going cross platform, then there's really only one option for our base command sets, and that's to base it on OpenGL. Which is what i've been secretly doing for a while now. Not that it's a well kept secret
The new graphics core is focusing on 2D first, the current editions are basically image/sprite based, but you can render all the standard PB graphics types such as Lines/Circles/Dots/Boxes etc. One of the older goals was to make FX command sets backward compatible with the classic version of PlayBasic, but this is no longer a core objective. Unfortunately, it's not viable to do that, since OpenGL works very differently, so there will be some command changes. As for exactly what's in it, we're keeping that secret for the time being.
Anyway, here's a short sneak peek of the perspective bubbles tech demo running on a the new OpenGL based graphics engine. The demo is perspectively projecting the bubble sprites, where each translucent sprite moves towards the camera much like in classic star field effect. The effect isn't that interesting really, it's to give you a quick glimpse at the OpenGL graphics engine is in fact up and running, even if in an completely unoptimized state. In this demo the engine is actually linked to the PlayBasic runtime, creating something of a Frankenstein version really just for testing. The final engine will ship with PBFX
