Simulate · Train · Deploy

Infinite Data Generation
for Robotic AI

We created the world's first game engine purpose-built for robotics.

Lucky Engine spins up virtual worlds where your robot can try, fail and learn a million times then steps into reality already knowing the job. No hardware to break, no lab time to book, no waiting.

MuJoCo physicsC# ScriptingPython SDKgRPC API
WalkerDriver.cs
using Hazel;
public class WalkerDriver : Entity
{
private RobotControllerComponent? m_Rcc;
private RobotController m_Robot;
protected override void OnCreate()
{
m_Rcc = GetComponent<RobotControllerComponent>();
if (m_Rcc is null)
return;
m_Robot = m_Rcc;
m_Robot.SetPolicyActive(PolicyIds.Walker, true);
}
protected override void OnUpdate(float ts)
{
if (m_Rcc is null)
return;
m_Robot.SetFloat(
PolicyIds.Walker, WalkerCommands.SetVx, 0.5f);
m_Robot.SetFloat(
PolicyIds.Walker, WalkerCommands.SetVy, 0.0f);
m_Robot.SetFloat(
PolicyIds.Walker, WalkerCommands.SetYawRate, 0.0f);
}
}
gRPC + Python
agent = rpc.AgentServiceStub(channel)
scene = rpc.SceneServiceStub(channel)
scene.SetSimulationMode(pb.SetSimulationModeRequest(
mode=pb.SIMULATION_MODE_DETERMINISTIC_REALTIME))
schema = agent.GetAgentSchema(pb.GetAgentSchemaRequest()).schema
agent.ResetAgent(pb.ResetAgentRequest())
for _ in range(1000):
# Each Step signals one action and releases exactly one physics tick.
resp = agent.Step(pb.StepRequest(actions=[0.0] * schema.action_size))
observation = resp.observation.observations # repeated float
if resp.terminated or resp.truncated:
agent.ResetAgent(pb.ResetAgentRequest())
agent.ReportProgress(pb.ProgressReport(finished=True))
Works with the robots you already own
Unitree G1Hello Robot Stretch 3FrankaDronesany MuJoCo XML
01 — Lucky Engine

A new game engine built from ground up by the Lucky Robots team

This is not Unity or Unreal, it's a game engine purpose-built for robotics. You can record 10,000hz, and millions of accurate episodes for robotics AI training. A unique engine with accurate time and real-world physics underneath.

marble_run.sim
MuJoCo physicsVulkan render1 armmarble run
train.py
# connect to the running simulation
from luckyrobots import LuckyRobots

lr = LuckyRobots()
lr.connect(robot="unitree_g1", scene="living_room")

for ep in range(1_000_000):
    obs = lr.reset(randomize=True)
    while not obs.done:
        action = policy(obs.camera, obs.joints)
        obs = lr.step(action)        # logs a labeled episode
/01

Physically accurate SIM-TO-REAL

Industry-standard MuJoCo contact, friction and dynamics run underneath — so a grasp learned in simulation holds on the real arm.

/02

Realistic rendering VULKAN

A Vulkan renderer drives camera feeds close to what the real sensors see — the difference between a vision model that works and one that doesn't.

/03

LeRobot 3.0 Data Output DATASETS

Every motion logs camera frames, joint states and sensor streams as labeled episodes — ready for imitation and robot learning. Directly compatible with LeRobot 3.0.

/04

Drive it from Python gRPC SDK

Connect with the Lucky Robots library, script the robot in code, and run thousands of experiments unattended overnight.

/05

Full Game Dev Experience LUCKY EDITOR

Build scenes, place robots and design environments by drag-and-drop and using C#. You can make any environment just like you are making a game, make your robots play basketball if you like.

Run Lucky Engine locallyv2026.1 · free for research & personal useOlder versions

Generate a million episodes. Ship the robot that learned. Train in simulation, deploy in reality.

Any embodiment Coming soon

Fly a drone through the same engine

Aerial robots run on the same MuJoCo physics and Python SDK as the arms and humanoids — autonomous flight, captured as labeled episodes.

live render · autonomous drone in MuJoCo flight
Articulated props Coming soon

Scenes full of objects that open

Fridges, grills and cabinets are rigged to open and close — so a policy can learn to manipulate the room, not just look at it.

articulated · appliances rigged to hinge open
articulated · doors and drawers that actually open
lucky editor · author articulation in the engine
Train at scale

From one blue cup to a million grasps

live render · G1 lifts a cup to inspect
live render · close-up cup-to-hand reach
0%*
less time and budget than training on real hardware
0
labeled episodes your team can train on
0
robots dropped, bricked or broken getting here
02 — LuckyHub

Extending Hugging Face for robotics

Projects, datasets, models and runs together in one workspace. Train in simulation, replay every episode, and roll the best policy straight to production. Your whole team, in sync.

AI creditssim minutestask episodeshobby → enterprise
Coming Soon
01

Host

REPOS

One workspace for robot projects, datasets and models with orgs and teams so the whole crew ships together.

02

Simulate

RUNS

Run simulation tasks in the cloud or on your desktop with Lucky Engine. A full train-and-test loop with no real robot required.

03

Collect & Replay

EPISODES

Every run is captured. Scrub any episode frame by frame and explore it like a dataset, not a log.

04

Generate millions of episodes in the cloud

CREDITS

If you want a billion episodes overnight, you can use Lucky Hub to do it.

05

Scale

BILLING

Start free, grow to enterprise. Only pay for what you run; AI credits, sim minutes and episodes.

hub.luckyrobots.com / acme-robotics / chasing-spheresmain · episode 04217
RECORDING
episode04217
tasklift cup → inspect
frames0
reward+0.62
statussuccess
datasetg1_tidy_v3
03 — Team

The people behind Lucky Robots

A team of engineers and researchers building the simulation layer for the robots about to enter the real world. We're hiring →

DevrimFounder & CEO
YanCofounder / CTO
ArtiaCofounder / COO
HarrisonDirector of Engineering, AI
AnujFounding Research Engineer
NurCoS / Ops
ConstantinDrone Simulation Engineer
LudwigSenior Game Engine Developer
JimSenior Software Engineer
MichaelSenior Software Engineer
JoshuaSenior Software Engineer
EmilySoftware Engineer
OzgurSenior Full-Stack Engineer
BaileySoftware Engineer
EcemOperations
ErenResearch Engineer

Teleop was never going to scale, and Isaac Sim was a pain to set up.

Try Lucky Engine.

Cutting-edge robot AI, autonomous systems, research at scale — Lucky Engine and LuckyHub give you the data and simulation to cross the gap from lab to the real world

We are looking to work with new marquee customers
If you are deploying autonomous AI and need accurate synthetic data, we will build your scene, assign you a forward deployed engineer, and give you a turn-key solution.
Talk to our enterprise team