You may remember a while back I had posted a lot about an online game platform called Crayta. For a while, I was really into Crayta, learning Lua again and hopefully creating useful widgets that I and other aspiring game developers could deploy. As time went on and I spent a good 8 hours a day with this tool, I eventually burnt out and, coupled with the fact that it’s a Stadia-only product that was burning through by monthly bandwidth allotment, put Crayta aside for, oh, a while. That while turned into weeks, then months, and here we are in September and I haven’t even considered going back.

Part of the reason is because I learned about a new player in this all-in-one game development-slash-discovery arena called Core. Core is very much like Crayta in that it offers users the option to play or create games, or both if they’re feeling ambitious. Like Crayta, Core uses Lua for its scripting language. And like Crayta, developers can build a world from pre-made mesh objects, lighting, and audio.

Since I’ve already written about Crayta, this post is strictly about Core.

Ease of Access

Core is made by Manticore Games and is currently in open alpha. You can download it to your local desktop, install, and run it. If you just want to browse a catalog of projects created with Core, you can hit up Manticore’s website, click the “Core” nav header, and see what’s being offered. If you want to play any of them, you’ll need to download and install the platform, which doesn’t please me entirely, but since it’s a free download I can’t complain too much.

Getting Started

After launching Core, you are greeted with a list of projects that are available for play. “Active games” are, I suppose, games which have players in them, as Core offers multiplayer as a rule (we’ll get to that later). The current crop of “Featured” projects are cleaving to a D&D style which is because Wizards of the Coast has partnered with Core to sponsor a “create an adventure” contest using licensed D&D assets. The judging will be done by WotC folks and notable online TTRPG luminaries…today, I believe (9/15/2020) during a PAX Online broadcast. It’s a massive feature in Core’s cap to have such a visible partner and presentation.

Core’s entry point

In Game Shop

Core has no product purchase option. Instead, users can purchase packages in several configurations. These generally include different avatar skins, mounts, in-game currency bundles, and Founders Packs. Considering the platform is free and all of this stuff is visual gravy, it’s not hurting anyone. None of the building blocks are behind a paywall as far as I can see.

Core’s Founder’s Packs (other options are available)

Building Blocks

Core’s designer UI

Core’s development area is mainly a designer area. The main viewport is your game world. Below that you have palettes of Core- and community-provided objects for use in constructing your world. These include building block primitives, lighting, effects, textures, and audio. In the image above I have added the error log panel which indicates that all panels are mobile and can be docked where appropriate. On the right we have the world hierarchy of objects added to the world, and below that, the properties panel. A toolbar runs along the top of the UI.

Unlike Crayta’s focus on voxels, Core’s primary mode of building is through the use of primitive objects. Many, many things can be constructed in this way, from weapons to buildings to space ships, boats, props, and so on. Core does provide some pre-built templates which have the added benefit of being “usable” in that they have the necessary scripts and actions already applied to, say, allow you to pick up a gun and shoot, complete with animation and everything. If you don’t like the default items, you can always drag individual parts into the world, group them, add scripts and actions, and when you turn it into a template, it’s ready for use in the game.

A custom built mage’s staff, exploded, in Core

Core’s objects are 3D meshes and come in two varieties: textured and primitive “untextured”. Textured objects are modeled and designed; they have a specific look, like a sci-fi bulkhead or a high fantasy dungeon wall complete with moss. Primitives (prims) have no texture applied, and sport that fine looking architectural blue-and-white grid motif you see on the ground plane above. However in both cases, you can use one of the many provided textures to override what the object is sporting by dragging it from the object library and onto the object. This way, you can design an object using items from the collection of over 1,600 individual pieces, and then drag and drop textures where appropriate. I don’t believe you can paint on objects, however. Sadly, it doesn’t look like you can import your own textures, either.

Same object, different textures in Core


The paradigm of “adding functionality at the source” applies to scripting in Core. In order for an object to have functionality, scripts are written and are attached as children of the object (or object part). This keeps the script with the object, and also allows the script to reference the object mesh using “parent” keywords.

Compound object in Core, with many scripts attached.

This mage’s staff comes from a tutorial on the Core site that I worked through. The staff is a composite of three items — two handles and a head piece. The highlighted items on the right are all of the scripts and “abilities” that make the staff work.

