Retro Replay Retro Gaming History, Reviews & Emulation
NINTENDO SNES/SFC EMULATOR CORE
bsnes-jg
bsnes-jg is the libretro (RetroArch) port of the bsnes cycle-accurate Super Nintendo / Super Famicom emulator. It is distributed as a libretro core (for RetroArch and other libretro frontends) and can also be built from the libretro/bsnes-jg source repository.
WHY IT MATTERS
Why use bsnes-jg?
Focused on cycle-accurate SNES emulation and compatibility with libretro frontends. As a libretro core it integrates with RetroArch features (shader chains, input remapping, save states and frontend-managed core options) while providing bsnes accuracy and gamedatabase-driven device detection.
BEST FOR
Best use case
Use bsnes-jg when you want a libretro-integrated, high-accuracy SNES core in RetroArch (or another libretro frontend). It is appropriate for preservation-minded play, accurate timing-sensitive tests, and running games that rely on precise SNES hardware behavior.
The people behind bsnes-jg
History & relationship to bsnes/higan
bsnes began as a cycle-accurate Super Nintendo emulator and later influenced the higan project. bsnes-jg is the libretro-targeted port/packaging of that emulator code maintained in the libretro organization (source and docs are available in the libretro/bsnes-jg repository and the Libretro documentation). Over time the libretro ecosystem has hosted multiple SNES cores (snes9x variants, bsnes-derived cores, bsnes-hd variants); bsnes-jg represents the libretro core intended to expose bsnes accuracy to libretro frontends. Details, changelogs and the core listing are available from the libretro project pages and the bsnes project documentation.
What bsnes-jg supports
- Super Nintendo / Super Famicom (SNES/SFC)
- Standard SNES controllers; game-specific devices determined via game database (as implemented by the core)
- Libretro features: save states, input mapping, shaders, core options (via frontend)
- Platforms supported via RetroArch: Windows, Linux, macOS, Android, and other systems that run RetroArch (platforms depend on available core builds)
Download and availability
OFFICIAL DOWNLOADS
Get bsnes-jg
Official distribution path: obtain the bsnes-jg core through a libretro frontend (RetroArch) using the frontend’s Core/Content updater, or download/build from the libretro/bsnes-jg source repository. The Libretro documentation lists bsnes-jg on the core list and provides a core guide page; the canonical source tree and releases are on the libretro Git hosting and GitHub mirror.
Get bsnes-jg ↗DOCUMENTATION
Official documentation
Read the official configuration, compatibility, and troubleshooting material before changing advanced options.
Read official documentation ↗bsnes-jg setup guide
Setup note: Two practical ways to get and run bsnes-jg: (A) use RetroArch’s online core downloader (recommended for most users); (B) build the core from source if you need a custom build or platform not provided by official builds. The steps below cover both approaches and provide key configuration notes specific to SNES accuracy and common pitfalls.
- A — Install RetroArch and get the core via the Core Updater: 1) Install the latest RetroArch build for your platform from the RetroArch project (not included here). 2) Launch RetroArch, open Online Updater (or Core Updater) and refresh core info. 3) Find and download the core named bsnes-jg (listed as Nintendo – SNES/SFC (bsnes-jg) in the libretro core list). 4) Load content (a legal SNES ROM file you provide) from RetroArch’s Load Content menu, then select bsnes-jg as the core if it does not auto-select. 5) Use RetroArch's Core Options to tune the core behavior; for accuracy-focused play leave defaults unless you need a specific workaround documented by the core’s README. Note: RetroArch's updater and available cores depend on your RetroArch version and platform; if bsnes-jg does not appear, update core info files in RetroArch or consider method B.
- B — Build bsnes-jg from source: 1) Get the source: clone the libretro/bsnes-jg repository (the libretro GitLab/GitHub mirrors contain the tree). 2) Inspect the repository README and Makefile to understand required build dependencies (common dependencies include a C++ compiler, libsamplerate if enabled, and libretro build toolchain details). 3) Follow the repository build instructions: typical steps are to set platform target in the Makefile or use the recommended build script, then run make to produce the libretro core binary (a .so, .dll or .dylib depending on platform). 4) Place the produced core file into RetroArch’s cores directory or your frontend’s expected core location. 5) Start RetroArch and load content with the freshly built core. If you need cross-compilation for consoles or restricted platforms, consult the libretro build documentation and the repository’s platform notes.
- Core configuration and practical notes: – Game files (ROMs): bsnes-jg reads SNES ROM images you must provide. The core may use a game database to detect peripherals; keep any core-provided databases up to date when present. – No BIOS/firmware files are required for standard SNES games. – Save handling: rely on the frontend’s save mechanisms (SRAM, save states). Ensure RetroArch is configured to write save files to a writable directory. – Performance: cycle-accurate cores can be CPU intensive on low-end hardware. If you need better performance on limited hardware, consider a less-accurate SNES core (e.g., snes9x variants) instead of bsnes-jg. – Shaders and post-processing: use RetroArch shader presets to apply image filters; these are frontend features, not part of the core itself. – HD patches and forks: there are bsnes-hd and other forks that add widescreen/HD features; those are separate projects and may not be available as the bsnes-jg libretro core.
- Troubleshooting tips: – Core not listed in RetroArch core downloader: update core info files (Online Updater → Update Core Info Files). – Crashes or audio issues: update RetroArch and the core; check the repository’s issue tracker for known bugs and platform-specific fixes. – Controller mapping: use RetroArch Input Remapping; some games require specific device detection (the core’s game database controls that behavior). – If you need features present in standalone bsnes (GUI-specific features), verify whether the libretro core exposes equivalent options or use the standalone bsnes application instead.
- Building for uncommon platforms: If your platform does not have official core builds, build from source as above and follow libretro’s cross-compilation guidance. For embedded or console ports follow the libretro documentation and the repository platform notes; these builds often require platform SDKs and signing tools not supplied by the core repository.
- Verifying authenticity and updates: Prefer the libretro organization repository and the official Libretro documentation for authoritative information and changelogs. Keep RetroArch and core info files up to date to receive newer core builds via the frontend’s updater.
Software reminder: This core does not include commercial games, BIOS, firmware or copyrighted ROMs. Provide your own game files legally. Follow your local laws for ROM ownership and use.
Sources and further reading
Detailed guides and tutorials
Explore step-by-step guides for bsnes-jg as they are published.
Use bsnes-jg on Android
An Android ARM64 Libretro build exists for bsnes-jg. Run the core through RetroArch for Android; the standalone desktop download and Android core may have different menus and features.
Emulates: SNES.
Verified Android core build ↗ · Browse all Android emulators →