We built the Matrix for robotics

Infinite data for robotics AI

LLMs were built on the internet
Robotics will be built on our infinite worlds

The world is moving to robotics, and every robot has to be trained. Human-generated data can’t carry that. There will never be enough people or enough time to film the amount of data we need.

A warehouse, a new variation every seed.

The answer is a virtual world where robots can learn, fail and try again before they touch the real thing. Lucky Engine is the game engine that builds it, with the tools to create those worlds and physically accurate light and physics to generate the training data.

We built our own engine to do it

Games have been simulating worlds for decades. We’re bringing that expertise to robotics. Lucky Engine grew from Hazel, and engine developers from EA’s Frostbite built it from the ground up for robots.

The editor, with collision shapes showing.

What is Lucky Engine?

Hear from our cofounders

Why don’t we see robots everywhere? In shopping malls, schools, hospitals, or supermarkets? Why are they still mostly confined to labs and carefully controlled demonstrations?

Because we can’t safely train robots in the environments where we actually need them. Imagine training a robot to navigate a crowded supermarket, rescue someone from a burning building, or assist patients in a hospital. You can’t afford thousands of failures when human lives are at stake.

And even if you could safely collect that data, what if you needed a million hours of it by next week? No teleoperation company could possibly deliver that.

Robotics doesn’t just have a data shortage. It has a data collection problem that the physical world cannot solve.

That’s why we built Lucky Engine. We can generate entire worlds and simulate scenarios that would be dangerous or impossible to recreate. A world where robots can practice millions of times before they ever encounter a human.

The reason robots aren’t everywhere isn’t that we don’t know how to build them. It’s that we haven’t been able to train them for the real world. Until now.

Devrim Yasar, Cofounder and CEO, Lucky Robots
Our cofounder and CTO, Yan Chernikov, walks you through why we’re building Lucky Engine.

The investors behind Lucky Robots

A new world for every lesson

Robots learn from variety. The same task in a thousand different rooms teaches more than one room a thousand times.

One image. One prompt. A fully rendered interactive scene

Claude, Codex and other AI assistants can open a project in Lucky Engine, build the scene and check their own work. Everything they build stays editable.

A brick warehouse loft with arched windows, a teal sofa, a red striped rug, globe pendant lights and a mezzanine with hanging plants: the photo given to the agent
Original image

Can you please create the scene in this photograph in the Lucky Engine. Procedurally generate any interactive elements using mujoco physics. Match the lighting and procedurally generate the textures. Add a G1 robot to the scene and have him walk around. When the level is done create a bunch of slow moving camera shots like a real estate advertisement and render them out into a montage. Good luck!

Built from graphs

Agents build with Lucky Procedural, so everything they make can still be reshaped by hand or from code.

Every edit can be undone

Undo an agent’s edit like any other. You stay in charge of the scene.

Create infinite worlds
Create infinite data

All built procedurally, with working hinges, cupboards and doors. Make the fridge taller, the drawer deeper or the whole kitchen new, and record again: a robot learns to use the room as well as see it.

A grill lid on a working hinge.
Fridge doors on real joints.
Drawers on MuJoCo slide joints, path traced.

From one blue cup to a million grasps

Same seed, same world, same data, every time.

Unitree G1, one cup grab per seed.

What’s behind our compiled reality

Lucky Engine spins up virtual worlds where your robot can try, fail and learn a million times, then step into reality already knowing the job.

Physically accurate simulation

Lucky Engine runs on real physics, so robots and the objects around them move, collide and break like they would in the real world. Its cameras and lidar act like the real hardware, so the data a robot trains on looks like what it’ll see on the job.

  • Robots move and collide in MuJoCo, the physics engine robotics researchers already use.
  • Anything built from a graph collides properly, and parts joined by hinges move on their own.
  • Build cables that bend, sag and swing under real physics.
  • Virtual lidar scans the room like real spinning and Livox sensors, with presets for three models.
  • Every surface reflects lidar the way the real material does, from twelve measured presets.
  • Virtual depth cameras see through glass and catch glints on shiny parts, just like real ones.

Photorealistic path‑traced rendering

Lucky Engine lights every scene the way light works in real life, with natural shadows, reflections and glass. Its virtual cameras work like real ones, so robots learn from images that look like the world they’ll work in.

  • Light bounces around the room like it does in real life, with soft shadows, reflections and glass.
  • Path-traced frames clean up as you work, so you see a sharp picture without waiting.
  • Virtual cameras have a real lens, aperture and sensor, and adjust to the light like a real camera.
  • Area lights, glowing materials, and glass that bends and splits light.
  • Record any camera with the path tracer, so training images match what you see.
  • One panel for bloom, upscaling, ambient occlusion and shadows.
  • Built into our own engine, not on Unity or Unreal.