Abilities are Core-provided actions that cover a lot of the functionality that we’d be expected to script, like attacking with a weapon, reloading (which isn’t useful for a staff), and picking up an item we come across. This is a massive timesaver, and is made even more convienient through the way Core handles placement of items on your avatar, which is way beyond the scope of this post but is easy to understand and works supremely well.

The one crucial aspect of Core’s item functionality is understanding “networked” versus “non-networked”, and the different contexts in which a script behaves. This is something I’m still a bit fuzzy on, but because Core has networking built into every game (whether you want it or not), scripts need to know exactly where they should be acting, what info they can expect to receive, and who can expect to receive their info. A “client context” for example is specific to each client and is useful for things like a UI that is only seen by a single player. A “server context” is used when an object in the game needs to execute code “on the server”, either because it’s game logic or because it’s resulting output or action needs to be broadcast to all players in the game. Breaking down the context in this manner seems straightforward, but knowing what has to go into a client context as opposed to a server context, when functionality seems otherwise pretty simple, is a bit tricky at my current level of understanding.

If you can zoom in on the image above, you’ll notice that the script on the left — the client version — and the script on the right — the server version — both include event handlers for “Binding Pressed”. These scripts handle the “zoom” functionality of aiming the staff so when the right mouse button is pressed, the camera zooms in for the user. Each handler, however, does something different: the client handler, where the actual visual effect of the zoom happens just for that specific client, raises another event to actually do the zoom, while the server handler forces the zooming user to walk instead of run because all clients in the game need to see the zooming user slow his or her pace.


I haven’t really spent much time with Core, especially compared to the time I spent with Crayta, so this post is to be taken as an overview of possibility and not a comprehensive review.

I like what Core is doing here overall. I think their catalog of building blocks is solid (though more would always be better since we can’t import our own meshes) and the drag-and-drop texturing is extremely useful. There are many special effect textures that can be applied to objects for some very cool visuals. I think offering components is a smart move; having everyone use the same sword or the same gun is serviceable, but “kitbashing” new objects together is going to seriously make up the difference between the stock items available to everyone, and something unique that can set your project apart from everyone else’s.

There’s a few things I’m not super psyched about, though. The first is the all-inclusive nature of the platform. Core games are played by Core users, and I don’t think it’ll be an easy sell to get people to try it if they aren’t interested in making their own projects. That usually results in a lot of builders who would rather have other people play their games, and fewer people who are just there to play. If Core could export a stand-alone distributable so individual games could be traded without the overhead of the launcher and the dev/design tools, that would be fantastic.

I’m also not excited that multiplayer is the default. Crayta is the same way. There doesn’t seem to be a way to limit the number of people per-server down to 1 (which I believe Crayta has) nor is there an obvious way to limit the number of players in a server to anything less than the maximum.

This leads me to my biggest gripe about Core, and Crayta as well: they are focused on very specific game types, specifically run-and-gun, which draw specific crowds. I don’t want to create another Battle Royale game, or another CS, or another variation on “the floor is lava”. That’s not to say that I can’t; the current D&D contest shows that a dungeon crawl is totally doable, and from the ones I’ve played so far, can be expertly done and a lot of fun. But they’re all still action-focused. Core offers a lot of quality of life features out of the box, but they’re all focused on first or third person shooter aesthetics. As with Crayta, UI elements are not a first-class citizen, serving mainly as a source of icons for buttons, health bars, or leaderboards. I don’t believe there’s any way to use a UI element as a textbox input, for example.

I’d like to see a similar platform that isn’t all about catering to the “format du jour” and makes it easier to start off with, say, a top down space-shooter with physics, or a side-scrolling platformer. I know, I know…there are other platforms which are better suited to those kinds of games, but I think it’s in Manticore’s best interest to broaden the appeal. While these games can certainly be done, it wouldn’t be without wrestling with all aspects of Core’s main focus to get it out of one, easy and convenient shape, and into another, less perfect, more contorted shape.

So what I thought I might try was to recreate something like Firefall. I had been looking through the documentation on terrain manipulation, and thought about Firefall‘s tropical setting. That would be a cool area to design, what with the rocky hills and mountains, sand and ocean. At least getting a landscape done would be a big achievement for me, and since the platform is geared towards shooters, a lot of that work would be done. I’ll have to see; my motivation these days isn’t where it used to be.

Sound off!

This site uses Akismet to reduce spam. Learn how your comment data is processed.