# GP2040-CE: RP2040 Gamepad Firmware With a Built-In Web Configurator > GP2040-CE turns a Raspberry Pi Pico or another RP2040 board into a multi-platform arcade stick or gamepad. It is aimed at builders who want to wire their own controller and configure it from a browser instead of a desktop app. **OpenStickCommunity/GP2040-CE** — Multi-Platform Gamepad Firmware for Raspberry Pi Pico and other RP2040 boards - Repository: https://github.com/OpenStickCommunity/GP2040-CE - Website: https://gp2040-ce.info - Stars: 2,543 · Forks: 680 - Language: C++ - License: MIT - Published: 2026-09-28 · Updated: 2026-09-28 · Language: en - Canonical page: https://hysenlabs.com/projects/openstickcommunity-gp2040-ce ## What GP2040-CE Solves for DIY Controller Builders A custom arcade stick normally means choosing a controller board, then accepting whatever firmware the vendor ships. Want a different SOCD rule, a per-button LED colour, or a PS5 mode? You buy a different board. GP2040-CE removes that coupling: it is firmware for the Raspberry Pi Pico and other RP2040-based boards, so the hardware choice and the input behaviour become separate decisions. The README states compatibility with PC, PS3, PS4, PS5, Nintendo Switch, Xbox One, Steam Deck, MiSTer and Android, and lists 14 input modes including X-Input, Nintendo Switch, Playstation 4/5, Xbox One, D-Input and Keyboard. The audience is narrow and specific. This is for people who are already soldering: buttons, a stick, a Pico, and a USB cable. It is not a consumer product, and there is no vendor shipping you a finished unit. The payoff is configurability that normally lives behind proprietary tools. SOCD cleaning has three documented modes (Up Priority, also called Stickless, Neutral, and Second Input Priority). Turbo, reversed input, dual direction via D-pad plus LS/RS, and per-button RGB are all firmware features rather than add-on hardware. If you have built a stick before and wished the board did something it does not do, this is the project's reason to exist. ## How the Firmware Maps Buttons, Modes and Displays The repository layout tells you most of the architecture. There is a src/ tree for firmware, a proto/ directory with compile_proto.cmake, and a www/ directory that holds the web configurator assets. That split matters: the configuration UI is not a separate desktop application, it is served by the device itself. The README calls it a "Built-in, embedded web configuration" and notes "No download required". You plug the controller in, open the configurator, change settings, and the device applies them. Input handling sits on top of TinyUSB, credited in the acknowledgements along with fluffymadness's tinyusb-xinput sample. That is why one firmware image can present itself as several different USB devices: the mode selection changes which descriptors and reports the device speaks. On the output side, the project supports 128x64 monochrome I2C displays (SSD1306, SH1106 and SH1107), a passive buzzer at 3v or 5v, PWM player indicator LEDs in XInput mode only, and multiple LED profiles. Persistent settings need somewhere to live, and the acknowledgements point to Kevin Boone's blog post on using RP2040 flash memory as emulated EEPROM. That is the storage layer behind your saved configuration. Latency is the claim the project leads with. The README reports an average of 0.76 ms in XInput and 0.91 ms for PlayStation 5 at the default 1000 Hz (1 ms) polling rate, measured with WydD's inputlag.science methodology. The published table for v0.7.12 shows XInput at 0.45 ms minimum, 1.28 ms maximum, 0.24 ms standard deviation, and 98.48% on time. Those numbers come from the project's own testing setup, which is documented separately, so treat them as vendor measurements rather than independent ones. ## Installing GP2040-CE and Configuring Your First Stick The README does not walk through installation inline. It links to two pages: Downloads at gp2040-ce.info/downloads and Installation at gp2040-ce.info/installation. That is where the firmware image and the flashing procedure live, and it is the correct starting point because the exact steps depend on which RP2040 board you have. Once the firmware is on the board and the controller is connected over USB, the configuration happens in the browser. The README describes the web configurator as built in and embedded, with no download required, and the project's usage page at gp2040-ce.info/usage covers the settings. A first session typically means picking an input mode, then adjusting SOCD behaviour and any LED or display options you have wired up. For building from source rather than flashing a release, the repository is a CMake project. The top level contains CMakeLists.txt alongside pico_sdk_import.cmake, which is the standard way a Pico SDK project pulls in the SDK, and .gitmodules, which means the SDK and libraries are expected as submodules. ```bash git clone --recursive https://github.com/OpenStickCommunity/GP2040-CE.git cd GP2040-CE ``` The --recursive flag matters here. Because the project uses .gitmodules and pico_sdk_import.cmake, a plain clone leaves the SDK and dependencies missing and the CMake configure step will fail. After cloning, the build is driven through CMake against a configured Pico SDK toolchain, and the output is a UF2 image that goes onto the board the same way a downloaded release does. The README points to gp2040-ce.info/installation for that flashing step rather than repeating it. ## Where GP2040-CE Stops Being the Right Tool The most concrete limitation is wireless. The README lists no wireless input mode anywhere in the feature set, and the input modes enumerated are all USB presentations (X-Input, D-Input, Switch, PS4/5, Xbox One, Keyboard). The related searches include "GP2040-CE wireless", which suggests people look for it, but the documentation given here does not describe it. If your build needs a wireless controller, this firmware is not the answer as documented. Platform support has caveats baked into the feature list. PWM player indicator LED support is marked XInput only, so a build that relies on player LEDs will lose that behaviour the moment you switch to another mode. PS4 and PS5 modes are the slowest in the published latency table (0.90 ms and 0.91 ms average versus 0.72 ms for Switch), and they also carry the widest spread, with a 2.38 ms maximum on PS5 against 1.22 ms on Switch. That is still fast, but it is not uniform across modes, and a build tuned for one console may behave measurably differently on another. There is also a documentation boundary. The README does not document rollback, and it does not list pin assignments; wiring lives on a separate page. Recovering a board that has been flashed with a bad configuration is not described in the README, so a builder should not assume a documented undo path exists. Finally, the project is community-run. The acknowledgements credit FeralAI for the original GP2040 and a long list of individual contributors for specific subsystems, which is a fair picture of how the codebase is maintained. ## GP2040-CE Versus a Commercial Controller Board The obvious alternative is a commercial arcade stick PCB, the category Brook occupies. The difference is not quality, it is where the configuration lives. A commercial board ships as a sealed product with vendor support and a fixed feature set; you install it, wire it, and use it. GP2040-CE is the opposite trade: you supply the board, flash the firmware, and in exchange you get settings the vendor board may not expose, such as three SOCD modes, per-button RGB with multiple profiles, turbo with selectable speed, and a splash screen you upload through the web UI. The second comparison people search for is against an RP2040 board itself, which is a category error worth correcting. The Pico is the hardware; GP2040-CE is what runs on it. The relevant question is which RP2040 board to buy, and the README does not rank them. It says the firmware targets the Raspberry Pi Pico and other RP2040-based boards, and directs wiring questions to gp2040-ce.info/controller-build/wiring. Where the commercial board wins is time. A GP2040-CE build requires soldering, a board choice, a flash, and a browser configuration session before the first match. If you want a working stick this weekend and do not care about SOCD modes or LED profiles, the commercial path is shorter. If you want to change how your stick behaves without buying new hardware, the firmware path is the only one of the two that offers that. ## Licence, Releases and What Upgrades Cost You GP2040-CE is MIT licensed, and the repository carries a LICENSE file at the top level. MIT is permissive: it allows modification and redistribution with the licence text preserved. One thing to check before shipping anything built on it is the bundled third-party code. The acknowledgements credit TinyUSB, OneBitDisplay, BitBang_I2C, an xid_driver library for Original Xbox support, and a licensed Road Rage font. Those components may carry their own terms, and the MIT licence on the project as a whole does not automatically relicense them. That is a question for your own review, not something the README resolves. Release cadence is visible from the tags. v0.7.12 landed on 2025-11-10, v0.7.11 on 2025-04-11, and v0.7.10 on 2024-10-04. That is roughly two releases a year, with the gap between v0.7.10 and v0.7.11 being about six months. The last push to the repository was on 2026-09-28, so work is ongoing between tagged releases. The practical upgrade cost is low: the firmware is a UF2 image, and the README points to gp2040-ce.info/downloads for new versions. The risk is configuration, not flashing. The README does not document a rollback procedure, so a builder who upgrades and finds a changed default should not assume the previous state is recoverable from the documentation alone. ## Conclusion GP2040-CE fits DIY arcade stick and gamepad builders who are comfortable flashing a UF2 and wiring buttons to GPIO, and who want one firmware image covering PC, PS3, PS4, PS5, Nintendo Switch, Xbox One, Steam Deck, MiSTer and Android. It is not the right choice if you need wireless, because the README lists no wireless input mode, or if you want a pre-built board with vendor support, in which case a commercial PCB is the shorter path. Before buying parts, verify that your board is RP2040-based and check the wiring page for your exact layout, because the README itself does not document pin assignments. ## FAQ ### What is GP2040-CE? It is gamepad firmware for the Raspberry Pi Pico and other RP2040-based boards, maintained by the OpenStickCommunity as the community edition of the original GP2040 project. It presents one controller as 14 selectable input modes, including X-Input, D-Input, Nintendo Switch, Playstation 4/5, Xbox One and Keyboard, and it is configured through a built-in web interface rather than a desktop application. ### How do I update the firmware on my GP2040-CE? The README links to gp2040-ce.info/downloads for firmware images and to gp2040-ce.info/installation for the flashing procedure. The exact steps depend on your RP2040 board, which is why the project keeps them on the installation page rather than in the README. ### Is GP2040-CE compatible with PS5? Yes. PS5 is listed among the supported platforms, and Playstation 4/5 is one of the 14 input modes. The project's own v0.7.12 latency table reports PS5 mode at 0.91 ms average at a 1 ms poll rate, which is the slowest of the modes it published. ### Which PS5 mode allows the GP2040-CE to run as an authenticated PS5 compatible arcade stick? The README lists Playstation 4/5 as one of the 14 input modes and reports PS5-mode latency in its results table, and the acknowledgements credit PassingLink for the technical details and code for the PS4 implementation. The README does not name a specific PS5 authentication mode, so check the usage page at gp2040-ce.info/usage before relying on one. ### How do I set up GP2040-CE? Download the firmware from gp2040-ce.info/downloads and follow the flashing steps at gp2040-ce.info/installation for your RP2040 board. Once the controller is connected over USB, the built-in web configurator handles input mode, SOCD behaviour, LED and display settings without any extra software. ### How do I use GP2040-CE on PS5? Select the Playstation 4/5 input mode and connect the controller to the console over USB. The project's v0.7.12 table reports PS5 mode at 0.91 ms average latency at a 1 ms poll rate, and the acknowledgements credit PassingLink for the PS4 implementation details. ## Sources - [License: MIT](https://github.com/OpenStickCommunity/GP2040-CE/blob/main/LICENSE) - [OpenStickCommunity/GP2040-CE on GitHub](https://github.com/OpenStickCommunity/GP2040-CE) - [Project website](https://gp2040-ce.info) - [README](https://github.com/OpenStickCommunity/GP2040-CE/blob/main/README.md) - [Releases](https://github.com/OpenStickCommunity/GP2040-CE/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/openstickcommunity-gp2040-ce