Bloodborne on PC Is Real: Native Recompilation Port Delivers 140+ FPS, 4K, and FSR 4 on Linux and Steam Deck

For more than a decade, the single most coveted holy grail in PC gaming has been Bloodborne on PC. Ever since FromSoftware and Hidetaka Miyazaki unleashed their Gothic masterpiece upon the PlayStation 4 in March 2015, millions of players have pleaded with Sony Interactive Entertainment for a native Windows port, a 60 FPS patch, or a 4K remaster. While Dark Souls received remasters and Demon’s Souls was completely rebuilt for the PlayStation 5, the Hunt has remained trapped in amber on 2013 hardware—forever locked at 1080p, capped at 30 frames per second, and plagued by notorious frame-pacing stutter.

Today, that decade-long drought has shattered in the most extraordinary way imaginable.

Enter bbport, a monumental open-source project by independent developer deadinside28. Bypassing the conventional roadblocks of slow console emulation, bbport runs the original PlayStation 4 retail executable of Bloodborne (CUSA03173, version 1.09) natively on x86-64 Linux PCs and the Steam Deck. Powered by a custom multi-threaded Vulkan graphics pipeline, unlocked simulation delta times, and ground-up motion vector reconstruction driving AMD FSR 4, the port achieves mind-boggling performance figures: over 140–150 FPS at 1440p and a blistering 90 FPS at native 4K.

The Recompilation Revolution: Game Preservation Hits Escape Velocity

To understand why bbport is such a historic technological milestone, you have to look at the seismic shift taking place across the video game preservation and reverse-engineering ecosystem over the last two years.

For decades, playing console games on personal computers required traditional emulation: software that painstakingly virtualizes a console’s CPU, memory controllers, audio processors, and custom graphics chips in software. Emulation is vital, but it demands immense computational overhead. Even today, running complex PlayStation 3 or Xbox 360 titles requires high-end multi-threaded desktop processors just to interpret foreign CPU architectures like PowerPC or the Cell Broadband Engine.

Recently, however, the retro and modern gaming scenes have undergone a full-blown renaissance through static recompilation and native source reimplementations:

• Nintendo 64: The Super Mario 64 and Zelda: Ocarina of Time (Ship of Harkinian) PC ports proved that compiling original game logic natively unlocked widescreen, ray tracing, high-refresh-rate gameplay, and extensive modding.
• Automated Static Binary Recompilers: Projects like Mr-Wiseguy’s N64 Recomp and PS1 Recomp proved that raw console binaries could be translated directly into clean C code offline, running seamlessly on modern systems with zero emulation penalty.
• PlayStation 2: The OpenGOAL project reverse-engineered Naughty Dog’s custom GOAL language to bring Jak and Daxter natively to PC.
• PlayStation 3: The ongoing effort to rewrite LittleBigPlanet in Rust bypasses Cell SPE bottlenecks entirely.

Now, this revolution has reached the eighth console generation. Because the PlayStation 4 was built around an x86-64 AMD Jaguar CPU rather than a proprietary RISC or Cell architecture, its game binaries are already compiled in the same instruction set that powers modern AMD and Intel desktop processors. Developer deadinside28 realized that if you strip away the heavy operating system baggage, Bloodborne does not need to be emulated at all—it can run as a native PC application.

Under the Hood: How bbport Runs Bloodborne Natively

Make no mistake: bbport is not a general emulator. It is a hyper-specialized native runtime built specifically for a single piece of software: Bloodborne v1.09.

While the brilliant team behind shadPS4 has done heroic work creating a general-purpose PlayStation 4 emulator, a general emulator must implement broad, high-level abstractions for hundreds of disparate Orbis OS system calls, background daemons, and variable game engines. bbport takes a radically different, razor-sharp approach:

1. A Bespoke 5,000-Line C Micro-Runtime

Instead of simulating the entire FreeBSD-derived Orbis operating system, bbport replaces the PS4's system libraries (such as libc and libSceFios2) with a lightweight, native C runtime spanning just ~5,000 lines of code (src/runtime_*.c). This minimal shim implements only the exact interfaces that Bloodborne actually touches:

• Memory & Thread Management: Maps game code straight into virtual memory with native POSIX threading and synchronization primitives.
• Filesystem I/O: Intercepts FromSoftware's archive calls, mounting the game's dvdroot_ps4/ assets directly from your local NVMe drive.
• Audio Processing: Direct decoding of Sony's proprietary ATRAC9 audio streams via an integrated LibAtrac9 pipeline.
• Input & Saves: Comprehensive controller handling via SDL3, with native support for DualShock 4 and DualSense touchpads, alongside robust local file save data serialization.

2. Multithreaded GPU Decoding Breaks the Draw-Call Bottleneck

In traditional PS4 emulation tests, Bloodborne frequently choked on single-threaded command processing. In early builds of shadPS4, a single CPU thread had to decode the PS4 GPU command stream, translate states, and issue draw calls to Vulkan. In complex Yharnam scenes packed with geometry, this single-threaded bottleneck capped frame rates to roughly 26 FPS regardless of how powerful your graphics card was.

bbport rewrites this entirely with a two-stage multi-threaded GPU pipeline:

