SpaceKit features

The playable loop

Explore a world on foot → board your landed ship → lift off → cross space → touch down somewhere new → step out and explore.

• Explore on foot. Walk a procedurally generated planet, or jetpack across it.
• Board where it stands. Walk up to your starship on the surface and interact to board.
• Planet to planet. Lift off, climb out through the atmosphere into space, cross open space to another world, pick a spot and touch down on the terrain.
• Zero-g boarding. The ship’s door also works in zero-g, so you can board or leave the ship out in open space.
• Playable demo maps. Every step of the loop is playable in the included demo maps.

Procedural worlds

• Spherical planets streamed at runtime from layered 3D noise, with no baking and no loading screens.
• Ring habitats. Cylindrical O’Neill-style rings (ASKRingWorld) built on the same terrain, noise, foliage and grass pipeline as planets. Terrain sits on the inner surface by default, and you can place it on the inner or outer surface.
• Ring structure. An outer structural shell (the hull cylinder), end walls, and translucent shell layers for cloud decks and atmospheric haze.
• Layered 3D noise. Perlin, Simplex, Cellular, Ridged and Domain Warp, stacked in layers with terrain presets.
• Climate biomes. Spatial biomes from temperature and humidity, with polar ice caps and a shoreline beach band.
• Foliage, dense grass and water, all biome-aware and data-asset driven.
• Large worlds. Double-precision noise and large-planet clamps.
• Horizon-based chunk culling, so the far side of the planet costs nothing.
• Many planets in one level. A central LOD arbiter (USKPlanetGenLODSubsystem) streams full terrain for the nearest world and draws the rest as low-poly far spheres, so only one chunk pool is ever live.
• Tiered per-chunk resolution (experimental, off by default).

World building tools

• Exclusion volumes. ASKPlanetGenExclusionVolume flattens procedural terrain into a level pad and clears foliage and grass, for hand-authored content such as villages, landing pads, points of interest, dungeon entrances and streamed sub-levels.
• Flat pads on curved worlds. Terrain flattens toward the tangent plane at the volume, so you get a flat pad rather than a spherical cap. The Align To Planet button rotates the volume flat to the surface beneath it.
• Seam-free pads. The same flatten runs in the mesh build, the foliage scatter and the grass scatter, so a pad stays consistent across streamed chunk seams. BlendRadius (default 10000 cm) smooths the edge back to natural terrain; where volumes overlap, the strongest blend wins.
• Actor spawner. USKPlanetGenSpawnerAsset scatters real Actors (ore, plants, wildlife, enemies, loot, points of interest) filtered by biome, slope and normalized height.
• Deterministic spawning. Each surface cell is seeded from its own coordinates, so the same cell always produces the same result and neighbouring chunks agree. Spawning is budgeted per frame, actors beyond SpawnRadius are despawned, and the spawner respects exclusion volumes.
• Both tools are data-asset driven and work on planets and ring worlds.

The ocean

• Depth-tinted water. Turquoise shallows through to deep navy, with shore foam and clear shallows that reveal the seabed.
• No per-frame cost for the tint. Depth is baked into vertex colour when the water builds.
• Sorts correctly from orbit. The water stays opaque Single Layer Water, so it sorts correctly behind volumetric clouds.
• Adaptive tessellation keeps the ocean smooth at any planet size. M_SimplePlanetWater ships as a lightweight flat-colour fallback.
• Ring worlds get the same treatment: depth tint, plus the character wades through shallow ring water and auto-jetpacks over deep water. Ring water tessellation scales with the ring rather than the terrain tile size.

Atmosphere and lighting

• Per-planet atmospheres. Atmosphere data assets (USKPlanetGenAtmosphereAsset) drive Sky Atmosphere and volumetric clouds. The level’s single Sky Atmosphere is driven from whichever planet is currently active, so many worlds share one atmosphere.
• Day/night terminator in shader space, with correct night-side lighting.
• Distant planets get cheap far-halo and cloud shells.
• Ring habitats get their own atmosphere shell layers and cloud decks.
• Clean cloud edges on UE 5.6 and newer via the High Quality Cloud Reconstruction option (on by default).

The starship

• Full 6DOF flight: pitch, yaw, roll, and strafe on all three axes.
• Gravity-aware. The ship reads the gravity at its location and aligns to it, so the same ship flies in atmosphere and in open space. In a level with no planet it falls back to Unreal’s world gravity.
• Engines. Hover engines, main engines and a hyperdrive for crossing distances. Each engine nozzle handles thrust contribution, vectoring, differential response, Niagara flames and audio.
• Landing gear with ground detection, deploy/retract state and a real landing state.
• Walkable interior with a working main door and hatches.
• Passengers can board and ride, not just the pilot.
• Flight HUD that reflects landed, hovering and flying states.
• Works without planets. The ship module has no compile-time dependency on the planet module. It reads gravity through standard engine APIs and binds to a gravity provider by reflection, so it still flies in a project with no planets at all.

Character and gravity

• Radial gravity on planets and centrifugal gravity inside ring habitats.
• Built in. SpaceKit’s gravity is based on GravityCore and ships inside SpaceKit, so you don’t need to buy GravityCore as well.
• Walk anywhere. ASKPlanetGenGravityCharacter walks the full surface of a sphere or the inside of a ring. There is no fake “up”.
• Jetpack with a fast-fly hyperdrive ability (FastFlyTo).
• Prediction-correct movement. USKPlanetGenGravityMovementComponent is built on Unreal’s character movement component with a per-frame gravity direction.
• Custom setups. Gravity source actors and volumes you can place by hand, and USKPlanetGenGravitySubsystem to query the gravity at any location.

