Description in Brief

The NAOS Engine™ (pronounced like "chaos") is a highly scalable, client/server game engine, designed to support a very large MMORPG. Continuously developed and refined for our own game, Vendetta Online, the engine has been proven through years of usage and expansion (public Alpha in May of 2002, retail game launch in 2004, and up to present-day). The game has over a million installs on Android alone, has been the subject of major television commercials, and was the first MMO to officially launch support for the Oculus Rift.

Our engine client supports Windows Vista-10 (and RT/Store), Mac, Linux, iOS and Android™, with rendering drivers for DirectX (11 and 9), OpenGL and OpenGL ES 2.0 and 3.0. The server is intended for distributed use across a cluster running FreeBSD or Linux, and has been elastically implemented on Amazon EC2. We are currently in the process of making this engine available as a licensed middleware product.

Points in Brief

• Update Server in C++, TCP network protocol, optimized minimal-delta patching (smallest possible download per user), very proven in wide usage. Supports maintainance of patch releases across many concurrent ports. Update client supports automated failover to multiple Update-clusters in the event of failure. Update Client is also a crash reporter, will detect and submit client tracebacks across all client platforms. Posts via HTTP to custom bug tracking/sorting server. Self-updating of the main application is even possible on mobile platforms (with some limitations).
• Game Server in C++, Lua, Erlang. Runs distributed across cluster based on FreeBSD or Linux. Scalable: Sector Daemons, controlling areas of game-world geography, are only run when needed (by player activity), distributed across N-machine cluster based on monitored per-machine CPU/memory load. Erlang-based Kourier subsystem maintains persistent lightweight threads for hundreds of thousands of NPCs as they transition across running/non-running game spatial bounaries. Erlang distributes elegantly, allows thread hibernation to further reduce overhead.
• Game Client written in C++ and Lua. Build targets for Windows (Vista-10, RT), MacOS X, Linux/32, Linux/64. Big and little endian, 64bit clean. Designed for portability, all hardware and platform-specific APIs are abstracted into separate drivers. Available drivers include DirectX 11, DX9, OpenGL, OpenGL ES 2.0, ES 3.0, Windows Wav-out, Windows DirectSound, Windows Vista/7 WASAPI, Mac Core Audio, Android Java audio, Android touch input, Android native joystick input, etc. Many other drivers possible to develop and drop in. OBB and primitive collision detection, polygon soup physics. Shader support, progressive/discrete LOD, advanced particle system. Very efficient, compressed UDP game protocol, with MTU path discovery. Compressed data file format for client-side game assets (can be encrypted). Spatial partitioning with Octree or Sweep & Prune. Fully featured UI system (all Lua), scroll regions, tree/list controls, drag-and-drop, etc. Optional hooks for the TeamSpeak 3 SDK, allowing for integrated voice chat across all current platforms. Includes native support for the Oculus Rift, Gear VR, HTC Vive, Leap Motion and other cutting-edge devices.
• Administration, Billing, Etc. Completely custom Lua/FastCGI website application, highly scalable by maximizing static content, distributing dynamic. Has received many sudden traffic influxes with little impact on load. Built-in messageboard and customer support applications. Custom automatic bug tracking of Lua errors, client crashes, etc. Billing system with secure, heavily tested implementations of APIs for PayPal, PayByCash, and credit cards (First Data). XMPP (jabber) functionality also available for administrative or expanded-player-usage (phone/mobile) applications. Custom mailing-list implementation for newsletters and the like, tags for username and unsubscribe links, automatic bounce removal, etc. In-app-purchase support for iOS, Android Play Store, Amazon, Windows Store and other mobile systems.

Planned Features

The NAOS Cloud™ will also include a cloud-hosted server solution, allowing the game developer to focus their efforts on gameplay rather than systems, network and facilities engineering. A sliding scale of cost that increases with the usage/revenue of the title, after launch, is intended to make the Platform more accessible to startup game companies.

We're MMO developers, so we call the "3D/game engine" the "client", to differentiate from the "server". Just to clarify for the mobile-reader, this "Client Engine" area basically equates to what most other companies call their entire "engine". Our engine can be used for anything, not just MMOs, it's very flexible. Here are a few features:

