Worlds & objects
Scenes, models, materials and linked prefabs. Build with reusable pieces while keeping instance-specific choices.
Platinum Game Creator
Big ideas. An approachable way to build them.
A welcoming place to make 2D and 3D games. Build a scene, try an idea, and turn it into something people can play. Clear tools and a short path from editing to playing help you keep creating as your ambitions grow.
EXPLORE GAME CREATOR
Choose the view that fits your work.
AN IDEA / A PLACE TO TRY ITStart with a scene.
Start with a scene.
Make it a game.
Arrange a scene, give something a behavior, press Play. Familiar tools and a short edit–play loop make it easy to begin, while deeper systems are there when your game needs them. You can make the creative decisions yourself without assembling an engine from disconnected tools.
Give ideas behavior.
Readable Lua, visual event tables and editable gameplay data work with the same objects. Start with the approach that makes sense to you.
Explore scripting & gameplay ↗A live workspace for your project.Independent tools and live documents share one object model. Explore the workspace, bespoke asset editors and the components for building your own.
Tour the editors ↗The systems behind the game.Gameplay, fixed-step physics, multiplayer, procedural animation, skeletal animation and GPU effects form a connected foundation.
Explore the engine ↗Take it to players.Package, verify, register, license and distribute your release. Publish through your preferred storefront with Platinum’s shared security services available underneath.
Follow the publishing steps ↗Take a real project apart.Coastal Light is our sample FPS and engine testbed. Play the build or learn how the island, movement, combat, Lua and Events fit together.
Play or learn ↗A better experience on both sides.PlatinumSDK connects the tools you build with the software people use: live objects, responsive interfaces, shared services and clear authority.
See the Platinum advantages ↗Your first project. Your next production.
Work directly in the editor, use Lua or Events, and extend demanding systems with native code when you need to. Your artwork, reusable scenes and gameplay choices stay at the center of the workflow.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
LUA / EVENTS / DATA-DRIVEN GAMEPLAY
Scripting & gameplay
Write a behavior in Lua, connect it to a visual rule, and tune it through object properties. All three approaches work on the same game state.
Lua scripting
The first-class runtime for writing your game code.
Lua is the first-class scripting runtime for writing game code: movement, combat, objectives, world systems and complete game logic. Keep code modular and reusable as your project grows. Define Lua objects with ordinary defaults and colon methods, use native object facades, or call engine systems directly from global callbacks. Mix these styles around the behavior you are making; component properties keep the useful values editable in the scene.
Runtime and engine integration
- Start with working systems. Controllers, equipment, health, scoring and networking are already part of the framework.
- Keep behavior reusable. One script can serve many objects with different component values.
- Mix your approaches. Lua, visual event rules and native modules cooperate on the same project data.
- Keep heavy work native. Simulation and rendering stay in their engine systems while Lua directs the gameplay.
Lua code examples
EXAMPLE 1 / 6
A target, a hit, a score
Start with ordinary field defaults and colon methods. Field types and event bindings are inferred; a registered native function can become a normal method. Attach the class to an actor, then let its hit handler emit the scoring event.
LUA
-- Ordinary Lua structure defaults become the backend schema.
local Target = objects.class("Target", {
health = 1,
points = 100,
defeated = false,
})
-- A native function can be used as a normal Lua method.
Target.emit = native.emit
function Target:on_start()
self.health = self.properties.health
self.points = self.properties.points * (self.properties.multiplier or 1)
end
-- Event methods register themselves; no string event mapping is needed.
function Target:on_hit(damage, shooter)
if self.defeated then return end
self.health = self.health - damage
if self.health <= 0 then
self.defeated = true
self:emit("target.defeated", { points = self.points })
end
end
-- Native Target components still own combat and respawn.
function on_start(actor)
Target:attach(actor)
end
Editable component data, readable behavior and shared engine systems.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Visual event tables
When something happens, make a rule.
Event Tables
Pick a readable event, choose the objects it concerns, add conditions and order the actions. Event Tables connect gameplay, UI, animation, sound and physics without turning each interaction into another script.
Event Table workspace
Build a rule: trigger, objects, conditions, actions
- Choose the trigger. Use scene and match lifecycle events, damage, pickups, physics triggers or a custom event with a readable name and documented inputs.
- Select the objects. Choose an exact entity, a type or model, this object, an entity inside its owning prefab, or the event’s instigator or target.
- Test conditions. Combine AND/OR expressions using gameplay values and the event’s inputs. Groups and sub-events let related rules stay together.
- Apply ordered actions. Change a property, award points, control a UI widget, invoke animation, play a sound or call into registered game systems.
Scopes, prefabs and reusable rules
Bind a table globally, to a game mode, to a level or to an individual scene/prefab object. Inherited rules run from the broadest scope to the most specific. Explicit overrides let a mode replace a global scoring rule without copying every unrelated behavior.
Object-local selection resolves within each prefab instance: a gate’s table can address its own moving part even when the scene contains many copies. Each instance keeps its own group state. Broader subscriptions let a UI event control an object while self still means the table’s owner.
Example: change the scoring mode
The sample’s global rules award a point for a non-suicide elimination. Capture-the-flag can override the inherited death handler and award five points for capturing a flag instead. Kills and deaths remain statistics; the objective determines the score. A level can add its own headshot announcement without changing either mode’s rules.
Multiplayer authority and replication
Gameplay tables run on the offline authority, peer host or dedicated server. The resulting world changes, UI updates, animation, particles and sound use the existing replication paths. You do not repeat the table on every client or write a separate RPC for each row.
Connect Lua and native events
Emit a named event from a script or native module. Register its label, category, description and inputs so designers can discover it in the picker. Stable event IDs keep scripts and saved tables working when a human-facing label changes.
Inspect and apply rules live
Use the live event monitor to follow dispatch, inspect the relevant object and conditions, then Save + Apply the table to the running session. Scope bindings live in ordinary project and scene data, so shared rules remain reusable and reviewable.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Data-driven gameplay
Useful values and reusable rules belong to the project.
Controllers, weapons, targets, UI, animation and sound have editable definitions. A designer can adjust health, cooldowns, timing or presentation without rebuilding the engine or duplicating the behavior behind every object.
How data, behavior and presentation connect
Project data
Objects, components, properties, reusable scenes and assets.
Behavior
Lua, Event Tables and native systems read and act on that data.
Presentation
UI, animation and sound respond to the same game state and events.
Lua can emit an event for the table to handle. A visual rule can invoke an action on a selected object. A UI binding can display the result. These are cooperating views of the same project, so each discipline can work where it is most comfortable.
Scope and inheritance in the editor
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
01 / 03 · Lua scripting
THE EDITOR / A LIVE WORKSPACE
One project. Tools with room to work.
Documents own the work. Views and tools help you shape it. Explore the workspace first, then the specialized editors you can use, combine or extend.
Workspace fundamentals
Live documents, independent tools and a consistent object model.
A scene, material, interface or animation is a document with its own identity and data. Its view is not the document itself: selection, zoom and tool state can change without turning the underlying asset into a different object.
Inspectors, hierarchies, timelines and previews are cooperating tools. Keep several in view on desktop, with independent tool windows where useful; the browser docks those tools into a workspace that fits the screen. Focus on one task without making every other view forget what you were doing.
Work in the view that makes sense
Edit a property in an inspector, adjust it visually or change the structured asset data. The host validates the edit against the current document rather than treating every panel as a separate source of truth. Shared commands and history keep related operations coherent.
Live documents also provide a foundation for authorized collaboration and integration with other PlatinumSDK tools. Access stays scoped to the document and operation; opening a view does not grant unrestricted access to the rest of the project.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Build an asset editor
Compose standard tools around your own data and controls.
New asset types can have useful authoring tools of their own. Define the asset’s model and validation, then assemble an editor from reusable components: a hierarchy for structure, an inspector for typed properties, a timeline for motion, a node canvas for connections, or a preview that draws the result.
- Define the asset. Give its document a schema, identity and explicit editing operations.
- Compose the workspace. Reuse standard widgets, controls and authoring panels. Add custom components for the interactions unique to your asset.
- Connect the commands. Translate edits into validated document operations, undoable changes and live previews.
- Register the integration. Make the asset, its editor and its runtime behavior part of the project through a native module.
The bespoke tools below use this approach. A material graph needs different controls from a character rig, but both can reuse selection, properties, commands and the surrounding workspace.
Browse the PlatinumSDK widget reference ↗Explore native extensions ↗Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Scenes & reusable objects
Build a world from pieces you can keep improving.
The scene and asset workspaces organize objects, components and reusable definitions. Place an object, inspect the data that describes it, and decide which changes belong to the shared source and which belong to this particular instance.
THE PROJECT LIBRARY / MORE THAN A FILE LISTA place for every piece.
A place for every piece.
Tools for what it does.
Models and textures, reusable objects and scenes, Lua scripts, event tables, UI documents, animation and sound all belong to the project. Browse folders, search and filter, switch between grids and lists, and inspect a model before placing it in the world.
Behavior & movement
Lua, Events, object animation and character profiles. Author logic and motion as assets you can find and edit.
Interface & sound
Menus, HUDs and spatial audio. Give UI and audio the same deliberate authoring attention as the world.
03 / LEVEL DESIGN · COMING SOONBuild a space.
Build a space.
Walk around in it.
Classic constructive solid geometry (CSG) level editing brings back a direct way to shape a world. Block out rooms and corridors, combine brushes, carve openings, and refine the space as the game takes shape. Use it alongside reusable models and scenes, from an early layout to a deliberately authored level.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Materials
Choose a direct surface workflow or build a graph.
Materials are authored assets rather than a collection of one-off changes to individual objects. Keep surface parameters and procedural choices together, then reuse the material wherever the project needs it.
Use the graph when a surface needs a more explicit structure. Its connections describe how the material is built; the GPU renders the result you are adjusting.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Interfaces
A visual editor and a readable document describe the same UI.
The canvas, hierarchy and property inspector edit a structured UI document. Layout, bindings, templates and instance overrides stay in project data, so a HUD or menu can be reused and driven by gameplay instead of becoming isolated screen code.
YOUR GAME / YOUR INTERFACEMake the interface
Make the interface
part of the game.
Build menus, HUDs, lobbies and settings in a visual UI editor. Arrange controls on the canvas, work in the hierarchy and keep the properties beside what you’re changing. Preview desktop, tablet and phone layouts without leaving the workspace.
Direct manipulation.
Move and resize controls, align selections, snap to guides and use undo or redo as you explore. Clear handles and visible properties keep the work close to the result.
Design meets behavior.
Bind values to the HUD and connect actions through Lua or Events. Keyboard and gamepad navigation, focus and modal screens belong to the runtime, too.
Visual or source.
Work on the canvas or edit the XML and supported CSS directly. Reusable templates and instance overrides let a shared interface adapt to different places in the game.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Character Studio
Clips, state graphs and rig controls form a reusable character.
Character Studio edits animation definitions the runtime can use: clips and cues, graph parameters, layered states, blendspaces, sockets and inverse-kinematics controls. Select an animation task below to see its workspace and purpose.
CHARACTER STUDIO / SKELETAL ANIMATIONA character.
A character.
A whole vocabulary of motion.
Bring skinned glTF characters into a dedicated workspace for clips, animation graphs, blendspaces and rig controls. Shape how a character moves, changes state and carries equipment, with the pose visible while you work.
Lua, Events and native systems can drive the same animation parameters. Gameplay remains responsible for physics, damage and inventory; animation gives those decisions expression through motion, layers, sockets and presentation cues.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Object animation
Author a timeline; let the game supply the context.
Save motion as an asset with named bindings, layers, keyframes and expression-driven inputs. A clip can be shared between objects and adapted by gameplay, rather than hard-coding a separate animation for each use.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Sound
Give audio the same authoring attention as the world.
Audition a sound, define its bus and voice limits, and shape distance attenuation around the way it should behave in the scene. Audio definitions belong to the project and can be reused or triggered from the same gameplay events as UI and animation.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
01 / 08 · Workspace fundamentals
THE ENGINE
Gameplay systems that work together.
A responsive editor matters. So does the runtime underneath it: consistent simulation, expressive animation, connected players and a world that keeps up.
Gameplay foundations
Build systems on a common simulation and object model.
Objects, components and project data connect the editor to the running game. Lua, event tables and native extensions can work on the same foundations, so you can start with a small interaction and grow it into a reusable gameplay system.
05 / GAMEPLAY FRAMEWORKA foundation for the game,
A foundation for the game,
not just the scene.
The built-in gameplay framework brings controllers, collision, weapons, health, pickups, scoring, respawn lifecycles and game events into a coherent component model. Lua and the event table work with the same objects, so behavior stays connected as a project grows.
The fixed-step gameplay framework runs at 120 Hz, with a shared player controller, Jolt physics and authoritative multiplayer. Local movement prediction and reconciliation keep your own character responsive; interpolation smooths remote characters and objects. Lua and Events connect authored gameplay to UI, sound and character presentation.
02 / YOUR WORKFLOW · COMING SOONHuman-friendly.
Human-friendly.
Agent-friendly. Your choice.
The editor is being designed to be straightforward for a person at every step, and practical for off-the-shelf AI agents when you choose to use one. Readable scripts, editable project data and repeatable operations are the foundation for advanced workflows: inspect a scene, organize assets, prepare a batch of changes, or help with game logic.
There is no built-in generative AI, required assistant, or model subscription planned. Bring an external agent of your choice, or work entirely by hand. The engine should help you express your ideas, with you deciding what belongs in the project.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Physics & multiplayer
Responsive local input. An authoritative shared world.
PHYSICS & MULTIPLAYER / FOLLOW AN ACTIONMake the game.
Make the game.
Let the framework connect it.
Built-in gameplay already has a route from input to authority to replicated state. Follow an example to see what happens on your machine, what the session authority decides, and what other players receive. Controllers, equipment, combat and objectives already share these paths.
Write mechanics in Lua, extend the movement controller’s state machine and input graph, or add native capabilities. The feel belongs to your game. The framework’s movement path provides prediction, authority reconciliation and smooth remote presentation around that design.
The framework handles
Shared controller simulation, input history and acknowledgments, correction replay, remote interpolation and fixed-step physics.
You decide / integrate
Compose Lua or native mechanics, extend controller states and the input graph, and define your own acceleration, air control and transitions. A replacement controller or simulation may need its own prediction/sync integration.
FOLLOW AN EXAMPLE
You move immediately. The authority confirms the shared result; corrections are handled without waiting before every step.
Choose a stage to see where it runs and what it contributes.
Your machine
Session authority
Other players
Authority is a role: a hosting player or a dedicated server can run it.
STAGE 1 / 4
Respond locally
The local controller advances movement and aim from your input before the next server snapshot arrives. It retains input samples so the result can be reconciled later.
Contribution: Predict from input
Transport and delivery choices
Native and browser sessions use QUIC/WebTransport and WebSocket paths, with WebRTC support for peer-hosted rooms. Movement prediction, snapshot interpolation and bounded hitscan rewind solve different parts of the experience; reliable commands and transient presentation updates can use different delivery policies.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Animation
Characters, objects, feel and worlds: follow how the motion is made.
ANIMATION / ASSETS, SYSTEMS & THEIR CONNECTIONS
Choose what you’re animating.
Character clips, object timelines and procedural adjustments do different jobs. Follow an example below to see which assets define the motion, which systems combine it, and where gameplay and physics fit.
A character starts with a skinned model and motion clips. Its profile and graphs decide how those clips combine, where the body should reach, and how much it should yield to physics.
The assets and systems in this group
- Model + skeletal clips
- The skeleton defines the bones; clips contain authored poses over time.
- Character profile + animation graph
- States, nested graphs, transition conditions, blendspaces, layers and masks decide which motion to use. Each character has its own parameters and playback state.
- Pose / IK / Physics graph
- Compose aiming, inverse kinematics (IK), nested pose operations and physical animation after the base clips have blended. IK adjusts a limb to meet a target, such as a hand grip or the ground.
FOLLOW AN EXAMPLE
The legs keep moving while the upper body reloads and the hands meet the weapon. These are combined contributions to one pose.
Choose a stage to see what it contributes.
STAGE 1 / 4
Choose the base motion
Speed, direction and grounded state drive the locomotion graph. Nested state machines organize transitions such as jump, fall and land; 1D/2D blendspaces mix the appropriate gait clips.
Uses: Clips + locomotion graph
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Rendering & GPU effects
Light, materials and large effects work with the scene.
04 / RENDERING & PERFORMANCEA modern engine
A modern engine
behind a familiar desk.
Work directly in your game’s GPU-rendered world, with physically based materials, lighting, shadows and live scene editing. Import models such as glTF into the project’s asset workflow, select and transform objects in place, and see the result as you build. Asset thumbnails use the same models you place in the scene.
Tune materials, lighting and effects in context. Scalable scene processing and GPU simulation keep expensive visual work in the systems designed for it, while quality settings let you balance presentation against the devices you want to support.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Particle simulation
Shape a GPU simulation rather than placing a static effect.
GPU PARTICLE SIMULATIONA little spark.
A little spark.
A whole lot of atmosphere.
Build a flame jet, a drifting cloud of smoke or the burst that makes an impact feel right. Game Creator’s Hanabi-powered particle system simulates and renders effects on the GPU, with an editor that lets you shape the result while watching it move in your world.
Shape the effect.
Choose continuous emission or a burst. Tune lifetime, speed, direction, spread and radius; give particles acceleration and drag. Control how size, HDR color and transparency change over a particle’s life, with additive or alpha blending.
See the change.
Live previews update as you edit. Orbit, pan and zoom around the effect independently of the scene. Pause to inspect a moment or restart a burst, with the level and isolated view available together.
Give detail room to grow.
GPU compute handles the visual simulation, with configurable capacity up to 65,536 particles per effect. Cached effect definitions and bounded emitters keep resource use deliberate. Gameplay collision and damage stay in the physics and scripting systems.
Make once. Use wherever it belongs.
Save an effect in the project library, then attach it to scene objects with a ParticleEmitter component. Offset, rotate and scale the emitter without changing the object itself. Keep a local override for one instance, reset it to the source, or deliberately update the library asset for the instances that inherit it.
Let gameplay set it off.
Emit a particle asset from Lua at a position and scale, or attach an emitter to something that moves. The sample includes flame, smoke, explosion and rocket-trail assets, with particle exhaust following physical rockets and explosions connected to damage and impulses. Visual feedback and game rules work together while keeping their responsibilities clear.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
01 / 05 · Gameplay foundations
Native modules
Add asset types, build custom editors, or extend and replace gameplay systems. Choose a module type to explore its workflow; choose it again to close it.
Built-in systems use the same module boundaries
Scene and prefab processing, physics, character animation, audio, materials, particles, networking and authoring tools are modular runtime systems. Select the parts your project needs, extend their services or bring your own implementation with the appropriate contracts.
Custom editor workspace
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
FROM PROJECT TO PLAYERS
Configure it once. Build the next release.
Choose a target and release settings, then repeat the same build workflow as your game grows. Packaging, registration and verified delivery stay connected.
Define the release
Save the settings that make each build repeatable.
- Choose your target.Set the platform, release channel and build configuration for the version you want to ship.
- Choose what belongs in it.Include the project assets, scripts and runtime dependencies, with development settings kept separate.
- Reuse the configuration.Run the same packaging workflow for the next build. Keep release identity, content and service settings together rather than repeating a manual checklist.
When licensing is enabled, the application defines its fixed home licensing server. A distribution mirror or another trusted repository can deliver a build without becoming entitled to issue licences for it.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Build & export
Package the game and connect the release services automatically.
BUILD & EXPORT
Build, register, release.
- Build for your players.Choose a native target or a WebGPU/WebGL browser build. Keep target-specific settings in a reusable build configuration. Platform SDKs, accounts and certification requirements still apply.
- Register and secure automatically.The configured build workflow packages the project and connects automatically to the services needed to register and secure the application. Software Hub receives its application identity, build, release inventory and licensing configuration.
- Ship a traceable release.Signed records and component hashes connect the distributed package to its registered build. Release channels support tracking, verified updates and the licensing policy you selected.
- Repeat without starting over.Reuse the configuration for fixes and new releases. Publish through Steam, itch.io, your own site or another distribution channel you choose.
Use PlatinumAuth and Software Hub together, or configure the supported service boundaries around your deployment. The following chapters explain verification and ownership in more detail.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Register & verify
Automatic Software Hub integration protects the release chain.
Publishing integrates with Platinum Software Hub registration and release verification out of the box. A signed release record covers the declared inventory of executable components, scripts and assets, so validation checks the expected build rather than merely trusting a file name or a launcher.
Trusted publisher keys establish provenance; content hashes establish that the bytes match the release. Validation belongs at the point where the runtime admits content. Signatures do not certify that arbitrary code is harmless, and a changed build must be published as a new trusted release.
Explore the verification chain ↗Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Ownership & licensing
Identity, ownership and access each have a clear job.
PlatinumAuth integration supplies identity while Software Hub handles application ownership and scoped licensing capabilities. Use the built-in registration, anti-piracy and licence validation services without creating a separate account and entitlement system for every game.
Permanent ownership records stay distinct from time-limited services such as subscriptions or multiplayer access. Online authority checks and appropriately scoped offline evidence enforce the access model you choose; a launcher check alone is not the entire protection.
Use Winnitude’s service or operate a repository of your own. Existing identity systems and non-Platinum applications can integrate through the same deliberately scoped service boundaries.
Choose the services your business needs ↗Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Distribute & grow
Steam, itch.io, your own site, or another channel you choose.
Publish your game wherever you want. Exporting does not require using a particular storefront. Signed release channels and verified updates let you maintain a trustworthy delivery path as the game evolves, while the storefront remains your choice.
A NEW PLACE TO PLAY / COMING SOON
Make a world. Find your people.
We’re building toward a platform where personal avatars, game discovery and distribution, multiplayer services and community forums live together. A place to share what you make, meet players and keep a community around a game. It is an additional home for your work, with publishing elsewhere always part of the picture.
Have a game in mind?
Contact Winnitude! to discuss evaluating Platinum Game Creator, engine licensing, platform needs, or a custom integration.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
01 / 05 · Define the release
COASTAL LIGHT / THE SAMPLE FPS
A working project to play, inspect and learn from.
Coastal Light exercises the engine’s animation, netcode, active ragdolls, lighting, UI, material graphs, keyframes, Lua and event tables. Follow those systems from the playable scene back into their scripts, data and authoring tools. Stay tuned for our first full Game Creator release.
Play the sample in the dedicated demo section, or return here to explore how it works. Play Coastal Light ↗
INSIDE THE PROJECT
Follow the game back to its systems.
Explore the playable world, its movement and networked interactions, then see the small rules that connect them.
World & presentation
An authored island, its interface and its effects.
THE SAMPLE PROJECT / LIGHTHOUSE RANGEA small FPS.
A small FPS.
The whole creative loop.
Walk out onto the island, pick up a blaster and try the range. Lighthouse Range connects an authored 3D scene, readable Lua, editable components, event-table rules and procedural animation in one playable project you can take apart and make your own.
Move. Explore. Experiment.
Walk, sprint and jump around the island. Scene colliders give the lighthouse and trees a physical presence; falling into the sea returns you to the authored spawn.
Three weapons. Your rules.
Find the Signal Blaster, Pulse Rifle and Heavy Blaster, then switch between acquired weapons. Damage, range and cooldown live in editable components. Targets award points and respawn for another round.
Change something. Play again.
Adjust a controller, rewrite a Lua behavior or change a scoring rule. Save, restart Play and feel the difference. Stop returns the editor to the authored scene.
Responsive feedback has a budget. The sample reuses effect resources and bounds particles, tracers and impacts, keeping temporary effects from accumulating as you play. View-motion controls let you tone down camera movement.
The front door
1 / 2
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Movement & body
Compose the mechanics. The framework connects the motion.
Walking, crouching, sprinting, braking and weapon handling are cooperating mechanics. Write movement mechanics in Lua or native code, extend the controller’s movement state machine and input graph, and compose their contributions into the result. The shipped controller is a starting point; your game owns its movement feel.
Build a controller from parts
Acceleration, air control, jump timing and state transitions are yours to define. You can extend the existing model or replace its foundation. Layer as many mechanics as your game needs: a sprint modifier, a crouch posture, a slide, a grapple or a temporary ability. Each contributes inputs, constraints or motion through the graph. Compose the active set dynamically as equipment, game mode or character state changes, with explicit ordering and priorities where mechanics interact.
The same movement, locally and online
Movement composition runs through the networked gameplay framework. Local prediction keeps input immediate; the authority validates the result, reconciliation corrects differences, and remote players see interpolated motion. Mechanics participate through their registered state and authority rules rather than requiring a separate networking implementation for every new move.
The body follows the action
Shared movement state drives the character graph, first-person body, weapon pose and procedural animation. Crouch while reloading, blend into a tactical sprint, then brake back into an aimed stance. Animation expresses the composed gameplay state instead of becoming a second controller competing with it.
A body in the world
1 / 4
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Combat & multiplayer
A shared game, with immediate local feedback.
Coastal Light connects players through the engine’s multiplayer framework. Movement predicts locally, combat resolves under the session authority, and replicated state keeps inventories, scores and other players in step. The same project supports peer-hosted and dedicated-server sessions.
Damage, pickups, projectiles and objectives use the shared gameplay systems. Extend them with your own network events or RPCs, then let registered data and authority metadata determine what replicates. The Engine section explains the available session modes and online services.
Connected instances
1 / 3
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
Lua meets events
One component emits a result; another rule decides what follows.
The sample defines Target with ordinary field defaults and on_start/on_hit methods. The runtime infers its field schema and event bindings. Target.emit proxies the registered native function as a normal method; the global callback attaches the class to its actor.
-- Ordinary Lua structure defaults become the backend schema.
local Target = objects.class("Target", {
health = 1,
points = 100,
defeated = false,
})
-- A native function can be used as a normal Lua method.
Target.emit = native.emit
function Target:on_start()
self.health = self.properties.health
self.points = self.properties.points * (self.properties.multiplier or 1)
end
-- Event methods register themselves; no string event mapping is needed.
function Target:on_hit(damage, shooter)
if self.defeated then return end
self.health = self.health - damage
if self.health <= 0 then
self.defeated = true
self:emit("target.defeated", { points = self.points })
end
end
-- Native Target components still own combat and respawn.
function on_start(actor)
Target:attach(actor)
end
The Range event table listens for target.defeated, checks points > 0, then updates team_score with game_team_score+points. The Lua component does not need to know how the objective UI or scoring workflow is organized.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
01 / 04 · World & presentation
BUILT WITH PLATINUMSDK
Good tools should make the whole experience better.
The foundation connects authoring, runtime interfaces and the tools around your project. Its value shows up in the everyday work.
Connected creative work
Carry assets, objects and scenes between cooperating tools.
THE CREATIVE SUITE / WORKING TOGETHEROne bird.
One bird.
More than one way to make it fly.
Build a game with characters you can open in Animator, and scenes you can bring into Video Editor. The tools should understand the work they share.
1. Work on the source in Animator
The bird’s flight cycle is open on the timeline. Objects, animations, scenes, compositions and audio sit in the same project library.
Open image to inspect at full size ↗2. See the same object in Game Creator
The matching bird, pose and revision appear in the scene. Edit animation in Animator leads back to the source; the project links also connect the scene to Video Editor.
Open image to inspect at full size ↗Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
From developer to player
Responsiveness, integration and clear security boundaries.
Tools that work together.
Make your workspace feel like yours. Keep the controls close, let the tools cooperate, and spend your attention on the thing you came here to make.
Your work. Clear boundaries.
Applications are designed around explicit identity and brokered permissions, with access scoped to the files and services they need. Cooperation should not mean giving every tool the keys to everything.
Friends at the same desk.
PlatinumSDK products share application contracts, familiar controls and a common approach to data. Connect the services you need without rebuilding every foundation. Existing systems can join through supported interfaces and adapters; compatibility depends on the integration.
Keep up with the idea.
A native, GPU-accelerated foundation and data-oriented architecture aim to keep feedback close to the action. Less waiting on the interface, fewer interruptions to the work. Actual performance depends on the application, device and workload.
Your workflow. Your vibe.
Shared themes and configurable workspaces let the tools adapt to the way you work. Choose a familiar desktop character or a more restrained business presentation, with consistent behavior underneath. Available controls and customization vary by release.
Leave the plumbing to us.
Discuss a managed deployment to reduce setup and day-to-day infrastructure work, or a self-hosted configuration for your organization’s requirements. Identity, integrations and hosting are configured deliberately rather than hidden behind a one-size-fits-all installation.
More making. Less overhead.
Shared infrastructure helps avoid paying for the same foundations over and over. Ask about an evaluation, licensing and deployment options suited to your scale; we will confirm the price and included services before you commit.
How the security and deployment model fits together
Authentication proves identity; authorization controls actions; encryption protects content in a defined storage or transport context. Release hashes and signatures establish integrity and provenance, not that software is harmless. Process isolation and resource brokering are runtime responsibilities. We help you select the runtime, hosting and access settings that fit your deployment, and explain which protections each layer provides.
We agree the hosting, integrations, access rules and support responsibilities with you during evaluation, so the setup matches your organization.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
01 / 03 · A useful workspace
PLAY IN YOUR BROWSER
Try the Coastal Light sample.
Coastal Light / Coastal Range is our playable sample project for Platinum Game Creator. Explore the range and see netcode, skeletal animation, active ragdolls, PBR lighting, event tables, authored UI, keyframe animation, material graphs and spatial sound working together. We keep developing the sample alongside the engine; stay tuned for our first full Game Creator release.
winnitude! SOFTWAREA PLATINUM GAME CREATOR SAMPLECOASTAL
COASTAL
RANGE
A little sea air.
A little target practice.
LATEST DEMO / WINDOWSCoastal Range.
Coastal Range.
On your desktop.
Try the 20 October 2026 motion build with authored menus, spatial sound, skeletal characters and shared multiplayer gameplay. The ZIP includes the standalone game and its project assets.
Extract the ZIP and run CoastalRange.exe, keeping the assets folder beside it. Play solo or join a configured multiplayer server from the game menu. Server setup is separate from this player download.
Windows 64-bit · Native build
The browser demo above remains available.
The browser demo above remains available.
Find your feet.
WASD move · Mouse look · Shift sprint · Space jump · C / Ctrl crouch
Try the range.
E pick up · 1–9 switch weapons · Left mouse fire · R reload · V first / third person · Esc pause and release the mouse
Choose Start or Resume in the game, then click the view to capture the mouse. If your browser declines mouse capture, drag to look; right-drag avoids firing. Use a desktop browser with WebGPU enabled. A full-window tab gives the game more room.
Protected by default through PlatinumSDK: scoped permissions, validated data operations and verified module admission keep shared work and executable extensions inside explicit trust boundaries.
PART OF THE PLATINUM FAMILYA familiar feel.
A familiar feel.
A modern foundation.
These tools are built around PlatinumSDK, and your own applications can be too. Reuse document editors, controls, commands and workspaces, or bring your own application model. The direction is a compatible family of tools that can cooperate around shared work. Cross-platform support remains central; availability varies by application and release.
Explore the application family ↗