There will be a world wide hackathon in two weeks time, no better way to get started and get to know some people: https://huggingface.co/LeRobot-worldwide-hackathon

When I started out, it was with microcontrollers, breadboards, sensors, actuators. And even though it was in college, I do wish I had just played around with more high-level stuff first.

Or 'manage your expectations', download ROS and build another mediocre turtle bot powered by some Nvidia Teraflop chip (if they allow you to boot their sdk), and spend a year learning "abstractions" defined by other people for other projects.

Totally free, don't need to buy anything just a computer.

I've been designing electrical hardware for robots for the last 4 years for a big corporation and I can tell you, the fun and money is in the software but having another skill is awesome. Robotics is a place where multiple fields converge and if you find a good team they will help you to grow.

Embedded is the adjacent field after you complete the course. Maybe something like zephyr project.

If you want to get you feet wet with mechanical. Buy a A1 mini and play with onshape (www.onshape.com) to design your first pieces, supports for the motors or the board, try create you own gripper.

As for the electrical engineering, is the one with most pitfalls and the most expensive. A wrong voltage will release the magical smoke and is another 30$ for a board. Tread carefully. Start with the RP2040 or the RP2350, they are cheap and well documented. This skill will evolve hand by hand with the embedded coding. Start small. Learn about H-bridge and brushed motors before doing the jump to the bigboys and FOC control with brushless. Get a cheap soldering iron. If you can, a clone of the JBC C245 tips. Is the most versatile and you can find stuff in alie xpress for 45 or 50$ and would be similar to the tools you will find in the field without breaking the bank.

Search for ROS meetups. I could point you to some depending where in the world you are.

And above all, it will be a long journey. Don't dispear, do at your own time but don't forget the objective.

Noted not just for pedantry but you may get more attention.

This is an example: https://youtu.be/mTpkV7xZln0

- Buy a small robot kit from Amazon or a local reseller. Yahboom make some good robot toy car kits. Hugging Face have the open source SO-ARM101 that plenty of companies manufacture and sell now. Expect to spend about $250 USD including a Jetson Nano for a good kit, up to $1000 USD if you want some more sensors

- If you can’t afford a real robot, play around with simulators like Isaac Sim and Mujoco

- Check out LeRobot, excellent framework for ML robotics from Hugging Face

- Learn the basics of ROS (pubsub), even if you don’t end up using it, a lot of the industry jargon and design patterns come from ROS so it helps to understand it. Think of ROS like Ruby on Rails, it’s a heavyweight batteries-included framework with lots of opinions.

- ROS does have some nice libraries for manipulation (MoveIt) and navigation (Nav2) using more classical (non-ML) methods

- Leverage AI tools such as ChatGPT and Cursor when you get stuck, it’s a lot faster than Googling when you’re just getting started and don’t even know the right term to search for.

- (Shameless plug) Check out two tools I’m working on: mcap.dev for logging and foxglove.dev for visualization

It also depends on what you're trying to learn. Programming? control? electronics? mechanism design? There are many different aspects that require their own expertise. I personally think of a roboticist as someone that can be functional in all the disciplines and bring it all together. Some one that can build a robot from scratch.

This advice is targeted towards someone starting in robotics with an emphasis on building a totally custom robot. You are doing the whole thing from scratch, no kit. (kits are super useful, but I personally like building everything and making hardware that works for me). In my eyes, if you haven't built it in hardware, it probably isn't a robot.

As a research roboticist, my best advice is forget Learning it all up front and just start building. You will probably have strengths and weaknesses, but robotics is a very multi-disciplinary problem and at the start, requires some head banging in what we like to call integration hell. Just Trying to build something does a couple things. It gets you acquainted with the interaction of all aspects (mechanical, electrical, software) of a robot and how they interact. Most importantly it gives you context for sll the things you learn later on. Build something, come across a problem, and google/brute force your way to a solution. You will stumble across context relevant resources and lessons in the moment. Especially at the start, a more "formal" education is too broad and comprehensive for the curious roboticist.

My simple advice is to just come up with something simple and SEND IT!

For mechanical - Onshape for 3D design (free tier) and a bambu A1 mini 3d printer can get you building anything you want for <$400. A couple nights of CAD tutorials will get you started. Hell you can even start with cardboard and hot glue if this is cost/time prohibitive.

For electronics - Browse www.adafruit.com or www.sparkfun.com for sensors and microcontroller boards. They both support QWICC connections which makes getting sensors plugged in and running super easy for a beginner. For computation and control a basic Arduino Uno or one of the adafruit feathers will do just fine. Don't get caught up in the internet debate on what the best microcontroller/single board computer is. The best robot is one that works and it is VERY easy to get in over your head in this realm and fall into the premature optimization track. Better to get something working that under performs than to never build at all.

