# OpenCat-Old: the Arduino quadruped platform the current hardware replaced

> Petoi's original OpenCat repository runs Bittle and Nybble on an Arduino Mega with 12 servos and a hobby servo shield. The README's first line tells you to use a different repository instead, which makes this one worth reading as history rather than as a build target.

**PetoiCamp/OpenCat-Old** — A programmable and highly maneuverable robotic cat for STEM education and AI-enhanced services.

- Repository: https://github.com/PetoiCamp/OpenCat-Old
- Website: https://www.petoi.com
- Stars: 1,378 · Forks: 360
- Language: C++
- License: not declared
- Published: 2026-10-07 · Updated: 2026-10-07 · Language: en
- Canonical page: https://hysenlabs.com/projects/petoicamp-opencat-old

## The README tells you not to use this repository

The opening paragraph is unusually direct. It says this repository for Nybble is too redundant with large image files, that it is now obsolete, and that the new OpenCat repository works for both Nybble and Bittle. It then routes the two current hardware lines elsewhere: OpenCatESP32 for Bittle X and Nybble Q, and a shop link for buying a Bittle X.

That framing matters for how you read everything after it. The rest of the README is not describing an active product, it is describing a lineage. The Kickstarter section announces Quaddle, a desk-sized quadruped on four servos rather than the usual eight to twelve, going live on Kickstarter in September 2026. The interesting technical detail there is not the crowdfunding date but the servo count: four servos means each leg has one degree of freedom of drive, so walking requires the legs to be mechanically coupled through the body rather than driven independently. The same section explains that position-feedback servos are what make Puppet Mode possible, since a servo's readable position is what lets a human hand-guide the legs and record a motion without writing code.

Two claims in that section are worth quoting precisely rather than paraphrasing, because the first is a promise and the second is a non-promise. Quaddle source code is not yet public, and the plan is to open source it before delivery. The ESP32-S3 code structure is stated to be closer to OpenCatESP32 than to this repository, which is a fairly direct admission that the code here is the older shape.

## Twelve servos, one Arduino Mega, and a servo shield

The hardware story is the whole architecture. A standard OpenCat build wires a set of hobby servos to an Arduino Mega through a servo shield, which is why the tree is as small as it is: `ModuleTests/`, `Nybble/`, `Resources/`, `SerialMasterPython/`, `TrivialTricks/` and the README. There is no build system, no package manifest, no dependency file and no test runner in that list.

The absence of a simulator directory is the most consequential detail. The README's own framing of the platform as a hands-on physical AI platform names reinforcement learning and sim2real as supported research directions, and a repository containing 20 or more academic papers are said to cite the platform. But sim2real requires a sim, and this tree has no sim. Any paper that used reinforcement learning on this hardware supplied the simulator and the training code separately. That is not a criticism of the hardware, it is a description of what a twelve-servo platform with no physical model of its own forces you to build yourself.

The C++ language tag in the repository metadata agrees with a firmware layout rather than a library. `Nybble/` is the gait code that runs on the board, and the presence of `ModuleTests/` suggests individual behaviours were developed in isolation before being assembled. That is a common and reasonable way to work on an embedded target with no unit test runner, and it is also why the repository has no way to prove a change did not break a gait.

## Puppet Mode is the idea that made the platform usable without code

If you read one mechanism from this repository, read Puppet Mode. The Quaddle section describes it as hand-guiding the legs and recording a motion directly, no code required, and it ties that capability to position-feedback servos being readable rather than only drivable.

That is a genuinely useful engineering trick and it explains a lot about the design. A hobby servo exposes a position register that can be read back, which gives you a crude kinematic observer: if the leg is where the motion expects, the read-back matches. That is not the same as a real state estimate, but it is enough to make a recorded motion into something you can replay on hardware, and replay is what turns a machine into a platform. Without replay, every experiment starts from a standing robot and a hope.

The cost is that the trick depends entirely on servos that report position. A bus servo that accepts commands but does not return its position removes the mechanism entirely, which is a large part of why the current ESP32 hardware exists as a separate effort rather than as an incremental update to this code. Reading this repository with that in mind makes the successor's architecture legible: a microcontroller with real current sensing and an IMU is not gold plating, it is what you need once you stop being able to infer position from the servo bus.

## SerialMasterPython tells you how the robot was actually taught

The directory named `SerialMasterPython/` is a small window into how this platform was used, and it is more revealing than the firmware is. It implies the normal workflow ran from a Python host over serial, which means the board was treated as a peripheral with a command protocol rather than as a self-contained robot.

That workflow is the honest way to teach motion to an embedded quadruped. Writing a gait in C++ on the board means slow iteration: compile, flash, power cycle, watch. Writing it in Python on a laptop means you can parameterise, batch and record. A directory of Python scripts driving the board over serial is evidence that most of the interesting work happened off-board, and that the on-board firmware was a thin execution layer.