• Build targets for Windows Vista-10, MacOS X, Linux, iOS and Android™. Big and little endian, 64bit clean.
• C++ based low-level functionality, with Lua on top. Much "game" and UI work can be done entirely in Lua.
• Fully native DirectX (11 and 9), OpenGL and OpenGL ES 2.0 and ES 3.x renderers available; complete separation of engine function calls from low-level APIs, to allow simplicity of future renderer development.
• Proven UDP game protocol, with custom guaranteed packet delivery, retransmission and sequencing figures. MTU discovery automatically optimizes for connection, proven through a vast number of consumer routers and the greater 'net (easily user-disabled as well). Custom packet compression can be optimized to the specific stream profile with genetic algorithms. Strong but fast encryption also available.
• Compressed data file format, allowing all art assets and other information to be rolled into a single compressed file, with optional encryption also available.
• Portable rendering engine supports progressive/continuous and discrete LOD, general geometry instancing and VR stereoscopic instancing, gamma correct rendering, material-based and object-hierarchy based scene graphs, multitude of shaders, compressed color and normal maps, animating textures, PNG with alpha, JPEG loading, etc.
• Optimized OBB and primitive based collision detection system.
• Threaded physics engine supports polygon soup collision meshes, first point of contact, center of mass calculations, conservation of momentum, etc.
• Advanced particle/FX system, with hierarchical effect definitions, envelopes, particle emitters may other particle emitters, etc.
• UI with fully featured interface controls, scroll regions, tree controls, list controls, drag-and-drop, etc.
• Spatial partitioning implementations via both Octree and Sweep-and-Prune (performance tradeoffs for either depending on usage).
• Portable sound system with stereo floating-point mixer, arbitrary number of simultaneous sounds, doppler effect, 3D positional sound (outputs to stereo). Integrated OGG/Vorbis support.
• Platform-specific sound drivers for Linux, Mac, Windows (Wave-out, DirectX, Vista/7) allows hardware features to be kept separate from portable code, simplifies adding new sound support.
• Scales very well across a variety of hardware (depending on art content used and implementation methods). Vendetta Online can run on a low-end smartphone, and still look cool on a heavyweight gaming desktop. Client engine also applicable to single-player or non-MMO development.
• Optional hooks for the TeamSpeak 3 SDK (implementations both server and client side) allows for integrated voice chat across all client platforms.

Beyond this, there is an entire art pipeline, with a whole suite of custom tools (available for Win/Mac/Linux) to help artists build and prototype their assets, visual effects, and other features. Custom export plugins are available for 3D packages, etc.

This area is under construction, more information will appear soon.

The Basic Architecture

Vendetta Online was conceived as a single-server, non-sharded game universe of potentially unlimited scale. Although our engine would work equally well with sharded designs (sharding is much easier), this historical point is mentioned to help illustrate the background of our architectural choices. The server-side needed to be able to scale effectively to a very large simultaneous-player capacity, while the client-side needed playability across a broad range of available hardware. We began development in 1998, during the modem era, so a strong emphasis was placed on network protocol efficiency; in later years this has helped us to pack a great deal more activity into a smaller amount of per-client bandwidth, a feature of particular value on mobile wireless networks. (We have also elastically implemented the server on Amazon EC2).

Like many live MMO products, Vendetta Online is still undergoing a process of continual refinement, so some aspects of architecture may fluctuate over time. That being said, here are some basics:

The Server

• The Core Packet Router, uses tightly optimized C++ with administrative Lua on top, and handles player connection aggregation and logins. Per-user packet queues allow variable rate shaping, packet re-ordering and optimization (newer update replaces unsent older update). Realtime datastream compression further improves bandwidth usage, compression tables may be genetically optimized to common packet use cases. Connections to Players, Kourier (Erlang), Sector Daemons, and the SQL server are maintained. Features built-in webserver with admin functionality.