Multiplayer

• Gravity, movement and flight state replicate. The gravity movement component works through Unreal’s standard client prediction, and the ship replicates its flight state and fires multicast cues for effects.
• Server-validated boarding. Boarding, leaving and door control route through server RPCs, each validated and executed server-side by ASKStarshipPawn.
• Passengers own their own requests, so a rider does not need to own the ship actor. The rider component is added to the character at runtime, with no changes to your Character or PlayerController classes.
• Dedicated servers. Terrain still generates collision on the server, so server-side movement is authoritative.

Built in C++, driven from Blueprint

• Two runtime modules with full source: SKPlanetGen (planets, ring worlds, gravity, noise, biomes, LOD streaming) and SKStarship (spacecraft, engines, landing gear, boarding). There is no editor module.
• Blueprint and Details panel access to every meaningful parameter: terrain shape, biome thresholds, atmosphere colours, flight tuning, gravity strength.
• Data-driven worlds. Atmosphere, biome foliage, grass, noise and actor-spawner settings are all data assets, so everything that defines how a world looks is data, not code.
• No third-party code. All noise algorithms are original implementations of public-domain mathematics, with no copyleft dependencies.
• Installs alongside PlanetGen and Starship. Modules, reflected types and the content root are namespaced, so SpaceKit installs in the same project as the standalone PlanetGen and Starship plugins without conflicts.

Key classes

Class	What it does	Blueprint API
ASKPlanet	The procedural spherical world. Owns the chunk pool, the noise generator, biome evaluation, foliage and grass scatter, and the water sphere.	SampleHeight, SampleHeightmap, GetPlanetCenter, GetPlanetRadius, GetGravityRadius, GetSeed, RandomizePlanet, ClearPlanet, PreviewPlanet, PreviewSize
ASKPlanetSunSky	An ASKPlanet that also positions and configures the level’s Sky Atmosphere and volumetric clouds for whichever planet is nearest.
ASKRingWorld	A cylindrical habitat on the same pipeline as ASKPlanet, with an outer shell, end walls and translucent shell layers.
ASKPlanetGenGravityCharacter	The player character: walks spheres and rings, jetpacks, and has a fast-fly hyperdrive.	FastFlyTo(TargetLocation, Duration), SetJetpackActive, ToggleJetpack
USKPlanetGenGravityMovementComponent	Character movement with a per-frame gravity direction. Prediction-correct, so it replicates.
USKPlanetGenGravitySubsystem	World subsystem that answers “what is the gravity here?”.	GetCurrentGravity, GetGravityDirectionAtLocation, SetDefaultGravityDirection, SetDefaultGravityStrength, SetZeroGravityOutsideVolumes
USKPlanetGenLODSubsystem	Streams full terrain for the nearest planet and renders every other planet as a low-poly far sphere.	PreviewLOD, ForceLODBoth, ReleaseLODOverride
ASKStarshipPawn	The pilotable spacecraft.	EnterShip, ExitShip, BoardPassenger, UnboardPassenger, SetMainDoorOpen, GetFlightState, IsInAtmosphere, IsInSpace
USKStarshipMovementComponent	6DOF flight. Reads world gravity, aligns the ship to it, and switches between atmospheric and zero-g behaviour.	SetStabilize, ToggleStabilize, SetThrottle, GetThrustState
USKStarshipEngineComponent	An engine nozzle: thrust contribution, vectoring, differential response, Niagara flames and audio.	SetEngineActive, ToggleEngine, SetPower
USKStarshipLandingGearComponent	Landing gear with ground detection and deploy/retract state.	SetDeployed
USKStarshipRiderComponent	Added to a character at runtime when it overlaps a piloted ship. Carries the passenger board, leave and open-door server RPCs (Server_RequestBoard, Server_RequestLeave, Server_RequestOpenDoor).
ASKPlanetGenExclusionVolume	Flattens a region of terrain into a level pad and suppresses foliage and grass. Key properties: bFlattenTerrain, FlattenStrength, BlendRadius, bSuppressFoliage, bSuppressGrass.
USKPlanetGenSpawnerAsset	Scatters real Actors filtered by biome, slope and normalized height. Key properties: ActorClass, Biome, Density, GridSize, SpawnRadius, Min/MaxNormalizedHeight, Min/MaxSlopeDegrees, bAlignToSurface, bRespectExclusionVolumes, bApplyTerrainLoadDelay.
USKPlanetGenAtmosphereAsset, USKPlanetGenBiomeFoliageAsset, USKPlanetGenGrassAsset, USKPlanetGenNoiseGenerator	Data assets for atmosphere, biome-aware foliage, dense grass and noise configuration.

What’s included

• Full C++ source: two runtime modules, SKPlanetGen and SKStarship (26 C++ classes)
• 33 Blueprints, including BP_Starship
• Five playable demo maps: MultiPlanetsMap, PlanetMap_Atmos, RingMap, StarshipDemo and StartMap (a level-select menu)
• Planet content in Content/PlanetGen/: planet materials, sample foliage and grass assets, and characters
• Water materials: depth-aware MI_PlanetWater (spheres) and MI_PlanetWaterRing (rings), and the flat-colour M_SimplePlanetWater
• Ship content in Content/Starship/: ship meshes, materials, FX and HUD
• Epic Games’ standard UE5 Mannequin meshes, animations and rigs under Content/PlanetGen/Characters/Mannequins, redistributed under the Unreal Engine EULA