For software - Most lower level robotics uses c++, which I think scares people. It is mostly because it is one level above hardware. Arduino/common libraries take care of all the hard stuff and you don’t have to worry about large scale things like garbage collection, memory leaks, or efficient code off the bat. The websites above have libraries, examples, and tutorials for every sensor. Even a non programmer type can smush the example code together in a functional way and get something up and running.

As you try to build you will learn and get more complicated. Robotics is so vast and large its best to focus on learning the skill you need at the time. But my main advice is just go build the thing and the learning resources/skills will present themselves when they are needed. Otherwise it is just too much to take a more planned approach.

- Electronics (batteries, resistors, capacitors, etc) - Robotic hardware (motors, sensors, microcontrollers, etc) - Software

The electronics learning is always going to apply to start there if you need to, then depending on your goals the hardware and software will vary.

For simple DIY projects I'd start with getting an Arduino or Arduino compatible board and just play around with building things with sensors, LEDs, motors, etc. You'll find lots of kits and resources online for simple Arduino projects.

More complex projects are probably going to need to be Linux-based (AI, machine vision, etc). In which case you might want to look at building something with a mini PC, Raspberry Pi, NVIDIA Jetson.

These days robotics is super accessible, but can cost a bit depending on what you want to do... That said, most of the time you'll find there are cheap ways to build POCs to validate your ideas first.

How much time do you have? How much do you know about hardware and software? What do you want to do? How much money do you want to invest? What do you want to learn?

The path forward changes entirely depending on the answers to these questions.

https://i.imgur.com/9YIHT9P.jpeg

Modern SBCs are decently powerful and run for long enough off a standard drone LiPo pack that you can fairly easily build yourself a solid little platform to learn and experiment with different controller approaches. Stereo cams, LiDAR modules, etc. are also readily available at a quality level that is decent enough.

You'll quickly realize the amount of work needed to bring any of the more advanced approaches to a productization level, but a "I implemented enough of this to get the principle" mini-Boston-Dynamics is in reach of the hobbyist.

In fact, the programming craft aspect of all of this is relatively simple. Basic implementations are typically not architecturally complex or a lot of sloc. You'll find that it's more about learning some control theory, and it'll also get you into machine learning.

I strongly recommend taking the generalist approach. It makes you a much better engineer in the long run. I had a friend call me up enraged one day. He got woken up at 1am and ordered to drive across the state to get a site back up and running because his hardware was broken and the very expensive software team was sitting around wasting their time. So he got to the site at three or four AM and found that the room full of software engineers, three PhDs among them, didn't understand that BOTH of the battery terminals needed to be connected. Yes, batteries in fact have a positive and a negative. And these people were each getting paid twice as much as him. He left that company and became hardware leadership at a much better company, thank goodness. My point is, super-specializing in the most profitable hyper-niche right off the bat is going to make you a very mediocre robotics engineer who might be successful in the short term, but might find yourself unemployed in a few years when we find a better modality to replace your hyper-niche. Specialists win the sprints, generalists win the marathons.

For starter, I always recommend a RC car with an Arduino (or cheaper equivalents).

Following can be had for less than <$100

- SG90 servo motor - 28BYJ-48 stepper motor - ULN2003 driver board - UNO R3 Controller Board (Elegoo) - RC car chasis/3D printed chasis

Hack around, add sensors, cameras etc. Next would be to build a robotic arm.

Crunch labs: https://www.crunchlabs.com/

As someone in the industry (I literally can call myself a Robot Master having a Masters Degree in Robotics), these simple “kid kits” are phenomenal. When you first start out, the hardest part is knowing the hardware is actually going to do what you tell it to do. Simplifying the mechanical engineering/electrical engineering so you can immediately create real world actions makes a huge difference in giving you motivation to keep going.

Once you have the basics in place and you understand mechanisms, sensors, and some algorithms, you can move on to other parts of robotics.

However, keep in mind robotics is really about system thinking… you have to understand trades between sensing, thinking, and acting. But most importantly you have to remember you are dealing with the real world… you can’t as easily write a unit test and know that a particular actuator will behave exactly the same way every time.

Just a few weeks ago, along with my partner i started this Sunday experiment of building and learning robotics as a software engineer.

We ordered a one hand robotic arm with orin nvidia gpu to start running experiments.

to commit and make it a habit, we also started documenting our learnings and experience.. if this motivates you you can check it out here - https://youtu.be/pAwkl6zd0ws

