Security researcher pepsipu has published technical details and a working demo of "ns2jb," a software jailbreak that runs custom code on the Nintendo Switch 2. Targeting system software version 23.0.1, it reportedly reaches the privileges of system modules, including the one that handles file operations, without installing a modchip. The researcher also showed a demonstration modifying Mario Kart World. However, the breadth of access gained in the research is a separate matter from the features the released package actually provides. The current public demo only confirms that code can run inside the file system module; it does not amount to a finished modding environment that survives a reboot.
The public demo versus the access gained in the research
While the ns2jb write-up describes arbitrary code execution with system-module privileges, the package pointed to by the public README is a demo that verifies small native functions running inside fs, and it introduces neither custom firmware nor persistence.
fs is the system module that handles access to the console's storage and files. According to pepsipu's technical write-up, ns2jb can run native code, executed directly by the CPU, with the privileges of ordinary system modules and the built-in fs. The researcher explains that this access makes it possible to run homebrew software, analyze and modify games, and back up save data. The write-up also mentions using a mechanism that operates peripherals through memory to investigate the Switch 2 hardware.
By contrast, what the "Switch 2 FS demo" in the distributed README does is run two small native functions inside fs, verify the results, and then restore the original instructions. Separating the research's furthest reach from what this demo offers clarifies where things currently stand.
| Item compared | pepsipu's technical write-up | Distributed README's FS demo |
|---|---|---|
| Privileges for running code | Ordinary system modules and the built-in fs | Verifies execution of small functions inside fs |
| Uses / features shown | Homebrew, game modification, save backup, etc. | Checks function results and restores original instructions |
| Persistence after reboot | Described as tethered | No persistence or custom firmware introduced |
The table compares the researcher's write-up and README as of October 22, 2026, by privileges, features, and persistence. It is not the result of independent testing on real hardware, and the demo's features do not set the upper limit of the research as a whole. Even when a method for gaining broad privileges is published, it does not mean a full set of tools that use those privileges is available.
There are also requirements for the execution environment. The README calls for SmileBASIC 4.4.9 and system version 23.0.1, plus a PC running macOS or Linux with Node.js 22 or later, and the PC and console must be able to communicate on the same network. SmileBASIC's save area needs more than 20 MiB of free space. "Software-only" means no modchip needs to be installed in the console, not that an external PC is unnecessary.
The README also contains a record of a real-hardware test on October 21: on the third attempt, after restarting, verification, restoration, and cleanup went through. The first two attempts stopped at the verification check, and cleanup was performed afterward. A general success rate cannot be calculated from this test record, and judging it as a stable usage environment will require more accumulated reproductions.
The entry point is an older-generation game; the destination is fs
Rather than a new Switch 2 title, pepsipu chose as the entry point SmileBASIC for the original Switch, which runs through backward compatibility. It is software that interprets and runs BASIC programs, and the researcher noted that the 3DS version of SmileBASIC had been a target of vulnerability exploitation in the past.
Initially, Codex targeted the browser's WebKit. However, being able to merely replace an existing JavaScript function with another made it hard to advance to freely calling system services, the researcher said. Protections such as XOM, which restricts reading of executable code; PAC, which prevents pointer forgery; and CFI, which restricts call targets, made it difficult to find and run the necessary instructions.
The researcher therefore chose to examine the code of original Switch games, because the original Switch lacks PAC and game code can be decrypted and analyzed. Instead of breaking all of the Switch 2 browser's protections head-on, the entry point was shifted to older software that is easier to analyze.
In the researcher's account, Codex found a 32-bit integer overflow in SmileBASIC's array handling. When the sum of the position and count of elements to be removed exceeds the representable range, it wraps around to a negative number and passes the range check. As a result, memory that should never have been handled enters the array, allowing reads and writes outside the permitted range.
But there is another step between being able to rewrite memory inside a game and gaining the privileges of a system service. pepsipu chose fs, which handles the file system, and moved on to a buffer overflow in the path normalization process that tidies file paths. By combining a flaw that allows copying content longer than the temporary area prepared with a cache structure Codex found, the researcher says it led to arbitrary memory reads and writes inside fs.
In other words, this route is not completed by a flaw in the old software alone. It is a chain that connects a weakness in an app running through compatibility features to a weakness in fs, which holds different privileges.
After the signature is checked, the loaded content changes
Being able to manipulate fs also reaches the trust relationships involved in loading code. ldr, the system module that loads Switch programs, receives executable files from fs and checks the program's privileges and signature. What pepsipu demonstrated is a method that exploits an inconsistency in this handoff.
Normally, the developer's key, the process's privilege information, the header of the distribution archive, and the executable inside it are tied together by signatures and hashes. If the legitimate privilege information and signature can be verified, only the corresponding program should run. However, whether the contents of the file finally handed over match the hash in the archive was something fs was responsible for guaranteeing.
According to the researcher, after fs provided the legitimate archive's hash and signature to ldr, the file system being read from could be swapped for another one. Because only the body of the executable is replaced while the legitimate privilege information remains, the code that actually runs has different contents even though it passes the signature check.
This differs in nature from mathematically forging a cryptographic signature. A compromised fs was able to break the link between confirming that a signature is valid and the executable content supplied afterward. It can be read as a case showing that, beyond the signature check itself, verified data must be kept in the same state until execution.
The research further says it used the privilege information of ro, the system module with permission to allocate memory for executable code, to rewrite fs's own code. Here too, what was obtained is system-module privilege, not an explanation that the kernel, the core of the OS, was taken over. The researcher also notes that, among the built-in system modules, there is currently no method to compromise anything other than fs.
What Codex handled in the search, and what the human chose
For the research, pepsipu built an environment in which Codex could send control inputs to a real console and receive video. Button inputs are sent over USB through a JetKVM, and the screen is checked via HDMI. To prepare for restarts after crashes, the researcher even set up a Bluetooth-operated mechanism to press the console's power button.
However, the researcher corrects the notion that giving the AI a short instruction led it to complete the jailbreak autonomously. The joking prompt at the start of the blog post was not an actual request, and the goal set for code execution in the user area did not succeed. The jailbreak itself took roughly two weeks of substantial effort, which the researcher distinguishes from the story of having it produce the Mario Kart World modification in a day.
Human judgment also shaped the research path. Across multiple Codex runs, services such as audio and local communication surfaced as candidates, but the researcher chose fs, from which the code of other services can be extracted and fed into analysis. It appears to have been research that combined flaw discovery and implementation by AI, target selection by a human, and trials on real hardware.
pepsipu hopes this arbitrary code execution will advance homebrew development and lead toward custom firmware. The researcher also tested it on the original Switch, but says a distribution package for that is not yet ready. For this to grow into a broadly usable development foundation on the Switch 2, the stages that remain are confirming the demo's reproducibility and building tools that use the access obtained. If those conditions are met, it could become a foothold for developers to investigate the console's functions and build their own software, going beyond a game-modding demonstration.