• The Sector Daemon actively controls an area of game geography, written in C++ and Lua. Vendetta Online is made up of over 7,000 different "sectors"; only those with players in them are "awake" and running at any given time. The SD can control any physically sized region, and handles the server-side of intensive tasks such as collision detection, physics, and low-level AI (PRM pathfinding, etc). SDs are distributed across a large cluster based on monitored per-machine CPU and memory load, with SDs transparently started as needed by players in the game, and shut down after "idle" parameters are met. Any number of sectors are possible, allowing for a game universe of near-infinite scale.
• Kourier is the moniker given to our Erlang-based subsystem, used by us to control large-scale gameplay and AI. For example, an individual Sector Daemon may handle the low-level AI for a given set of NPCs, perhaps a hundred or so in a specific region, having them react to various input criteria and other areas requiring high performance. Kourier, on the other hand, manages the high-level behaviour across tens of thousands of NPCs, commanding them on a larger scale and managing the behaviour of armies, nations, economies, and the like. Erlang is a highly-scalable functional language and runtime system, originally developed for use with always-on phone switches made by Ericsson. Distributed usage and lightweight threading are two of its core properties, making it ideal for our application. Using this, we can maintain persistent threads for every NPC, as well as many other game cases, with minimal overhead and great scalability. Should the NPC be unneeded, such as being located in a non-running sector, the thread can be hibernated, reducing the overhead even further. Vendetta Online often has tens of thousands of NPCs in production at any given time; beyond this we have tested the Kourier system with over a million NPCs at a 10x simulation rate, without issue (each NPC using two unique threads, on a single quad-core machine with 4GB of ram), and we expect it to scale far beyond that point. Kourier also includes an advanced binary logging system, capable of recording thousands of events per second, which can be used as a kind of chronological database, allowing one to view only what is pertinent to the task at hand.

"But how much will this cost?" is the obvious question. We've kicked around a number of notions for this, and recently come to the following (this is still in flux, and subject to change):

• The client 3D/game engine will be free for single-player and two-player games (in binary/library form). This includes all platforms: Win, Mac, Linux, Android, iOS, WinRT. You can ship any kind of single-player or two-player titles you want, in any quantity, with no revshare or licensing fees, forever. If you're looking to make 90% of the mobile or indie games out there, and comparing engines, that basically means you get the "engine" for free. Build the next Angry Birds, make a zillion dollars, we wish you the best.
• If you want to build a real multi-player game, or add serious multi-player features, we'll ask you to work with our NAOS Cloud offering (our NAOS Server hosted, by us, in the cloud). The NAOS Cloud will basically bill you at close to our "cost" for the monthly bandwidth, CPU usage and server resources used by your title. Beyond this, we'll ask for revenue share on a slow curve that will scale with your gross revenue, starting out very small when your revenues are small and staying small as you grow. If you make over a million dollars US per year, our rev-share will peak at 10% of the money you actually make as a developer (what you are actually paid, across all types of revenue streams from the title, after the cuts and fees from App Stores and advertising networks and the like).

"But how can you afford to do this?" is the next question. The above proposal differs quite a bit from the norm; we're basically "giving away" what everyone else sells as "the engine".

The simple answer is: we're game developers. We made this engine to help us achieve our goals in game development, and games like Vendetta Online are where we make our money. Thus, we can give away the engine itself without really impacting our bottom line. We also have quite a low overhead, which we'll continue while rolling out this engine. We aren't likely to spend money on an expensive booth at GDC; we think developers would rather just try the product themselves and make their own decisions.

"What if I want a specific feature? Or support? Or a source license?" We can accomodate those things. We're always going to be improving the engine anyway (for our own usage), and if the community wants a higher priority on something, we can potentially post a bounty for that feature (the associated development costs for us to add it more quickly), and let the community crowdfund the improvement.

Beyond this, we can do source-licenses and support a-la carte, but our main goals here will be the creation of a moderately self-supporting online community, built around the "free" binary/library engine-license. As MMO developers, creating this kind of community is pretty familiar territory for us.

Other on-going improvements to the engine will continue to get released over time, for free, as we make changes for our own development usage (our own games).

We're looking for developers to help us test the engine, when it becomes available. There will be no cost associated with this, we're just looking for feedback on how to make our engine best fit your needs.

If you're interested, submit your email address below, and we'll shoot you a message as we get closer to release.

If you'd really like to directly contact us, you can send an email to licensing at guildsoftware dot com.