Edit: you could take a more top down approach and get like an ardupilot, use it in rover mode, and just really learn how to configure and use it to its full potential which is pretty far out there. There’s also a lua scripting capability last time I checked.

For that there are some great points of entry now. Places like pololu robotics, Adafruit, sparkfun, etc. are all as good as ever and are great jumping off points into building and eventually designing hardware.

It may sound silly, but I asked Gemini to recommend a learning plan and it came up with a detailed plan along with time estimates in months. The first step is reading and going through all the exercises in Make Electronics (third edition) which is very hands on.

https://store.steampowered.com/app/573090/Stormworks_Build_a...

The idea of that game is that you build vehicles to do rescues and deal with natural disasters. While there is a career mode where you gain currency that you can spend on parts and fuel, most people who play that game play it in sandbox mode where you essentially design vehicles to do certain things, while also configuring the game to chose missions it generates. For example, you can make it so you only have to deal with land rescue missions or only fight enemy ai.

The building system is VERY in depth. While you don't have to worry about structural strength, you do have to keep things in mind like part placement, CG location, internal volume for buoyancy for ships. Then you get to propulsion, which you have to build out of components - the game has a fairly indepth internal combustion engine simulator where you build custom engines, and have to make sure they are fed with adequate fuel, air, and cooled appropriately. You can do jet engines, you can do nuclear, you can do full electric, and so on.

Then you have to build systems to do missions - for example, to transport a container you have to build a crane to be able to pick it up.

Finally, the game features a microcontroller system which is the bread and butter of doing cool things. There is a bunch of sensors that can read data (GPS, laser distance, pitch, roll, heading, radar, e.t.c), which you can route into a microcontroller, and do math either with logic blocks or Lua code, and thats how you build automation. You will get very familiar with things like PID controller tuning, trigonometry math (for things like distance sensing), state machine coding practices, and other things that are all applicable to the real world.

1. Start by learning a simulation tool, e.g. Mujoco (open source) or Isaac Sim. 2. Learn basics of optimal control and reinforcement learning, reproduce papers/ideas in the simulation. 3. Get your hands dirty on a cheap robot, and try deploy your trained model on it. For mobility and manipulation. Unitree Go1/Go2 for mobility, and robotic arms for manipulation.

Yet, today, people easily build simple robots using a few rc servos and an Arduino. Somehow kinematics is not really essential if you just want to build simple robotic toys. The pedagogy of robotics courses could have been so much better...

The fundamentals of robotics is in the math; think control theory. Don’t over emphasize the surface level like ROS, arduinos, and Lego kits. Those are implementation details

I'm not entirely sure how to make that more 'accessible'. It's like, spend the next 5 years of your life mastering difficult math and electronics so that the sensors can be integrated into feedback that stabilizes a motor system.

I guess you can cheat and use servos for a lot of this (where an EE already solved many feedback loop issues). But if you ever need to build your own sensor+motor solution you'd get stuck if you didn't know the math.

-------

Making simple controls without relying upon feedback sensors is likely the goal, you can do a lot with that. But then do your best to avoid the Masters level demons that plague this problem set.

Maybe learn PID controller theory and if that isn't enough for your problems, give up and try a different design. PID is simple enough that you won't need years of math to learn, but it's very adhoc to configure and not always the best methodology to use.

Better than nothing though.

But no matter what you need an actual physical robot I have never once seen anyone actually transition into robotics without them having made the commitment of spending $100s or $1000s on a capable robot. Very capable robots are in that range at this point.

1.Figure out what you want the robot to do. This is the hardest part, cause it requires constraining your desires considerably

2. Figure out how you want to make it do that. Do you want a deterministic robot? Do you want a robot that uses inference?

3. Then buy the robot that can do the physical action. If your task is to move groceries from your car into the house, you have much different requirements than if its a linear actuator flipping a static switch

4. Choose your robotic actuation path: Dedicated embedded controller (FPGA, PLC), controller coupled with another switch, autopilot etc…

Test, iterate, test….

2) Get an electronics starter kit. (Adafruit or SparkFun are good places to start looking.)

3) Buy/borrow the book "Practical Electronics for Inventors". You don't need to read it cover to cover, but it's very useful. (Realistically, though, an LLM is probably good enough to explain basic concepts and/or help you pick parts these days.)

4) Build a toy robot with parts you printed (or purchased) and parts from the electronics kit.

5) Once you've built the toy robot, make something bigger! (or the existing one better!)

6) Optional: Find someone to buy your toy robot so you can have the funds to design and build your next one.

