# JTAGulator finds the debug port you cannot see on a bare board > JTAGulator is an open source hardware tool that helps you locate on-chip debug interfaces on a device from test points, vias, component pads or connectors, built as Parallax Propeller Spin firmware with the protocol work split across separate source files. It suits hardware researchers who have a board and need to find out whether it still has a debug port. **grandideastudio/jtagulator** — JTAGulator: Assisted discovery of on-chip debug interfaces - Repository: https://github.com/grandideastudio/jtagulator - Website: https://jtagulator.com - Stars: 817 · Forks: 115 - Language: Propeller Spin - License: not declared - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/grandideastudio-jtagulator ## The problem is that the port is not documented The README describes JTAGulator as an open source hardware hacking tool that assists in identifying on-chip debug, or OCD, interfaces from test points, vias, component pads, or connectors of an electronic device. That list of starting points is the design idea. When a device arrives without a schematic, or with a schematic that does not show the debug pads, or with the pads present but unlabelled and surrounded by other small components, the usual method of attaching a probe is a guessing game. JTAGulator turns that into a guided search, with the board telling you where the candidates are and the tool telling you which one answers. The scope is deliberately narrow. It is a discovery aid for the debug interface, not a full debugger, and the repository contains no host software to speak of, which tells you where the project's centre of gravity sits. ## The firmware is Parallax Spin, one file per concern The primary language of the repository is Propeller Spin, which is the Parallax Propeller's own language, and the file layout shows how the work is divided. `JTAGulator.spin` is the main program, with `JTAGulatorCon.spin` and `JTAGulatorUtil.spin` holding the console and utility code, and a set of protocol files beside them: `PropJTAG.spin`, `PropSWD.spin` for serial wire debug, `PropSUMP.spin` for the SUMP logic analyzer protocol, `PropOCD.spin` and `PropSerial.spin`. There is also `Basic_I2C_Driver.spin`, `RealRandom.spin` and `PulseWidth.spin` as supporting modules, plus the serial plumbing in `jm_rxserial.spin` and `jm_txserial.spin` and a `sort_dec.spin` helper. The repository also contains a prebuilt `JTAGulator.eeprom` and a `Hardware/` directory with the board files. Keeping each bus in its own file is what makes the firmware approachable, because a reader looking at the JTAG logic does not have to wade through the SWD code to find it. ## Compiling the firmware with OpenSpin The README gives a one line build command for people who already work with the Parallax toolchain. The firmware can be compiled with OpenSpin, and the command is: ```bash openspin -o JTAGulator.eeprom -e -v JTAGulator.spin ``` The output is an EEPROM image, which is what the Propeller bootloader expects, and the verbose flag gives a listing while it builds. The build requires the source files in the directory, since the Propeller compiler resolves the module names at compile time rather than at run time. Note what the official route is, though. The recommended toolchain is the Parallax Propeller Tool version 1.3.2 for Windows, and the README is explicit that alternative development environments are untested and unsupported. The OpenSpin route is offered as a working alternative for people who prefer a command line, and the flags are the same regardless of which one you use to write the code. ## Writing to RAM for a test, or to EEPROM for a real update The two PropLoader commands in the README differ in one flag, and the difference is the one that matters when you are working on hardware. Writing to RAM is for testing: ```bash proploader -p /dev/SERIALPORT -v JTAGulator.eeprom ``` Adding the `-e` flag writes the image to EEPROM instead, which is the persistent update: ```bash proploader -p /dev/SERIALPORT -v -e JTAGulator.eeprom ``` The serial port is given as a device path, on Linux a path under `/dev`, and the verbose flag prints progress. The RAM route is what you want while iterating, since a reset discards it and you cannot brick the board with a bad image, and the EEPROM route is what you use to make the firmware stick. The README also links a video demonstrating the firmware update process, and the official releases are published as tags on the repository, so a user who does not want to compile anything can flash a released image instead. ## A development repository, and a change of maintainer Two practical caveats sit in the README, and both affect how you should treat a checkout. The first is a note that this is a development repository and that interim commits may be unstable, which is a polite way of saying that the default branch is not a release. If you want reproducible behaviour, take a tagged release rather than the tip of master. The second is about who maintains it. The author is Joe Grand of Grand Idea Studio, and the README states that as of July 2025 the project is maintained and supported by EXPLIoT, with a page of their own for the tool. The credit list runs long, with contributions from named individuals including @samyk, @kbembedded, @BenGardiner, @adamgreen, @0ff, @piggybanks and others, which is a good sign for a project of this kind. The documentation lives in the project wiki, and there is a YouTube playlist of videos linked from the README for the parts of the workflow that are easier to watch than to read. ## CC BY-SA for the design, trademarks for the name The licensing has two halves, and the second one is easy to miss. The JTAGulator design is distributed under a Creative Commons Attribution-ShareAlike 4.0 International licence, which means you can share and adapt the work, but you must attribute the original author and distribute any contributions under the same licence. That is a hardware design licence, which is why the attribution requirement matters when you publish a board based on it. Separately, the README states that the JTAGulator name and logo are registered trademarks of Grand Idea Studio and that the marks may not be used on derived works without permission. So the circuits and documentation are open, and the brand is not. No licence identifier is set in the project metadata, so read the LICENSE statement in the README before you put a derived board into production. ## When a dedicated probe is the better answer The honest alternative is a purpose built debug probe, and the choice between them is a question of approach. A probe expects to be pointed at a known header: you have the pinout, you have the connector, and the tool drives the bus. JTAGulator is for the case where you have none of that, and it works from the physical evidence on the board, the small pads and vias that tend to survive on a device whose debug port was meant to be disabled. The two approaches also differ in what you can conclude. A probe that connects tells you the interface is alive and lets you talk to the chip. A discovery tool that finds a candidate point tells you where to look, and the identification step is the beginning of the work rather than the end of it. If you already know the pinout, the extra work in this tool buys you nothing, and if you do not, it is the difference between a weekend and an unsolvable puzzle. ## Conclusion Adopt JTAGulator when you have a device and do not know where its debug interface is, because the whole point of the tool is to work from physical test points, vias, component pads and connectors rather than from a schematic you do not have. Do not adopt it as a general programmer for a chip whose pinout you already know, since a dedicated debug probe does that job with less setup. Verify first that you can build the firmware for your board, because the supported path is the Parallax Propeller Tool on Windows, and that you have the serial port and the `proploader` tool to push the image, since the compiled `JTAGulator.eeprom` in the repository is an artefact of that toolchain rather than a portable binary. ## FAQ ### What does JTAGulator actually do? It assists in identifying on-chip debug interfaces on an electronic device, working from test points, vias, component pads or connectors. The README describes it as an open source hardware hacking tool for that discovery job. ### How do I compile the JTAGulator firmware? With OpenSpin, using `openspin -o JTAGulator.eeprom -e -v JTAGulator.spin`. The README recommends the Parallax Propeller Tool version 1.3.2 for Windows as the supported environment and says alternative environments are untested and unsupported. ### What is the difference between the two proploader commands? Writing to RAM is for testing, with `proploader -p /dev/SERIALPORT -v JTAGulator.eeprom`, and adding the `-e` flag writes the image to EEPROM instead, which is the persistent firmware update. ### Can I use the JTAGulator name and logo on my own board? No. The design is under Creative Commons Attribution-ShareAlike 4.0, so you can adapt and share it with attribution and the same terms, but the JTAGulator name and logo are registered trademarks of Grand Idea Studio and may not be used on derived works without permission. ## Sources - [grandideastudio/jtagulator on GitHub](https://github.com/grandideastudio/jtagulator) - [Issues](https://github.com/grandideastudio/jtagulator/issues) - [Project website](https://jtagulator.com) - [README](https://github.com/grandideastudio/jtagulator/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/grandideastudio-jtagulator