105 Robotics Projects or 2-3yrs Dagestan

Hold up

This was made for my own reference but you definitely gotta check it out!!

Dude what’s your goal (?)

I once met a young 20yo computer science student who excitedly tells me she’s gonna take 6 months off uni to try building a product.

And she asks me “what are your plans for the near future” and I just tell her:

I intend to have 4PB of storage, a lot of books in my study room, some land and a nice garden, spend my time building my own software and hardware far from people, use starlink, study the things I’m interested in and write on the internet if it’s still around and basically only come out to travel and meet people every couple of months.

And basically, I am permanently RETIRING from This soulless World.

Hence the answer to this question.

Also, I was born a tinkerer, so I’ve been doing this even before I was a teen.

And also GOD CHOSE ME.

Bro! how did you even get this list

Yh about that, I just browsed every famous company that deals with robots. Boston Dynamics, Tesla, Figure AI etc.

I am aware most of these companies dont actually build nothing, they just come out on social platforms and be like “We are announcing an announcement about announcing another announcement” and they never actually announce a product lol.

But I had no choice.

Behavior and control flow

1. Behavior tree design. Implement a behavior tree library in C++ that sequences pick, place and recover actions for a simulated arm.
2. Finite state machine for robot modes. Code an FSM that switches between idle, navigate, grasp and fault states with transition guards.
3. Real-time motor command interface. Write a C++ loop that sends velocity commands to simulated actuators at a fixed 1 kHz rate.
4. Hardware-in-the-loop test harness. Build a Python script that injects sensor noise and verifies controller response under simulated faults.
5. Behavior recovery from faults. Add recovery branches to a behavior tree that re-grasp after a slip.
6. Directed acyclic graph for skill execution. Implement a DAG scheduler that runs parallel perception and motion nodes.

Perception

7. Perception pipeline for object detection. Train a lightweight detector and run it on live camera frames to output bounding boxes.
8. Stereo vision depth estimation. Implement a basic stereo matching algorithm and generate depth maps from image pairs.
9. Calibration routine for cameras. Write a tool that estimates camera extrinsics from a checkerboard sequence.
10. Visual odometry pipeline. Code a basic feature-based visual odometry that tracks camera motion.
11. SLAM for indoor mapping. Integrate a lightweight SLAM that builds an occupancy grid from lidar scans.
12. CUDA accelerated perception. Write a CUDA kernel for point cloud downsampling and measure speedup.
13. NITROS style type adaptation. Convert a ROS 2 image message into a GPU buffer with zero-copy transfer.
14. Synthetic data for pose estimation. Generate rendered images of objects with ground-truth 6D poses.
15. Tactile sensor simulation. Model simple contact pressure maps on a gripper surface.
16. Force torque sensing simulation. Model and filter simulated force torque signals at the wrist.

Estimation and planning

17. State estimation with multiple sensors. Fuse simulated IMU and wheel odometry using an extended Kalman filter.
18. Multi-modal sensor fusion. Combine vision, force and proprioception into a single state estimate.
19. Navigation stack basics. Create a simple A-star planner that outputs paths around static obstacles in a grid.
20. Grasp pose generation. Compute candidate grasp poses from a point cloud of a simple object.
21. Grasp quality metrics. Compute force-closure and Ferrari-Canny metrics for candidate grasps.
22. Task planning with a PDDL-like language. Write a planner that sequences high-level actions for a multi-step warehouse task.
23. Motion planning with cuMotion style batching. Implement a batch trajectory optimizer that returns the lowest-cost path.
24. Collision checking in planning. Add continuous collision detection to a motion planner for a multi-link arm.
25. Singularity avoidance in planning. Add a cost that penalizes proximity to kinematic singularities.
26. Null-space optimization. Use redundant degrees of freedom to maximize manipulability while tracking a pose.
27. Benchmark suite for motion planners. Measure planning time and success rate across a set of scenes.
28. Long-horizon planning with memory. Maintain a short-term memory of observed objects and plan over it.

Control

