Basically, it works by combining the best old and stable technologies with the best new and popular ones, resulting in a platform that's both sane and cool.
The A4 Virtual Machine is built around a modern implementation of Smalltalk, the original object-oriented computing platform. So at it's heart A4 is just textbook computing infrastructure, entirely devoid of new innovations.
It's this complete lack of new innovations that really allows A4 to shine. Instead of struggling to prove half a dozen new concepts, A4 enables developers to build on concepts which are already proven, already stable and already well-documented.
This leaves you with a complete, high-level application framework that takes up less than half a floppy disk and can be ported to just about any platform with a C compiler.
On top of the core virtual machine, A4 features an extensible system call framework allowing programs running inside the virtual machine to interact in a systematic way with extensions written in C.
This framework is similar in design to the Unix system call mechanism, and in particular the virtual filesystem (VFS) layer, but with some modern enhancements (such as graphics primitives and a URL-like naming convention).
There are several benefits to this approach, compared to the more commonly-used foreign function interface (FFI) model. Every A4 extension operates over a clean and well-managed interface, ensuring that the program in the virtual machine won't accidentally (or deliberately) mismanage pointers into memory.
This also allows certain resources (such as windows on a desktop) to be automatically reopened when the app resumes execution. Just as importantly, this system allows the application developer to iterate over every open resource in a high-level way for debugging, testing or optimisation purposes.
The main downside (compared to an FFI) is that extensions need to be written in C instead of in a higher-level language. However, this is a small price to pay given that the details of underlying APIs are usually easier to work with in C anyway.
Extensions which are currently in a usable state include:
cell(for division and command of program state, with support for multithreading and persistence)
memory(for accessing system memory resources, and for sharing them between cells)
window(for displaying graphical content on a desktop using SDL2)
event(for receiving events, such as mouse movement, keyboard/button presses and [soon!] messages between cells)
pixmap(for holding a 32-bit RGBA image in memory and [soon!] reading and writing to PNG [and JPG?])
painter(for rendering smooth 2D graphics and text on a
pattern(for building gradients and image patterns for use with
Planned extensions include:
file(there is still a legacy API for file access, but eventually this will be replaced with a better-managed version based on the new system call API)
os(for getting system information and performing platform-specific commands)
https(these will probably just be tight wrappers over something like CURL, so expect full access to web resources)
internet(for raw TCP/IP networking, e.g. to implement messenger or file-sharing protocols)
otp(for interacting with Erlang/OTP applications, and for easy-to-use cluster/cloud connections)