If you’re a millennial kid who grew up loving the first Dhoom movie. You know firsthand how grand the experience was to watch Dhoom 2. The high-tech gadgets, the famous diamond robbery - it was one of the best Bollywood sci-fi tech movies of its time. I was just 10 years old back then.
Fast forward to 2026. Twenty years later, I think it’s finally time to build the car replica, to relive the nostalgia and have some fun.
We’ve all seen the craze around Iron Man suits and the 90s trend of Batmobile builds among young engineers. Movie-inspired projects have become a way to turn childhood inspiration into real-world creations.This is my take on bringing a bit of that movie magic to life.
So, let’s begin. Cue “ta na na na na na na na na”
I’ve been working on this project for a year now. It seemed simple at first, but once you get down to the details, things become far more trickier. This is why plan first, define the scope as early as possible.
In the movie, most of the props are created using a mix of CGI and practical effects, so it’s important to figure out what can be built practically. In the case of the Dhoom 2 car, I found that recreating the car’s design, adding a camera, and implementing the iris-opening mechanism are all doable.
However, there are a few limitations. Features like the arm popping out (even though vacuum robots come with arms now[1]) and the car climbing over the diamond podium aren’t realistically achievable for this build. They’re CG in the movie anyway.
When planning a project like this, you need to decide what you really want from it. Is it mainly about getting the look right, or do you also want real mechanical and electronic functionality? With movie props, appearance alone already takes up most of the effort. Matching what was shown on screen is easily the major challenge. Once that direction is clear, you can optimize the rest of the build around it.
So, with all that in mind, I decided to build following things since they’re enough to film a sequence shown in the movie.
In the movie, the car prop is used in the famous diamond robbery scene where the thief uses an RC car to steal a diamond from the museum. Here’s the link to refresh your memory
The car’s design is surprisingly practical. Apart from the obvious CGI elements, most of its features felt plausible enough to attempt recreating practically.While reading about the VFX work on the movie, I found that Tata Elxsi was responsible for the car’s visual effects[2].
First task is to estimate the dimensions of the car. Its tricky to do that because the perceived dimension will change based on the camera angle and distance.
Luckily, In one of the scene, they show the 35mm film beside the opened car. Since we know tts a 35mm film, we can measure how many pixels are the film and based on that guess the car dims. Its not accurate but enough to give us the ball park. I did this in fusion 360 by importing image as canvas. This can also be done using OpenCV.
The actual dimensions came out to be 147mm×190mm. However, I wanted some buffer space on the print bed so I decided to somewhat scale the model down.
Some of the internal structure shown earlier were’t practical so I omitted them. The body is divided into two parts:
One interesting detail I noticed was the wheel design. In the movie, the wheels appear to be fixed on their spinning axis and don’t move left or right, yet the car still makes sharp turns. There are also ten visible wheels spinning, even though they don’t seem to steer. How they achieved this in the film is still a mystery to me.
To tackle it from the mechanical perspective, I decided to attach motors to two front wheels. By spinning them in opposite directions, the car can turn left or right. The drawback is that the remaining wheels tend to drag slightly during turns.
The wheels themselves are simple pulley designs modelled using an OpenSCAD Python script. I experimented with the parameters until the proportions looked right, then imported the final model into Fusion 360.
The electronics setup is fairly simple. I’m using an ESP32-CAM for the live video feed. It has enough GPIO pins to control the motor driver and can run on a relatively small LiPo battery. Since the build only uses two geared N20 motors, I went with the compact DRV8833 motor driver. I also had to use an extension ribbon cable and an adapter for the camera module.
The motors are 12V N20 geared motors rated at 60 RPM. They’re slow, but they provide enough torque to carry the full weight of the car. The battery is a 7.4V, 600mAh two-cell LiPo, which is the only one that could fit inside the bottom cavity. A step-down (buck) module is required to safely power the ESP32.
High level architecture:
On the ESP32, I’m using the ESP-IDF framework. Separate tasks are created for the UDP/HTTP handling and the camera. The MJPEG stream uses GET requests to send image frames. To read joystick data from the main controller, I use both UDP and HTTP GET requests, depending on the setup.
All in all, I’ve tried to achieve a look similar to what’s shown in the movie.
The book is another important piece of the puzzle. In the movie, the antagonist uses the book as a decoy to wirelessly operate the RC car.
Unlike the car, the book is fairly practical to build. The book contains a joystick and a few additional buttons to control the car. The camera mounted on the car sends a live video feed to the screen embedded inside the book.
I used an online service to 3D print the book because I couldn’t achieve the same color and finish with my printer. The buttons and joystick were printed with and painted as well . I still managed to make a few mistakes. The top cover’s binding isn’t as curved as the bottom half, and in the movie, the bottom section is slightly larger, something I forgot to account for. Still, I think it turned out pretty close.
The high level design of the book’s electronics is shown here:
And the electronics arranged inside the book:
The Milk-V Duo S SBC is the central controller of the system. It handles all the thread logic, reads user input, sends data to the ESP32, and controls the display. The board is powered by a 5000mAh power bank.
The buttons and joystick are connected to a PCF8574A I²C I/O expander instead of directly to the main board, since most of the 3.3V header pins are already used for the SPI interface.
The LCD is connected to the Milk-V Duo S via SPI and uses the ILI9488 driver. It is used to display the live video stream.
A high-level overview of the software architecture is shown below:
The libcurl library fetches the MJPEG stream from the ESP32 using GET requests, parses the buffer, and once a valid frame is found, pushes it onto a queue. From there, the writer thread saves the raw MJPEG data to disk. In parallel, the display thread sends the frames to the screen. This is the car’s pov camera feed.
The GPIO thread reads input data over I²C every 10 ms using the WiringX library. Each button press is registered only once and then locked, while the joystick is continuously polled for new input. The gpio_status_relay_thread then parses these values, builds a GET URL with the parameters, and sends it to the ESP32 to control the car’s movement.
Now, let’s take a closer look at how the buttons work. There are four buttons on the book. As shown in the movie scene, each button performs multiple actions depending on what the car is doing at that moment (more on this later). The exact sequence will be explained in the #robberyscene. However, the mapping is:
Another interesting aspect of this setup is the visual effects. In the movie, the book’s live feed has several VFX layers added on top. I wanted to recreate these as closely as possible.
.dat file containing raw noise frames, played before the live stream startsAll of these effects are composited on top of the frame based on the button states.
Overall, the software ties the book’s controls, visual effects, and car communication into a single system.
For the black strip, I used black plastic tape on the floor. I arranged each piece so the car could show off its turning capability while blending into the strip’s dark color. And for the diamond, I initially forgot about building the podium and the holder. I ordered the diamond from Amazon and later 3D printed a holder for it. It’s not perfect, but it gets the job done.
With the setup finished and the system ready, it’s time to bring the robbery scene to life on camera:
The car is hidden out of sight, with a black strip guiding the path toward the diamond.
The book controller is powered on, and everything is in position to begin the robbery sequence.
* Theif presses the RED button.
- The car rolls out from its hiding place.
- It crosses the exposed white floor.
- Then it stops on the main black strip, facing the correct direction.
* Theif then presses HOME button.
- The book’s display switches to static noise,
just like in the movie when the lens cover retracts.
* Theif then presses RETURN button.
- The live feed from the car’s POV camera appears on the screen.
* Theif uses joytsick to drive the car.
- Keeping it aligned with the black strip, I guide it closer to the diamond.
* What happens next?
- To be continued
For now, this is where the scene ends. I hope to add the iris mechanism and extend it further in the future.
Thank you for reading through this project.