29. Whole-body control interface. Write a quadratic program that tracks end-effector pose while respecting joint limits.
30. Impedance control implementation. Simulate compliant interaction of an arm with a virtual surface.
31. Model predictive control for manipulation. Implement a short-horizon MPC that tracks a Cartesian trajectory.
32. Quadratic programming for torque control. Solve a QP that realizes desired end-effector forces.
33. Inverse dynamics feed-forward. Compute and apply inverse dynamics torques to improve tracking.
34. Online adaptation of controllers. Implement a simple adaptive gain scheduler based on tracking error.
35. Parameter sweeping for controllers. Automate grid search over PID gains and select the best set.
36. System identification of robot dynamics. Estimate inertial parameters from recorded motion data.
37. In-hand manipulation primitives. Implement regrasping sequences using tactile or force feedback.
38. Multi-robot coordination protocol. Implement a simple consensus algorithm so two robots avoid collisions.

Simulation

39. Isaac Sim scene setup. Build a warehouse environment and spawn a mobile manipulator.
40. Isaac Lab training loop. Train a simple RL policy inside Isaac Lab and export the checkpoint.
41. URDF and MJCF model conversion. Write a converter that turns a URDF description into a MuJoCo model.
42. Soft contact modeling. Implement a compliant contact model and compare bounce behavior.
43. Constraint-based solvers. Code a projected Gauss-Seidel solver for contact and joint constraints.
44. Differentiable contact dynamics. Expose contact forces through automatic differentiation for policy gradients.
45. GPU batch simulation of policies. Run thousands of parallel rollouts of a policy on GPU.
46. Deterministic simulation seeds. Ensure identical simulation outcomes given the same random seed.
47. Spatial algebra library usage. Implement rigid-body dynamics using spatial vectors.
48. Energy monitoring of simulated robots. Track kinetic and potential energy to detect unstable controllers.

Learning

49. Teleoperation data collection pipeline. Log joint angles and camera frames during keyboard or joystick teleop sessions.
50. Imitation learning dataset curation. Filter and label teleop trajectories, then train a basic behavioral cloning policy.
51. Visuomotor policy training. Train a small convolutional policy that maps images to joint velocities in simulation.
52. Reinforcement learning for locomotion. Train a PPO agent for a simple biped standing and walking task in MuJoCo.
53. Domain randomization schedule. Vary friction, mass and lighting during training and measure robustness.
54. Human demonstration retargeting. Map human joint trajectories to a robot kinematic chain.
55. VR teleoperation bridge. Stream VR controller poses to a robot and command its end-effector.
56. Dataset versioning for robot learning. Store trajectories with metadata and support reproducible loading.
57. Experiment tracking for policies. Log hyperparameters, rewards and videos from training runs.
58. Active learning for data collection. Select the most uncertain states for additional teleop demonstrations.
59. Transfer learning across robot morphologies. Adapt a policy trained on one arm to a slightly different kinematic chain.
60. Foundation model fine-tuning for robotics. Fine-tune a small vision-language model on robot instruction data.
61. Tool-use agent for robot tasks. Build an LLM agent that calls robot skill APIs to complete a multi-step goal.
62. Edge deployment of neural policies. Quantize a policy and run inference under a real-time deadline.

Safety and reliability

63. Safe policy wrappers. Implement monitoring that aborts a learned policy when torque limits are approached.
64. Safety monitor for autonomy. Write a watchdog that freezes motion when localization uncertainty exceeds a threshold.
65. Graceful degradation strategies. Reduce control frequency or disable non-critical skills under overload.
66. Robustness testing under sensor dropout. Randomly drop camera frames or force readings and measure recovery.
67. Failure mode analysis scripts. Automatically classify common failure modes from logged trajectories.
68. Automated regression tests for behaviors. Script a suite that runs a behavior tree on randomized scenes and reports success rate.
69. End-to-end skill evaluation protocol. Define success criteria and automatically score multi-step tasks.
70. A/B testing framework for policies. Deploy two policy variants and compare metrics on the same tasks.
71. Human feedback collection interface. Build a simple UI for operators to rate trajectory quality.

