Vastworx by Berowsma Studios

The server framework for persistent worlds

A distributed C++17 server architecture and visual toolchain for building MMOs. Game-agnostic by design: the engine ships no game, and your content defines the world.

Explore the engine

Read the docs

C++17 UDP / TCP Visual scripting Distributed architecture Multi-database

Platform

Built to run a world, not a match

Persistent state, distributed simulation and a toolchain your designers can actually use.

Distributed architecture

Seven cooperating servers: Login, World, Coordinator, Expanse Controller, Region, Universal Chat and AI. Add region servers to add capacity.

Visual scripting

Node graphs compile to bytecode and stay in sync with their text form, so designers and engineers work on the same logic.

Predictable performance

A 10-20 TPS simulation tick with condition-variable waiting throughout. An idle region server sits at 0-1% CPU.

Architecture

Seven servers, one world

Clients speak UDP to the servers that need them: Login to get in, an Expanse Controller to create a character, and the Region running the ground they are standing on. Everything behind that is TCP.

Editor

Design the world, not the plumbing

Schemas, content and behaviour live in one editor. Changes export as data the servers load, so shipping content does not mean shipping a build.

Visual schema designer with generated migrations
Node graphs and their text form stay in sync
Integrated script editor with syntax highlighting
Validation before export, not after deploy

See the editor

Under the hood

A reliability layer built for world state

Clients speak UDP, so ordering, fragmentation and retransmission are ours to own. Packets carry an explicit flag header rather than relying on the transport.

// Illustrative only. Flag names and values are simplified.
namespace Network {

    // Each datagram carries a flag word describing how it must be handled
    // before the payload is read.
    enum class HeaderFlags : uint16_t {
        SequenceStart   = 0x2000,  // first packet of a session
        SequenceEnd     = 0x8000,
        Acknowledgement = 0x1000,
        Fragment        = 0x0800,  // payload continues in a later datagram
        Reliable        = 0x0200,  // must be retransmitted until acknowledged
        SelectiveAck    = 0x0008,
    };

    void Connection::Receive(const Datagram& d) {
        if (d.Has(HeaderFlags::Fragment)) {
            reassembler_.Accept(d);       // hold until the run completes
            return;
        }
        if (d.Has(HeaderFlags::Reliable)) {
            Acknowledge(d.Sequence());    // sender retries until this lands
        }
        Dispatch(d.Opcode(), d.Payload());
    }
}

Illustrative — not the actual public API.

Comparison

How Vastworx differs

Measured against the usual shape of an MMO backend: one process, one language runtime, one database.

Capability	Vastworx	Typical MMO stack
Architecture	Distributed, seven roles	Monolithic
Language	Native C++17	Managed runtime
Scaling unit	Region server	Whole process
Visual scripting	Node graph to bytecode	None, or text only
Client protocol	UDP with a custom reliability layer	TCP
Cache	Shared memory locally, TCP remotely	Database round trip
Game content	Data and scripts, engine is agnostic	Hardcoded entity types
Simulation tick	10-20 TPS, condition-variable waits	Busy-wait or fixed sleep

Built on

C++17

UDP / TCP

Shared memory

Multi-database

Unity

Unreal

Custom clients

Latest updates

All updates

No updates published yet.

Start building

Tell us what you are building and we will point you at the right starting place.

Get in touch

Read the docs