• Stage 1 (Decoding Thread): Consumes and unpacks the raw PS4 command stream asynchronously.
• Stage 2 (Recording Thread): Binds pipelines, handles state memoization, and records Vulkan draw commands in parallel.
• Helper Worker Threads: Dedicated background threads handle asynchronous buffer streaming and texture memory copies.

By decoupling the graphics backend across multiple CPU cores, draw call throughput skyrockets—transforming what was once an unplayable bottleneck into an uncapped torrent of visual data.

Synthetic Motion Vectors & FSR 4: Engineering Magic in Yharnam

Perhaps the most mind-bending technological breakthrough in bbport is its treatment of modern temporal upscaling.

Modern temporal reconstruction technologies—including AMD FidelityFX Super Resolution (FSR 3.1 & FSR 4), NVIDIA DLSS, and Intel XeSS—rely on sub-pixel jitter and accurate per-pixel motion vectors (velocity buffers) to track objects moving across frames. Without motion vectors, temporal upscaling collapses into severe ghosting, smearing, and edge shimmer.

The problem? Bloodborne, built in 2014 on FromSoftware's proprietary engine, possesses no native velocity buffer whatsoever.

Rather than settling for blurry spatial upscaling, bbport synthesizes motion vectors completely on the fly:

1. Camera Velocity: Dynamically reconstructed from the scene's hardware depth buffer and the camera's inverse projection matrices.
2. Dynamic Object Velocity: The Hunter's movements, flapping trenchcoats, billowing capes, transforming trick weapons, and charging Lycanthropes are tracked by calculating per-vertex delta vectors between the current and previous frame.
3. Sub-Pixel Jitter: Halton sub-pixel jitter sequences are injected directly into the rendering pipeline.
4. Native UI Composition: The 3D scene renders at reduced resolution (720p, 1080p, or 1440p) and upscales to your target display, while the HUD, health bars, inventory icons, and dialogue fonts are rendered natively at full output resolution for pin-sharp clarity.

Even more astonishingly, bbport integrates AMD FSR 4 (INT8 model v07) and bit-exact FSR 4.1.1 natively through Vulkan. The developer even rewrote AMD's final shader passes to utilize workgroup shared memory on RDNA3 GPUs—clocking in at 3.5× faster and reducing FSR 4 frame times at 4K from ~6.0 ms down to an incredible ~4.0 ms!

Performance Reality: 150+ FPS, 4K, and the Steam Deck

Because the game code executes natively without emulation overhead, the performance gains are staggering:

• AMD Radeon RX 7800 XT (4K FSR 4 Balanced): ~90 FPS rock solid.
• 1440p Output (FSR 4 Quality): 140 to 150+ FPS.
• Community Simulation Patches: Integrates patches from legendary reverse-engineer Lance McDonald, Kyo, auser1337, and illusion to decouple the game's physics from its 30 Hz tick rate, offering silky smooth 60, 90, 120, or fully uncapped gameplay.
• In-Game Settings Overlay: Pressing Insert or clicking L3 + R3 opens a custom ImGui overlay allowing on-the-fly tuning of chromatic aberration, motion blur, depth of field, SSAO, screen-space reflections, and sharpness.

Steam Deck Ready: An AppImage in Your Pocket

For portable gaming enthusiasts, bbport is already packaged into a standalone AppImage complete with a GTK4 launcher. By targeting 720p output with temporal upscaling to the Steam Deck's 800p screen, players can add the AppImage as a Non-Steam Game with the --play flag and launch straight into Yharnam directly inside SteamOS Game Mode.

The launcher also includes built-in support for loose-file mods (drag-and-drop dvdroot_ps4/ folders), custom load orders, Lance McDonald's GoldHEN free camera, and FromSoftware's internal debug menu.

Clean and Legal: How to Run bbport

In accordance with strict video game preservation ethics and copyright law, no proprietary game files, models, textures, or Sony SDK binaries are included in the repository.

To run bbport, players must provide their own decrypted dump of Bloodborne extracted from a legally owned retail disc or PSN copy on a jailbroken PS4:

• Target Release: CUSA03173, updated to patch v1.09.
• Required Files: The game folder containing eboot.bin, sce_module/, and dvdroot_ps4/.
• Operating System: Linux x86-64 with a Vulkan 1.3 capable GPU (AMD RADV/Mesa, Intel, or NVIDIA).
• Repository: Source code, build instructions, and issue tracking are live on GitHub at deadinside28/bloodborne_pc, with community discussion hosted on their dedicated Discord server.

The Preservation Verdict: A Monumental Triumph

For ten years, the gaming community was told that bringing Bloodborne to modern PCs was too technically convoluted, that the engine’s internal Havok physics were too rigidly hardcoded to 30 FPS, and that Sony had no commercial incentive to remaster a decade-old PS4 exclusive.

The release of bbport proves once again that passionate, brilliant open-source developers can achieve what trillion-dollar corporations refuse to attempt. Standing on the shoulders of the shadPS4 graphics engine, Lance McDonald's foundational patch research, and modern Vulkan compute shaders, deadinside28 has delivered a masterclass in modern reverse engineering.

The night of the Hunt is finally over. Bloodborne is on PC—and it runs at 140 frames per second.