Systems and real time

72. Low-latency message passing. Measure and optimize end-to-end latency of a custom UDP-based robot command channel.
73. Real-time Linux tuning. Configure a system for low-latency scheduling and measure jitter under load.
74. Multi-threaded control architecture. Separate sensing, planning and actuation into threads with lock-free queues.
75. Soft real-time priority assignment. Give control threads higher priority than logging threads.
76. Latency compensation techniques. Predict and compensate for communication delay in teleoperation.
77. Wireless link quality monitoring. Track packet loss and jitter and adapt control rates accordingly.
78. Performance profiling of robot stacks. Instrument a full stack and identify the top latency contributors.
79. Resource usage monitoring. Track CPU, memory and GPU utilization of robot processes in real time.
80. CAN bus interface simulation. Emulate CAN messages for joint commands and parse responses in C++.
81. EtherCAT master basics. Implement a minimal cyclic exchange that updates simulated drive status.
82. Cross-compilation for embedded targets. Build robot software for an ARM platform and validate under emulation.

Software infrastructure

83. ROS 2 node for skill API. Expose a robot skill as a ROS 2 action server that clients can call.
84. Dynamic skill discovery. Build a service registry that lists available robot skills at runtime.
85. Plugin architecture for skills. Load new robot skills dynamically at runtime from shared libraries.
86. Distributed system for robot services. Design microservices that exchange robot state over a message bus.
87. Containerized robot software. Package a ROS 2 stack in Docker and run it with hardware simulation.
88. Fleet orchestration basics. Write a central coordinator that assigns simple tasks to multiple simulated robots.
89. Fleet health dashboard backend. Aggregate status from multiple robots and expose query endpoints.
90. Diagnostic logging framework. Create structured logs that capture controller state, sensor health and timing metrics.
91. Binary logging format for high-rate data. Design a compact log format for joint and sensor streams.
92. Replay and scrubbing tools. Build a player that steps through recorded logs frame by frame.
93. Message schema evolution. Design versioned message formats that remain compatible across releases.
94. Configuration management for robots. Store and apply per-robot calibration and tuning parameters.
95. OTA update mechanism for robots. Design a safe staged software update that can roll back on failure.
96. Continuous integration for robot code. Set up a pipeline that builds, runs unit tests and simulation smoke tests.
97. Unit tests for numerical robotics kernels. Write tests that verify Jacobian accuracy to machine precision.
98. Integration tests with simulated hardware. Run a full skill end-to-end against a physics simulator.
99. Code generation for kinematics. Generate optimized C++ from a kinematic description language.
100. Automated documentation of APIs. Generate skill API docs from annotated code.

Bringing the knowledge together

The individual projects are practice. These are the systems.

1. Mobile manipulator stack. A complete simulated mobile manipulator that uses a behavior tree to navigate, grasp and place objects, running perception, state estimation, motion planning and a learned visuomotor fallback policy inside one ROS 2 and physics simulation environment.
2. Teleop to imitation pipeline. Record human demonstrations over a low-latency interface, train a visuomotor policy with domain randomization, deploy it under a safety monitor, and evaluate success across randomized scenes with automated logging and regression tests.
3. Multi-robot fleet coordinator. Assign tasks via a DAG planner, exchange state over a custom low-latency channel, monitor health diagnostics, and recover from individual robot faults while each robot runs its own real-time control and perception nodes.
4. Simulation to deployment loop. Train an RL locomotion or manipulation policy in a high-throughput GPU batch simulator, transfer it to a real-time C++ controller with inverse dynamics feed-forward, and validate it under hardware-in-the-loop conditions with calibration and profiling tools.
5. Humanoid-style skill system. Combine whole-body control, task planning, foundation-model guidance, safety monitors, CUDA-accelerated perception and a plugin-based skill library, then run long-horizon multi-step tasks with continuous logging, evaluation and OTA-style update support.

Are you thinking what I am thinking ?

The pattern is obvious once written down. Everything below the learning layer is literally systems engineering (I think): timing, message passing, logging, tests.

End of entry.