Fewer meshes. More math

Lucky Procedural keeps your scenes light and easy to tweak, so you can create endless episodes to train robots on.

  • Change a number and get a new shape. No remodeling.
  • Surfaces come from parameters too, so they can change from one episode to the next.
  • Turn any simple shape into a graph you can edit, without starting over.
  • Give an agent a photo and it builds that room in the engine, with every object still editable.
  • Lucky Engine runs a local MCP server, so AI assistants like Claude and Codex can open projects, edit scenes and check their work with screenshots.
  • Every variation comes from a seed, so any room can be rebuilt exactly, as often as you need it.
  • Expose any parameter, then override it per instance or change it from C# between episodes.

Deterministic data your robot already reads

Same seed, same world, same data, every time.

  • Datasets come out ready for Hugging Face’s LeRobot tools.
  • Episodes and camera video are saved as standard Parquet files.
  • Choose which joint, sensor and pose values to record in one simple YAML file.
  • Everything runs on one fixed-rate clock, in real time or faster.
  • Time is recorded at a high, fixed rate: up to 10,000 ticks a second.
  • Your Python code and the simulation take turns, one step at a time, so nothing drifts out of sync.
  • Recording stays in step with the simulation, frame for frame.
  • If a run can’t be reproduced bit for bit, its metadata says so.
  • Every tick runs in the same order: sense, decide, step, check, record. No tick is ever dropped.

Works with the robots you already have

Import any MuJoCo model, or start from a Unitree G1 or Go2, Franka Panda, AgileX Piper or Enactic OpenArm. Drive it from Python over gRPC with Gymnasium environments, and record LeRobot 3.0 datasets your training code already reads.

  • A fixed-rate timeline records the whole episode, and flags any run that isn’t bit-reproducible in its metadata.
  • Choose joint, sensor and pose values in YAML, and get typed Parquet columns with GPU-encoded video, depth and lidar.
  • Every tick runs in the same order: sensors read, your policy decides, physics steps, the result is recorded. Drive it from Python in lock-step, and no tick is ever dropped.
  • Aerial robots on the same MuJoCo physics and Python SDK as the arms and humanoids, with autonomous flight captured as labeled episodes.
train.py
# pip install luckyrobotsfrom luckyrobots import Session with Session() as sess:    sess.connect(timeout_s=30.0, robot="unitreego2")    obs = sess.reset()    for _ in range(1000):        actions = policy(obs)          # your model        obs = sess.step(actions=actions)
A Unitree G1 humanoid, head and shoulders, its eyes lighting up orange.

Works with your robots

Import any MuJoCo model, or start from a Unitree G1 or Go2, Franka Panda, AgileX Piper or Enactic OpenArm.

  • Unitree G1

    Humanoid

  • Unitree Go2

    Quadruped

  • ANYmal C

    Quadruped

  • AgileX Piper

    Robot arm

  • Franka Panda

    Robot arm

  • Drone

    Autonomous flight, coming soon

Built by the people who build game engines

Our engineers shipped engine technology on Frostbite at Electronic Arts and created the Hazel engine. We're hiring

  • Devrim YasarCofounder and CEO
  • YanCofounder and CTO
  • ArtiaCofounder and COO
  • NurChief of Staff and Ops
  • CameronDirector of Marketing
  • MichaelSenior Software Engineer
  • JoshSenior Software Engineer
  • JoshuaSenior Software Engineer
  • JimSenior Software Engineer
  • JamesSenior Rendering Engineer
  • VictorSenior Rendering Engineer
  • OzgurSenior Full-Stack Engineer
  • ErenResearch Engineer
  • ConstantinDrone Simulation Engineer
  • BaileySoftware Engineer
  • EmilySoftware Engineer
  • EcemOperations

Advisors: Yanjie Ze, Chris Paxton, Roger Dickey, Neil Nie, Chong Zhang and Alex Sutherland.

Every robot starts here

Build with it

Build a world, bring your robot and record your first episode today. No ROS or hardware needed to start.

v2026.3 for Linux, Windows and macOS. Older versions · Join the Discord

Download Lucky Engine

Deploy at scale

We’ll build your scenes, put a forward-deployed engineer on your team and run the data pipeline with you end to end.

Partner with us