`TrivialTricks/` is a title that invites reading as the quick wins a new owner should try first, and `Resources/` is the catch-all for material that does not fit the firmware. Between them they describe a project whose value was never concentrated in a single hard problem. The hard parts were mechanical assembly, servo calibration and getting the timing right, and none of those are visible in a repository.

## What the repository does not tell you

There is no licence file. The repository metadata has a `license` field of null, and the tree listing does not contain a LICENSE entry, which for a repository that people have forked, modified and published papers against is a real gap. The newer OpenCat repository and the ESP32 project are the ones to check for licence terms, and until you have confirmed a licence in writing, treat this code as not licensed for reuse.

There is also no contribution guide, no code of conduct and no issue template mentioned anywhere in the README. The follow-the-project links are all outbound: YouTube, Twitter, Instagram, Facebook, LinkedIn and TikTok, all pointing at the PetoiCamp accounts rather than at a discussion forum in the repository. For a project with this many shipped units, the absence of a local contribution surface is consistent with the README's own statement that the point is mass production and sharing rather than community development of the firmware.

The cumulative numbers deserve one caution. The README reports 30,000 or more robots shipped, 60 or more countries, over one million dollars raised across two prior campaigns, and 20 or more academic papers citing the platform. These are cumulative across all channels and all hardware generations, so they describe the OpenCat programme rather than this repository. Nothing in the tree indicates how many of those units run this code, and the redirection notice at the top is evidence that most of them do not.

## Who this is for, and what to read instead

If your goal is a working quadruped today, this repository is the wrong starting point and the README tells you so within two sentences. PetoiCamp/OpenCat is the one that works for both Bittle and Nybble, and OpenCatEsp32-Quadruped-Robot is described as already powering thousands of Bittle X and Nybble Q units. The current code path is the ESP32 one, and Quaddle is planned to follow it rather than resurrect this Arduino design.

The people who should still read this repository fall into two groups. The first is anyone working on legged locomotion who wants to see a complete gait engine written under the constraint that the only state you can observe is a servo position register, because that constraint forces a particular and increasingly rare style of control code. The second is anyone evaluating physical AI hardware for education, where the 30,000 units and 60 countries figure is evidence that a servo-driven quadruped is manufacturable and repairable at a price point classrooms can absorb.

There is also a search angle worth naming plainly, since the questions people actually ask about this project tend to be about whether an open source robot dog exists at all. The answer is yes, and it is unusually open by the standards of small robotics: the hardware design, the firmware and the Python host tooling are all reachable. The catch in this particular repository is not openness, it is obsolescence, and the fix for that is a different URL rather than a fork.

## Conclusion

OpenCat-Old is a legacy repository and the README says so in its first line, which removes most of the risk of getting this wrong. What remains worth reading is the structure of a quadruped control stack that runs on an Arduino Mega with no motor current sensing, no IMU in the standard build and no kinematics library, and the honest scope statement that this is a system for skilled makers rather than a kit you hand to a twelve-year-old. If you want to build one now, clone PetoiCamp/OpenCat instead, because that repository covers both Bittle and Nybble and the ESP32 variant has taken over as the live code path. If you want to understand how a twelve-servo gait engine is written when the only feedback is a hobby servo position register, read `Nybble/` here and treat everything else as a snapshot.

## FAQ

### Is there an open source robot dog available?

Yes, and this repository is part of one. Petoi's OpenCat programme has shipped over 30,000 quadruped units across more than 60 countries, with the firmware, Python host tooling and hardware design all public. Note that this repository is the superseded Arduino build and the README redirects to PetoiCamp/OpenCat, which covers both Bittle and Nybble.

### Is there an open-source AI robot available?

For legged robotics, the practical answer is a servo-driven quadruped rather than an end-to-end AI stack. OpenCat is a mechanical platform you can apply learning to: the README names reinforcement learning and sim2real as supported research directions and says 20 or more academic papers cite the platform, but the repository ships no simulator, so training code is something you supply.

### Which OpenCat repository should I clone to build a robot today?

Not this one. PetoiCamp/OpenCat is the successor that works for both Bittle and Nybble, and OpenCatEsp32-Quadruped-Robot is the ESP32 path that already powers thousands of Bittle X and Nybble Q units. This repository's own README calls itself obsolete and too redundant with large image files.

## Sources

- [Issues](https://github.com/PetoiCamp/OpenCat-Old/issues)
- [PetoiCamp/OpenCat-Old on GitHub](https://github.com/PetoiCamp/OpenCat-Old)
- [Project website](https://www.petoi.com)
- [README](https://github.com/PetoiCamp/OpenCat-Old/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/petoicamp-opencat-old