jabara Wiki - User contributions [en]

Design

2026-04-18T19:54:57Z

Mako:

This article is a living document that details the design and development process of [[jabara]].

This article does not intend to be a reference source for Nintendo Switch emulation, nor does it detail the complete operation and function of jabara (the only comprehensive resource on jabara's internals is its [https://git.zelda.sr/jabara/jabara source code]); rather, it is written in the hope that it proves useful as a general outline for the development process of a Switch emulator. As the lack of any other such detailed resources at the time led to the design and development of jabara being difficult and time-consuming, this article was written with the intent of being a helpful starting point for others seeking to develop Switch emulation software.

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions or [[wikipedia:Microsoft_Windows|Windows]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that constitutes a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

== Foundations ==
Implementing TAS functionality in a fork of an existing NX emulator, such as, at the time, suyu<ref group="note">suyu is currently unmaintained and [https://eden-emu.dev Eden] is its most current active fork. However, suyu was current at the time this development decision was made.</ref> or Ryujinx, was considered. However, the complex and outdated buildsystem of yuzu, and, by extension, that of forks such as suyu, made forking suyu unviable, and the use of [https://learn.microsoft.com/en-us/dotnet/csharp/ C#] and [https://dotnet.microsoft.com/en-us/ .NET] by Ryujinx made forking Ryujinx undesirable. To avoid having to work with such codebases, jabara became an entirely separate emulation project.

To best benefit users and developers, jabara was chosen to be a [[wikipedia:Free_and_open-source_software|free and open source]] software project in order to allow free modification and redistribution and encourage community contribution. jabara is licensed under the [https://www.gnu.org/licenses/gpl-3.0.en.html GNU GPLv3] and can be used under the terms of any later version of the GPL. Nintendo has a history of issuing DMCA takedown requests to emulation projects,<ref>https://consumerrights.wiki/w/Nintendo#History_against_console_emulation</ref> especially to public GitHub repositories, so the decision was made to selfhost the relevant Git repositories on an instance of [https://forgejo.org Forgejo]. The public Git forge can be accessed at https://git.zelda.sr.

Due to the high performance required to efficiently emulate NX software and the portability desired of the project, the use of a low-level, [[wikipedia:Compiled_language|compiled programming language]] to develop jabara was imperative. [https://rust-lang.org Rust] was chosen for its efficiency, memory safety, portability, and robust feature set. Following initial branding, a basic Rust crate (package) structure was created and the main project repository was set up on git.zelda.sr at [https://git.zelda.sr/jabara/jabara jabara/jabara].

[[JabaraWiki:About|This wiki]], an instance of [https://www.mediawiki.org MediaWiki], was created during development to organize project design on this article. By release, this wiki will also document emulator features and provide various emulator setup and TASing guides.

== Emulation ==

=== Overview ===
The primary goal of NX emulation is to implement enough of the NX's [[wikipedia:System_on_a_chip|system on a chip]] (SoC), the [[wikipedia:Tegra#Tegra_X1|Tegra X1]], and the NX operating system, Horizon OS ('''HOS'''), to allow [[wikipedia:User_space_and_kernel_space|userland]] NX applications to run.

Two general approaches exist to system emulation: low-level emulation (LLE) and high-level emulation (HLE). In the simplest sense, the emulated ("guest") machine transforms input data into output data. LLE and HLE differ in that LLE emulators emulate the processes by which input data are transformed, while HLE emulators only emulate the visible results (i.e. corresponding output to given input). Many modern emulators are combinations of both LLE and HLE.

All existing NX emulators are at least in part HLE. However, unlike existing NX emulators, which contain aspects of LLE in that they generally attempt to recreate kernel classes and their functionality with relative accuracy, jabara takes an approach much closer to pure HLE, implementing kernel functionality only accurately enough such that its behavior as exposed by the HOS [https://switchbrew.org/wiki/SVC supervisor calls] ('''SVCs''') is accurate to what is expected by their userland callers.<ref group="note">In officially licensed NX applications, the only direct caller of HOS SVCs is the Nintendo SDK (<code>nnsdk</code>).</ref> This approach avoids codebase clutter and allows kernel methods and SVCs to be implemented in an optimally performant matter.

=== CPU ===
The Tegra X1 contains four [[wikipedia:ARM_Cortex-A57|ARM Cortex-A57]] cores used by the NX, as well as four unused [[wikipedia:ARM_Cortex-A53|ARM Cortex-A53]] cores. The Cortex-A57 implements the [[wikipedia:ARM_architecture_family#Armv8-A|Armv8-A]] instruction set architecture (ISA). Only its 64-bit mode ('''AArch64''') is used by HOS, so the target of jabara's CPU emulation is to emulate an AArch64 core. The instruction set used by AArch64 is known as '''A64'''.

Naively, the [[wikipedia:Instruction_cycle|instruction cycle]] may be emulated to interpret A64 code on a per-instruction basis. While providing the most accurate CPU emulation, interpretation does, however, also carry drastic overhead in its slow and repetitive nature. jabara instead emulates A64 using [[wikipedia:Binary_translation#Dynamic_binary_translation|dynamic binary translation]] (DBT), in which [[wikipedia:Basic_block|basic blocks]] of A64 code are collectively translated to the ISA of the emulator ("host") machine, providing performance often better than that of the NX within basic blocks. Existing NX emulators commonly accomplish this using the [https://github.com/lioncash/dynarmic dynarmic] [[wikipedia:Dynamic_recompilation|dynamic recompiler]]. However, due to the difficulty of using [https://isocpp.org C++] libraries in Rust codebases, as well as the aforementioned issues present in the the buildsystem of yuzu that stem partially from that of dynarmic, the [http://github.com/unicorn-engine/unicorn Unicorn] CPU emulator framework, which provides [https://github.com/unicorn-engine/unicorn/tree/master/bindings/rust/unicorn-engine Rust bindings] for its underlying [https://www.c-language.org C] implementation, was chosen for jabara. Unicorn emulates various architectures, including AArch64, using [[wikipedia:Just-in-time_compilation|just-in-time compilation]] (JIT), a DBT technique also used by dynarmic that makes Unicorn a sufficiently performant framework for Tegra X1 emulation. It is based on [https://www.qemu.org QEMU], a widely-used generic machine emulator framework that achieves near-native performance in many scenarios.

AArch64 implements privilege as [https://developer.arm.com/documentation/102412/0103/Privilege-and-Exception-levels/Exception-levels Exception levels] (ELs) numbered <code>EL0</code> through <code>EL3</code>. In this exception model, exceptions may only be raised to an EL identical to that of the caller, and may only be returned from to an EL lower than that of the callee. The NX mostly follows the typical AArch64 EL software model in which userland code runs at <code>EL0</code>, the OS at <code>EL1</code>, the hypervisor at <code>EL2</code>, and the [https://developer.arm.com/documentation/100935/0100/Switching-betwen-the-Normal-and-Secure-worlds- Secure Monitor] at <code>EL3</code>, though the NX lacks a hypervisor, so exceptions raised by <code>EL1</code> are taken directly to <code>EL3</code>. Because jabara emulates HOS itself, its implementation of HOS functionality can be thought of as <code>EL1</code> code—however, as this code is entirely invisible to the guest system, it is not actually running at any EL. Exceptions raised to <code>EL1</code> must hence be handled by jabara, and higher ELs—of which only <code>EL3</code> is used by the NX—can be ignored.

In AArch64, SVCs are implemented as exceptions raised to <code>EL1</code> by the <code>[https://developer.arm.com/documentation/111182/2025-09_ASL1/Base-Instructions/SVC--Supervisor-call-?lang=en SVC]</code> ("supervisor call") A64 instruction. As raising execution to <code>EL1</code> is required for userland (<code>EL0</code>) applications to call kernel (<code>EL1</code>) functionality, SVCs are used for all userland calls to kernel code, and hence must be implemented in jabara in order to run userland NX applications. The Rust bindings for Unicorn expose <code>[https://docs.rs/unicorn-engine/latest/unicorn_engine/struct.Unicorn.html#method.add_intr_hook Unicorn<'a, D>::add_intr_hook]</code>, which hooks guest interrupts and exceptions, passing a <code>u32</code> interrupt code to the hook function. The interrupt codes are defined in <code>[https://git.zelda.sr/jabara/unicorn/src/commit/3811fdcb861dc7686dde0ec0a7624bb92e277647/qemu/target/arm/cpu.h#L32-L52 qemu/target/arm/cpu.h]</code>, with <code>EXCP_SWI</code> ('''s'''oft'''w'''are '''i'''nterrupt) being the code used for guest exceptions. If a caught interrupt is a software interrupt, the details of the exception raised are available via the Exception Syndrome Register for the current Exception level; for <code>SVC</code> exceptions, this is <code>EL1</code>, so the <code>[https://developer.arm.com/documentation/111180/2025-09_ASL1/AArch64-Registers/ESR-EL1--Exception-Syndrome-Register--EL1-?lang=en ESR_EL1]</code> (Exception Syndrome Register (EL1)) register must be read. <code>SVC</code> exceptions can be identified by an <code>[https://developer.arm.com/documentation/111180/2025-09_ASL1/AArch64-Registers/ESR-EL1--Exception-Syndrome-Register--EL1-?lang=en#fieldset_0-31_26 EC]</code> (Exception Class) value of <code>0b010101</code> ("<code>SVC</code> instruction execution in AArch64 state"), located at bits <code>26</code> through <code>31</code>, and an <code>[https://developer.arm.com/documentation/111180/2025-09_ASL1/AArch64-Registers/ESR-EL1--Exception-Syndrome-Register--EL1-?lang=en#fieldset_0-25_25 IL]</code> (Instruction Length) value of <code>0b1</code> ("32-bit instruction trapped"), located at bit <code>25</code>. The immediate argument, <code>[https://developer.arm.com/documentation/111182/2025-09_ASL1/Base-Instructions/SVC--Supervisor-call-?lang=en#imm imm16]</code>, of a caught <code>SVC</code> exception is encoded in the <code>[https://developer.arm.com/documentation/111180/2025-09_ASL1/AArch64-Registers/ESR-EL1--Exception-Syndrome-Register--EL1-?lang=en#fieldset_0-24_0_11 ISS]</code> (Instruction Specific Syndrome) field, located at bits <code>0</code> through <code>15</code>. <code>imm16</code> is then used to uniquely identify the called SVC, allowing the correct SVC implementation in jabara to be called. Exception Syndrome Registers are not exposed by Unicorn's AArch64 API, so Unicorn was forked to [https://git.zelda.sr/jabara/unicorn jabara/unicorn] to add this functionality, exposing an <code>ESR</code> read-only pseudoregister that accesses the Exception Syndrome Register for the current Exception level, always <code>EL1</code> in jabara. This allows SVCs to be implemented per immediate (<code>imm16</code>) in native Rust code, callable by the guest machine with the <code>SVC</code> instruction.

== Notes ==
<references group="note" />

== References ==

Design

2026-04-18T19:46:51Z

Mako:

This article is a living document that details the design and development process of [[jabara]].

This article does not intend to be a reference source for Nintendo Switch emulation, nor does it detail the complete operation and function of jabara (the only comprehensive resource on jabara's internals is its [https://git.zelda.sr/jabara/jabara source code]); rather, it is written in the hope that it proves useful as a general outline for the development process of a Switch emulator. As the lack of any other such detailed resources at the time led to the design and development of jabara being difficult and time-consuming, this article was written with the intent of being a helpful starting point for others seeking to develop Switch emulation software.

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions or [[wikipedia:Microsoft_Windows|Windows]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that constitutes a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

== Foundations ==
Implementing TAS functionality in a fork of an existing NX emulator, such as, at the time, suyu<ref group="note">suyu is currently unmaintained and [https://eden-emu.dev Eden] is its most current active fork. However, suyu was current at the time this development decision was made.</ref> or Ryujinx, was considered. However, the complex and outdated buildsystem of yuzu, and, by extension, that of forks such as suyu, made forking suyu unviable, and the use of [https://learn.microsoft.com/en-us/dotnet/csharp/ C#] and [https://dotnet.microsoft.com/en-us/ .NET] by Ryujinx made forking Ryujinx undesirable. To avoid having to work with such codebases, jabara became an entirely separate emulation project.

To best benefit users and developers, jabara was chosen to be a [[wikipedia:Free_and_open-source_software|free and open source]] software project in order to allow free modification and redistribution and encourage community contribution. jabara is licensed under the [https://www.gnu.org/licenses/gpl-3.0.en.html GNU GPLv3] and can be used under the terms of any later version of the GPL. Nintendo has a history of issuing DMCA takedown requests to emulation projects,<ref>https://consumerrights.wiki/w/Nintendo#History_against_console_emulation</ref> especially to public GitHub repositories, so the decision was made to selfhost the relevant Git repositories on an instance of [https://forgejo.org Forgejo]. The public Git forge can be accessed at https://git.zelda.sr.

Due to the high performance required to efficiently emulate NX software and the portability desired of the project, the use of a low-level, [[wikipedia:Compiled_language|compiled programming language]] to develop jabara was imperative. [https://rust-lang.org Rust] was chosen for its efficiency, memory safety, portability, and robust feature set. Following initial branding, a basic Rust crate (package) structure was created and the main project repository was set up on git.zelda.sr at [https://git.zelda.sr/jabara/jabara jabara/jabara].

[[JabaraWiki:About|This wiki]], an instance of [https://www.mediawiki.org MediaWiki], was created during development to organize project design on this article. By release, this wiki will also document emulator features and provide various emulator setup and TASing guides.

== Emulation ==

=== Overview ===
The primary goal of NX emulation is to implement enough of the NX's [[wikipedia:System_on_a_chip|system on a chip]] (SoC), the [[wikipedia:Tegra#Tegra_X1|Tegra X1]], and the NX operating system, Horizon OS ('''HOS'''), to allow [[wikipedia:User_space_and_kernel_space|userland]] NX applications to run.

Two general approaches exist to system emulation: low-level emulation (LLE) and high-level emulation (HLE). In the simplest sense, the emulated ("guest") machine transforms input data into output data. LLE and HLE differ in that LLE emulators emulate the processes by which input data are transformed, while HLE emulators only emulate the visible results (i.e. corresponding output to given input). Many modern emulators are combinations of both LLE and HLE.

All existing NX emulators are at least in part HLE. However, unlike existing NX emulators, which contain aspects of LLE in that they generally attempt to recreate kernel classes and their functionality with relative accuracy, jabara takes an approach much closer to pure HLE, implementing kernel functionality only accurately enough such that its behavior as exposed by the HOS [https://switchbrew.org/wiki/SVC supervisor calls] ('''SVCs''') is accurate to what is expected by their userland callers.<ref group="note">In officially licensed NX applications, the only direct caller of HOS SVCs is the Nintendo SDK (<code>nnsdk</code>).</ref> This approach avoids codebase clutter and allows kernel methods and SVCs to be implemented in an optimally performant matter.

=== CPU ===
The Tegra X1 contains four [[wikipedia:ARM_Cortex-A57|ARM Cortex-A57]] cores used by the NX, as well as four unused [[wikipedia:ARM_Cortex-A53|ARM Cortex-A53]] cores. The Cortex-A57 implements the [[wikipedia:ARM_architecture_family#Armv8-A|Armv8-A]] instruction set architecture (ISA). Only its 64-bit mode ('''AArch64''') is used by HOS, so the target of jabara's CPU emulation is to emulate an AArch64 core. The instruction set used by AArch64 is known as '''A64'''.

Naively, the [[wikipedia:Instruction_cycle|instruction cycle]] may be emulated to interpret A64 code on a per-instruction basis. While providing the most accurate CPU emulation, interpretation does, however, also carry drastic overhead in its slow and repetitive nature. jabara instead emulates A64 using [[wikipedia:Binary_translation#Dynamic_binary_translation|dynamic binary translation]] (DBT), in which [[wikipedia:Basic_block|basic blocks]] of A64 code are collectively translated to the ISA of the emulator ("host") machine, providing performance often better than that of the NX within basic blocks. Existing NX emulators commonly accomplish this using the [https://github.com/lioncash/dynarmic dynarmic] [[wikipedia:Dynamic_recompilation|dynamic recompiler]]. However, due to the difficulty of using [https://isocpp.org C++] libraries in Rust codebases, as well as the aforementioned issues present in the the buildsystem of yuzu that stem partially from that of dynarmic, the [http://github.com/unicorn-engine/unicorn Unicorn] CPU emulator framework, which provides [https://github.com/unicorn-engine/unicorn/tree/master/bindings/rust/unicorn-engine Rust bindings] for its underlying [https://www.c-language.org C] implementation, was chosen for jabara. Unicorn emulates various architectures, including AArch64, using [[wikipedia:Just-in-time_compilation|just-in-time compilation]] (JIT), a DBT technique also used by dynarmic that makes Unicorn a sufficiently performant framework for Tegra X1 emulation. It is based on [https://www.qemu.org QEMU], a widely-used generic machine emulator ramework that achieves near-native performance in many scenarios.

AArch64 implements privilege as [https://developer.arm.com/documentation/102412/0103/Privilege-and-Exception-levels/Exception-levels Exception levels] (ELs) numbered <code>EL0</code> through <code>EL3</code>. In this exception model, exceptions may only be raised to an EL identical to that of the caller, and may only be returned from to an EL lower than that of the callee. The NX mostly follows the typical AArch64 EL software model in which userland code runs at <code>EL0</code>, the OS at <code>EL1</code>, the hypervisor at <code>EL2</code>, and the [https://developer.arm.com/documentation/100935/0100/Switching-betwen-the-Normal-and-Secure-worlds- Secure Monitor] at <code>EL3</code>, though the NX lacks a hypervisor, so exceptions raised by <code>EL1</code> are taken directly to <code>EL3</code>. Because jabara emulates HOS itself, its implementation of HOS functionality can be thought of as <code>EL1</code> code—however, as this code is entirely invisible to the guest system, it is not actually running at any EL. Exceptions raised to <code>EL1</code> must hence be handled by jabara, and higher ELs—of which only <code>EL3</code> is used by the NX—can be ignored.

In AArch64, SVCs are implemented as exceptions raised to <code>EL1</code> by the <code>[https://developer.arm.com/documentation/111182/2025-09_ASL1/Base-Instructions/SVC--Supervisor-call-?lang=en SVC]</code> ("supervisor call") A64 instruction. As raising execution to <code>EL1</code> is required for userland (<code>EL0</code>) applications to call kernel (<code>EL1</code>) functionality, SVCs are used for all userland calls to kernel code, and hence must be implemented in jabara in order to run userland NX applications. The Rust bindings for Unicorn expose <code>[https://docs.rs/unicorn-engine/latest/unicorn_engine/struct.Unicorn.html#method.add_intr_hook Unicorn<'a, D>::add_intr_hook]</code>, which hooks guest interrupts and exceptions, passing a <code>u32</code> interrupt code to the hook function. The interrupt codes are defined in <code>[https://git.zelda.sr/jabara/unicorn/src/commit/3811fdcb861dc7686dde0ec0a7624bb92e277647/qemu/target/arm/cpu.h#L32-L52 qemu/target/arm/cpu.h]</code>, with <code>EXCP_SWI</code> ('''s'''oft'''w'''are '''i'''nterrupt) being the code used for guest exceptions. If a caught interrupt is a software interrupt, the details of the exception raised are available via the Exception Syndrome Register for the current Exception level; for <code>SVC</code> exceptions, this is <code>EL1</code>, so the <code>[https://developer.arm.com/documentation/111180/2025-09_ASL1/AArch64-Registers/ESR-EL1--Exception-Syndrome-Register--EL1-?lang=en ESR_EL1]</code> (Exception Syndrome Register (EL1)) register must be read. <code>SVC</code> exceptions can be identified by an <code>[https://developer.arm.com/documentation/111180/2025-09_ASL1/AArch64-Registers/ESR-EL1--Exception-Syndrome-Register--EL1-?lang=en#fieldset_0-31_26 EC]</code> (Exception Class) value of <code>0b010101</code> ("<code>SVC</code> instruction execution in AArch64 state"), located at bits <code>26</code> through <code>31</code>, and an <code>[https://developer.arm.com/documentation/111180/2025-09_ASL1/AArch64-Registers/ESR-EL1--Exception-Syndrome-Register--EL1-?lang=en#fieldset_0-25_25 IL]</code> (Instruction Length) value of <code>0b1</code> ("32-bit instruction trapped"), located at bit <code>25</code>. The immediate argument, <code>[https://developer.arm.com/documentation/111182/2025-09_ASL1/Base-Instructions/SVC--Supervisor-call-?lang=en#imm imm16]</code>, of a caught <code>SVC</code> exception is encoded in the <code>[https://developer.arm.com/documentation/111180/2025-09_ASL1/AArch64-Registers/ESR-EL1--Exception-Syndrome-Register--EL1-?lang=en#fieldset_0-24_0_11 ISS]</code> (Instruction Specific Syndrome) field, located at bits <code>0</code> through <code>15</code>. <code>imm16</code> is then used to uniquely identify the called SVC, allowing the correct SVC implementation in jabara to be called. Exception Syndrome Registers are not exposed by Unicorn's AArch64 API, so Unicorn was forked to [https://git.zelda.sr/jabara/unicorn jabara/unicorn] to add this functionality, exposing an <code>ESR</code> read-only pseudoregister that accesses the Exception Syndrome Register for the current Exception level, always <code>EL1</code> in jabara. This allows SVCs to be implemented per immediate (<code>imm16</code>) in native Rust code, callable by the guest machine with the <code>SVC</code> instruction.

== Notes ==
<references group="note" />

== References ==

Design

2026-04-12T06:03:30Z

Mako:

Design

2026-04-10T09:25:49Z

Mako:

Design

2026-04-10T09:24:20Z

Mako:

Design

2026-04-10T09:23:01Z

Mako:

Design

2026-04-10T08:39:14Z

Mako:

Design

2026-04-10T08:37:15Z

Mako:

Design

2026-04-10T08:35:47Z

Mako:

Design

2026-04-10T07:14:01Z

Mako:

Design

2026-04-10T06:56:02Z

Mako:

Design

2026-04-10T06:55:21Z

Mako:

Contribution guidelines

2026-04-03T01:54:04Z

Mako:

This page contains guidelines for contributing code to [[jabara]].

== Source access ==
jabara is developed on a dedicated [https://forgejo.org Forgejo] instance hosted at [https://git.zelda.sr git.zelda.sr]. The primary repository is located under the [https://git.zelda.sr/jabara jabara] organization at [https://git.zelda.sr/jabara/jabara jabara/jabara].

== Submitting changes ==
Contributions to jabara should be made as pull requests to the repository. (Guidelines TBD)

== Git guidelines ==
Git commit messages should follow the [https://www.conventionalcommits.org/en/v1.0.0/ Conventional Commits] conventions. Here are a few well-formed examples:

* <code>chore: flatten imports and re-export `Cpu`</code>
* <code>fix(docs): use `align` instead of `style`</code>

After the first release, changelogs will be kept as described by [https://keepachangelog.com/en/1.1.0/ Keep a Changelog] in the file `CHANGELOG.md`.

== Code guidelines ==

All comments should make use of [[wikipedia:Markdown|Markdown]] formatting where applicable.

If referencing external sources for <code>jabara_core</code> implementation details (e.g. [https://switchbrew.org/wiki/Main_Page SwitchBrew], source code of emulators such as [https://git.greemdev.net/projects/Ryubing Ryujinx] or [https://git.eden-emu.dev/eden-emu/eden Eden]), include a comment linking to the source referenced.

Check for [https://doc.rust-lang.org/stable/clippy/index.html Clippy] lints by running <code>cargo clippy</code> and apply suggested changes, if any. If there is good reason not to apply a suggestion, add an <code>#[allow(clippy::some_lint)]</code> attribute to the smallest possible region (e.g. the function containing the offending code), along with a comment explaining your decision.

Ensure that all code has been formatted with [https://rust-lang.github.io/rustfmt/ Rustfmt] before committing. This can be done by configuring your editor to autoformat on save or by running <code>cargo fmt</code>.

You can disallow local commits with clippy lints or formatting issues by creating a pre-commit hook. Create an executable file at <code>.git/hooks/pre-commit</code> with the following content:
<pre>#!/bin/sh

cargo clippy -- -Dwarnings
cargo fmt --check
</pre>

== Documentation guideines ==
Lint all Markdown documentation with <code>[https://github.com/davidanson/markdownlint markdownlint]</code> before committing.

Contribution guidelines

2026-04-03T01:49:16Z

Mako:

This page contains guidelines for contributing code to [[jabara]].

== Source access ==
jabara is developed on a dedicated [https://forgejo.org Forgejo] instance hosted at [https://git.zelda.sr git.zelda.sr]. The primary repository is located under the [https://git.zelda.sr/jabara jabara] organization at [https://git.zelda.sr/jabara/jabara jabara/jabara].

== Submitting changes ==
Contributions to jabara should be made as pull requests to the repository. (Guidelines TBD)

== Git guidelines ==
Git commit messages should follow the [https://www.conventionalcommits.org/en/v1.0.0/ Conventional Commits] conventions. Here are a few well-formed examples:

* <code>chore: flatten imports and re-export `Cpu`</code>
* <code>fix(docs): use `align` instead of `style`</code>

After the first release, changelogs will be kept as described by [https://keepachangelog.com/en/1.1.0/ Keep a Changelog] in the file `CHANGELOG.md`.

== Code guidelines ==

Check for [https://doc.rust-lang.org/stable/clippy/index.html Clippy] lints by running <code>cargo clippy</code> and apply suggested changes, if any. If there is good reason not to apply a suggestion, add an <code>#[allow(clippy::some_lint)]</code> attribute to the smallest possible region (e.g. the function containing the offending code), along with a comment explaining your decision.

Ensure that all code has been formatted with [https://rust-lang.github.io/rustfmt/ Rustfmt] before committing. This can be done by configuring your editor to autoformat on save or by running <code>cargo fmt</code>.

You can disallow local commits with clippy lints or formatting issues by creating a pre-commit hook. Create an executable file at <code>.git/hooks/pre-commit</code> with the following content:
<pre>#!/bin/sh

cargo clippy -- -Dwarnings
cargo fmt --check
</pre>

== Documentation guideines ==
Lint all Markdown documentation with <code>[https://github.com/davidanson/markdownlint markdownlint]</code> before committing.

Contribution guidelines

2026-04-03T01:41:49Z

Mako:

This page contains guidelines for contributing code to [[jabara]].

== Source access ==
jabara is developed on a dedicated [https://forgejo.org Forgejo] instance hosted at [https://git.zelda.sr git.zelda.sr]. The primary repository is located under the [https://git.zelda.sr/jabara jabara] organization at [https://git.zelda.sr/jabara/jabara jabara/jabara].

== Submitting changes ==
Contributions to jabara should be made as pull requests to the repository. (Guidelines TBD)

== Git guidelines ==
Git commit messages should follow the [https://www.conventionalcommits.org/en/v1.0.0/ Conventional Commits] conventions. Here are a few well-formed examples:

* <code>chore: flatten imports and re-export `Cpu`</code>
* <code>fix(docs): use `align` instead of `style`</code>

After the first release, changelogs will be kept as described by [https://keepachangelog.com/en/1.1.0/ Keep a Changelog].

== Code guidelines ==

Check for [https://doc.rust-lang.org/stable/clippy/index.html Clippy] lints by running <code>cargo clippy</code> and apply suggested changes, if any. If there is good reason not to apply a suggestion, add an <code>#[allow(clippy::some_lint)]</code> attribute to the smallest possible region (e.g. the function containing the offending code), along with a comment explaining your decision.

Ensure that all code has been formatted with [https://rust-lang.github.io/rustfmt/ Rustfmt] before committing. This can be done by configuring your editor to autoformat on save or by running <code>cargo fmt</code>.

You can disallow local commits with clippy lints or formatting issues by creating a pre-commit hook. Create an executable file at <code>.git/hooks/pre-commit</code> with the following content:
<pre>#!/bin/sh

cargo clippy -- -Dwarnings
cargo fmt --check
</pre>

Design

2026-04-01T17:59:27Z

Mako:

This article is a living document that details the design and development process of [[jabara]].

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions or [[wikipedia:Microsoft_Windows|Windows]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that constitutes a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

== Foundations ==
Implementing TAS functionality in a fork of an existing NX emulator, such as, at the time, suyu or Ryujinx, was considered. However, the complex and outdated buildsystem of yuzu, and, by extension, that of forks such as suyu, made forking suyu unviable, and the use of C# and .NET by Ryujinx made forking Ryujinx undesirable. To avoid having to work with such codebases, jabara became an entirely separate emulation project.

To best benefit users and developers, jabara was chosen to be a [[wikipedia:Free_and_open-source_software|free and open source]] software project in order to allow free modification and redistribution and encourage community contribution. jabara is licensed under the [https://www.gnu.org/licenses/gpl-3.0.en.html GNU GPLv3] and can be used under the terms of any later version of the GPL. Nintendo has a history of issuing DMCA takedown requests to emulation projects,<ref>https://consumerrights.wiki/w/Nintendo#History_against_console_emulation</ref> especially to public GitHub repositories, so the decision was made to selfhost the relevant Git repositories on an instance of [https://forgejo.org Forgejo]. The public Git forge can be accessed at https://git.zelda.sr.

Due to the high performance required to efficiently emulate NX software and the portability desired of the project, the use of a low-level, [[wikipedia:Compiled_language|compiled programming language]] to develop jabara was imperative. [https://rust-lang.org Rust] was chosen for its efficiency, memory safety, portability, and robust feature set. Following initial branding, a basic Rust crate (package) structure was created and the main project repository was set up on git.zelda.sr at [https://git.zelda.sr/jabara/jabara jabara/jabara].

[[JabaraWiki:About|This wiki]], an instance of [https://www.mediawiki.org MediaWiki], was created during development to organize project design on this article. By release, this wiki will also document emulator features and provide various emulator setup and TASing guides.

== References ==

Design

2026-03-27T07:25:10Z

Mako:

Design

2026-03-27T04:09:46Z

Mako:

This article is a living document that details the design and development process of [[jabara]].

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions or [[wikipedia:Microsoft_Windows|Windows]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that constitutes a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

== Foundations ==
To best benefit users and developers, jabara was chosen to be a [[wikipedia:Free_and_open-source_software|free and open source]] software project in order to allow free modification and redistribution and encourage community contribution. jabara is licensed under the [https://www.gnu.org/licenses/gpl-3.0.en.html GNU GPLv3] and can be used under the terms of any later version of the GPL. Nintendo has a history of issuing DMCA takedown requests to emulation projects,<ref>https://consumerrights.wiki/w/Nintendo#History_against_console_emulation</ref> especially to public GitHub repositories, so the decision was made to selfhost the relevant Git repositories on an instance of [https://forgejo.org Forgejo]. The public Git forge can be accessed at https://git.zelda.sr.

Due to the high performance required to efficiently emulate NX software and the portability desired of the project, the use of a low-level, [[wikipedia:Compiled_language|compiled programming language]] to develop jabara was imperative. [https://rust-lang.org Rust] was chosen for its efficiency, memory safety, portability, and robust feature set. Following initial branding, a basic Rust crate (package) structure was created and the main project repository was set up on git.zelda.sr at [https://git.zelda.sr/jabara/jabara jabara/jabara].

[[JabaraWiki:About|This wiki]], an instance of [https://www.mediawiki.org MediaWiki], was created during development to organize project design on this article. By release, this wiki will also document emulator features and provide various emulator setup and TASing guides.

Design

2026-03-27T03:44:05Z

Mako:

This article is a living document that details the design and development process of [[jabara]].

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions or [[wikipedia:Microsoft_Windows|Windows]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that constitutes a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

== Setup ==
To best benefit users and developers, jabara was chosen to be a [[wikipedia:Free_and_open-source_software|free and open source]] software project in order to allow free modification and redistribution and encourage community contribution. jabara is licensed under the [https://www.gnu.org/licenses/gpl-3.0.en.html GNU GPLv3] and can be used under the terms of any later version of the GPL. Nintendo has a history of issuing DMCA takedown requests to emulation projects,<ref>https://consumerrights.wiki/w/Nintendo#History_against_console_emulation</ref> especially to public GitHub repositories, so the decision was made to selfhost the relevant Git repositories on an instance of [https://forgejo.org Forgejo]. The public Git forge can be accessed at https://git.zelda.sr.

Due to the high performance required to efficiently emulate NX software and the portability desired of the project, the use of a low-level, [[wikipedia:Compiled_language|compiled programming language]] to develop jabara was imperative. [https://rust-lang.org Rust] was chosen for its efficiency, memory safety, portability, and robust feature set. Following initial branding, a basic Rust crate (package) structure was created and the main project repository was set up on git.zelda.sr at [https://git.zelda.sr/jabara/jabara jabara/jabara].

[[JabaraWiki:About|This wiki]], an instance of [https://www.mediawiki.org MediaWiki], was created during development to organize project design on this article. By release, this wiki will also document emulator features and provide various emulator setup and TASing guides.

JabaraWiki:General disclaimer

2026-03-25T18:04:46Z

Mako:

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned [[wikipedia:Nintendo_Switch|Nintendo Switch]] ('''NX''') software.

JabaraWiki:General disclaimer

2026-03-25T18:04:10Z

Mako: Created page with "jabara is not a cheating tool and is not intended to give unfair advantages to real-time attack ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software."

JabaraWiki:About

2026-03-25T18:03:09Z

Mako: Created page with "The '''jabara Wiki''' is a wiki providing documentation on the features and design of jabara, a Nintendo Switch emulator."

The '''jabara Wiki''' is a wiki providing documentation on the features and design of [[jabara]], a [[wikipedia:Nintendo_Switch|Nintendo Switch]] emulator.

Design

2026-03-25T07:53:44Z

Mako:

This page is a living document that details the design and development process of [[jabara]].

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions or [[wikipedia:Microsoft_Windows|Windows]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that constitutes a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

Contribution guidelines

2026-03-25T07:47:41Z

Mako:

Design

2026-03-25T06:04:40Z

Mako:

This page is a living document that details the design and development process of [[jabara]].

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions or [[wikipedia:Microsoft_Windows|Windows]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that uniquely identifies a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

Design

2026-03-25T06:00:25Z

Mako:

This page is a living document that details the design and development process of [[jabara]].

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions, [[wikipedia:Microsoft_Windows|Windows]], or [[wikipedia:MacOS|macOS]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that uniquely identifies a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

Design

2026-03-25T05:59:02Z

Mako: Created page with "This page is a living document that details the design and development process of jabara. == Purpose == jabara is a Nintendo Switch (codename '''NX''') emulator designed to provide robust tool-assisted speedrun and superplay (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that i..."

This page is a living document that details the design and development process of [[jabara]].

== Purpose ==
jabara is a [[wikipedia:Nintendo_Switch|Nintendo Switch]] (codename '''NX''') emulator designed to provide robust [[wikipedia:Tool-assisted_speedrun|tool-assisted speedrun and superplay]] (generally, '''TAS''') functionality for Switch games. Its use case differs from existing NX emulators (e.g. [https://eden-emu.dev Eden], [https://ryujinx.app Ryujinx]) in that it is designed primarily for TAS creation and playback with optimized real-time gameplay as a secondary target.

jabara is not a cheating tool and is not intended to give unfair advantages to [[wikipedia:Speedrunning#Real-time_attack|real-time attack]] ('''RTA''') speedrunners. jabara is not a tool for piracy or copyright violation and may only be used with legally extracted ('''"dumped"''') copies of owned NX software.

== Scope ==
jabara cannot be used to emulate the [[wikipedia:Nintendo_Switch_2|Nintendo Switch 2]].

jabara can be used on [[wikipedia:X86-64|x86-64]] and [[wikipedia:AArch64|AArch64]] machines running any modern version of most [[wikipedia:Linux|Linux]] distributions, [[wikipedia:Microsoft_Windows|Windows]], and [[wikipedia:MacOS|macOS]]. Support for mobile devices is not planned.

jabara aims to provide a wide variety of tools for creating and replaying TASes. Among others, tools offered for TAS developers ('''TASers''') include frame advance, [[wikipedia:Saved_game#Save_states|savestates]], input manipulation, memory viewing, system state and [[wikipedia:Random_number_generation|random number generation]] ('''RNG''') manipulation, and [[wikipedia:Debugger|debugging]]. All information that uniquely identifies a particular TAS may be recorded to a movie file that can be used to deterministically replay the TAS on any instance of jabara, assuming all necessary game data are present and unchanged.

Support for physical input devices such as controllers or keyboards is an eventual goal to make jabara viable for real-time gameplay.

Jabara

2026-03-24T17:59:57Z

Mako:

{{DISPLAYTITLE:jabara}}
'''jabara''' is a work-in-progress [[wikipedia:Free_and_open-source_software|free and open source]] emulator of the [[wikipedia:Nintendo_Switch|Nintendo Switch]], written in [[wikipedia:Rust_(programming_language)|Rust]].

Jabara

2026-03-24T17:45:12Z

Mako:

{{DISPLAYTITLE:jabara}}
'''jabara''' is a work-in-progress [[wikipedia:Free_and_open-source_software|free and open source]] emulator for the [[wikipedia:Nintendo_Switch|Nintendo Switch]], written in [[wikipedia:Rust_(programming_language)|Rust]].

User:Mako

2026-03-24T17:43:18Z

Mako:

<nowiki>:</nowiki>3

User:Mako

2026-03-24T17:43:03Z

Mako: Created page with ":3"

Jabara

2026-03-24T17:42:06Z

Mako:

{{DISPLAYTITLE:jabara}}

'''jabara''' is a work-in-progress [[wikipedia:Free_and_open-source_software|free and open source]] emulator for the [[wikipedia:Nintendo_Switch|Nintendo Switch]], written in [[wikipedia:Rust_(programming_language)|Rust]].

Jabara

2026-03-24T17:39:53Z

Mako: Created page with "'''jabara''' is a work-in-progress free and open source emulator for the Nintendo Switch, written in Rust."

'''jabara''' is a work-in-progress [[wikipedia:Free_and_open-source_software|free and open source]] emulator for the [[wikipedia:Nintendo_Switch|Nintendo Switch]], written in [[wikipedia:Rust_(programming_language)|Rust]].