Robotics is a field filled with layers upon layers of complexity, theory, and real-world problems. Those at the top of the game (think robust dog robots, walking bipedal star wars droids, high-speed and high-torque many-DOF arm platforms) are leveraging learnings and expensive prototypes from decades of work/research to achieve those feats. This is not to be discouraging, but to say - they all started somewhere - you too can start, and maybe you won't build things like that today, but you can get there.

And the cool thing is all that robotics work by experts has made the barrier to entry much lower - today you can choose to apply money to solve problems you don't want to learn and focus on the things you do want to learn, in ways that weren't possible 10 years ago. Need a powerful closed loop motor system? Buy an ODrive or closed-loop stepper platform off the shelf, and focus on how to apply those systems to build something higher level.

But the big difference with learning hardware/robotics compared to software (speaking from experience having watched a lot of really smart people struggle to get robots working when I ran an MIT robotics competition, 6.270, and was a lab assistant for another course, 6.141) is that the real world is unforgiving in a way that software is generally not. So if you come from a software background, you will find that robotics can have so many more setbacks because nothing ever moves/behaves/reacts in a precisely predictable way in physical space. This is why I say just jump in - you'll have fun learning all the ways things go wrong, and they faster you get that learning out of the way, the sooner you can build things that work reliably!

Try things and figure out how and why they don't work, and iterate. But don't set unrealistically high expectations or it will just be frustrating.

The only maths you'll need at the beginning is basic control engineering (PID Loops), forward/inverse kinematics and Extended Kalman Filtering. The only other thing is maybe V=IR, anything else and you're just placating some professor's ego.

https://www.youtube.com/@jamesbruton

The top comment refers to a course around a small mobile robot. Maybe you could go through this, and try to build a bicycle which would balance itself and drive a 100 yards in an empty, safe parking lot. That will certainly involve ME, EE, and CS! Who knows where that might lead?

IF, on the other hand, you want to make 1e6 of these things ("tech giants seems to capture most of the conversation")-- that a completely different story. You're going to need a skilled team, ideally one that has been to a rodeo before. I can't help you there.

But if you're building one, for fun --- Just DO It. Ask friendly robotics club members when you get stuck. IF your problem is particularly and singularly unique, then whatever domain that entails, you will need to master; that's your Secret Sauce.

Ivan Sutherland, who was Thesis Advisor to CMU's first Robotics Institute PhD said something to the effect that after 4 years of a Robotics PhD program, you end up with the ability to solder and attach connectors with a high degree of confidence.

A True Roboticists requires deep knowledge in mathematics, software engineering, mechanical engineering, manufacturing small lots, reliability engineering, materials engineering, data collection & graphical evaluation methodologies..... What one might call a Systems Engineer's handbag. It also helps to be inspired by the wonders of nature that biology affords us.

The details? eh, they change. Whether you used some hot cpu, some hot language, some hot OS --- Marc Raibert's hopping & jumping robots used C and BSD4.3 Unix, with the kernel locks cleaned up (reduced) so a 1 kHz kernel interrupt stream could be supported on a 1 MIPS machine (Vax 780). Timesharing was never stopped, but the kernel did get quite a large percentage of CPU cycles.

I'll repeat: Just do it. Start. Move forward. The project will teach you the questions you must ask.

- https://www.kscale.dev - https://news.ycombinator.com/item?id=44023680

A kernel developer plays with Home Assistant

- Part 1: https://lwn.net/SubscriberLink/1017720/7155ecb9602e9ef2/ - Part 2: https://lwn.net/SubscriberLink/1017945/93d12d28178b372e/ - https://news.ycombinator.com/item?id=44011381

Dutch ingenuity: A brainless soft robot running on air

- https://arstechnica.com/science/2025/05/dutch-scientists-bui... - https://news.ycombinator.com/item?id=43972689

Gemini Robotics

- https://deepmind.google/discover/blog/gemini-robotics-brings... - https://news.ycombinator.com/item?id=43344082

Morphing robot turns challenging terrain to its advantage

- https://actu.epfl.ch/news/morphing-robot-turns-challenging-t... - https://news.ycombinator.com/item?id=43194234

RoboPianist: Dexterous Piano Playing with Deep Reinforcement Learning (2023)

- https://kzakka.com/robopianist/#demo - https://news.ycombinator.com/item?id=43192751

Ask HN: Best way to learn robotics with a 10 year old?

- https://news.ycombinator.com/item?id=41070703

DARPA project reveals one person can control dozens of robots

- https://spectrum.ieee.org/darpa-robot - https://news.ycombinator.com/item?id=43209358

This is obviously naive and computationally wasteful but I really want to see vision first rebuilds of most control and feedback systems.