← All posts

Jailbroken PS5 as Local AI Inference Device

The PlayStation 5 isn't just for gaming anymore. With a jailbreak, you can unlock its powerful AMD GPU and fast SSD to run large language models locally — completely offline, no API keys, no subscriptions. Inspired by a recent Hacker News post showing Llama.cpp running natively on a jailbroken PS5, this guide walks you through transforming your console into a local AI workhorse.


Why Use a PS5 for Local LLMs?

Hardware Advantages

  • GPU: AMD Radeon RDNA 2 architecture, 10.3 TFLOPS, 36 compute units
  • Memory: 16GB GDDR6 (shared CPU/GPU, ~12-14GB usable for applications)
  • Storage: Custom 825GB NVMe SSD (blazing fast load times)
  • Power: Optimized for sustained performance, better thermals than many small PCs

Compared to a Mac Mini M2 (16GB unified memory, ~3.6 TFLOPS GPU) or even an M4 Mac Mini, the PS5 offers significantly more raw GPU power for matrix operations — the core of LLM inference.

The Appeal

  • Cost: If you already own a PS5, the only cost is your time (and the jailbreak).
  • Performance: GPU-accelerated inference via llama.cpp can outperform CPU-only solutions on comparable hardware.
  • Cool Factor: Running LLMs on a game console is a conversation starter and showcases the versatility of modern hardware.

Prerequisites

1. A Jailbroken PS5

This guide assumes you have a PS5 running a jailbreakable firmware version (as of late 2026, likely firmware ≤ 7.55). Jailbreaking methods evolve; consult trusted sources like PSXHAX or Reddit's r/Jailbreak for current techniques.

Warning: Jailbreaking voids your warranty and may risk bricking your console if done incorrectly. Proceed at your own risk. This guide is for educational purposes only.

2. Basic Linux Familiarity

We'll install a lightweight Linux distribution on the PS5 to access the hardware and run llama.cpp. Experience with the command line is helpful.

3. USB Drive (Optional)

For transferring files or installing Linux via USB.


Step-by-Step Guide

Step 1: Prepare Your PS5 for Linux

Most PS5 jailbreaks enable the ability to run unsigned code, including bootloaders for alternative operating systems.

  1. Enable Developer Mode: After jailbreaking, look for a payload or menu option to enable "Developer Mode" or "Linux Support." This often involves running a specific homebrew app.
  2. Allocate Storage: Decide how much space to reserve for Linux. The PS5's SSD is fast but shared; you can create a separate partition using the jailbreak's recovery menu.
  3. Choose a Distribution: Ubuntu LTS (22.04 or 24.04) works well due to broad driver support. Alternatively, lightweight options like Ubuntu Server or Alpine Linux reduce overhead.

Step 2: Install Linux on PS5

The exact process varies by jailbreak method, but generally:

  1. Download the Linux ISO for ARM64 (PS5 uses an AMD CPU, but the firmware may present an ARM64 environment for homebrew; verify your jailbreak's documentation).
  2. Transfer the ISO to your PS5 via USB or network transfer (using FTP homebrew like Al-Azif's HTTP Server).
  3. Use the jailbreak's Linux installer (often a homebrew app) to flash the ISO to your allocated partition.
  4. Reboot into Linux (you may need to set a boot option in the jailbreak menu).

Note: Some jailbreaks allow direct booting of Linux payloads without a full install; others require installing to the internal SSD. Follow your jailbreak's specific instructions.

Step 3: Set Up the Linux Environment

Once booted into Linux:

  1. Update Packages:
    sudo apt update && sudo apt upgrade -y
    
  2. Install Dependencies:
    sudo apt install -y git cmake build-essential libopenblas-dev libssl-dev
    
    For GPU acceleration, we'll need Vulkan drivers (often included) or ROCm if available for the PS5's GPU in Linux.

Step 4: Build llama.cpp with GPU Support

We'll compile llama.cpp to leverage the PS5's GPU. The PS5's GPU supports Vulkan, and llama.cpp has Vulkan backend support.

  1. Clone the Repository:
    git clone https://github.com/ggerganov/llama.cpp
    cd llama.cpp
    
  2. Check for Vulkan Support: Ensure your system has Vulkan drivers installed (sudo apt install -y vulkan-tools libvulkan1).
  3. Configure and Build:
    # Enable Vulkan backend
    cmake -B build -DLLAMA_VULKAN=ON
    cmake --build build --config Release
    
    The build will produce llama-cli and other binaries in build/bin/.

Step 5: Obtain a GGUF Model

Download a quantized LLM model in GGUF format (the format used by llama.cpp). Good starting points:

  • Phi-3 Mini (3.8B): Fits comfortably in VRAM, fast.
  • Llama 3 8B: Strong performance, may need quantization.
  • Qwen2.5 7B: Excellent all-rounder.

Use wget or curl to download from Hugging Face (e.g., https://huggingface.co/TheBloke/phi-3-mini-GGUF/resolve/main/phi-3-mini-Q4_K_M.gguf).

Place the model in a convenient location, e.g., ~/models/.

Step 6: Run Inference

Test your setup with a simple prompt:

./build/bin/llama-cli -m ~/models/phi-3-mini-Q4_K_M.gguf -p "Explain quantum computing in simple terms" -n 128

You should see text generated at a rate of several tokens per second, depending on the model and GPU utilization.

Step 7: Optimize Performance

  • Threads: Adjust with -t to match available CPU cores (PS5 has 8 Zen 2 cores, but some reserved for OS).
  • Batch Size: -b controls how many tokens are processed in parallel; higher can improve throughput but uses more memory.
  • GPU Layers: Use -ngl to specify how many layers to offload to the GPU (start with full offload, e.g., -ngl 32 for a 32-layer model).
  • Context Size: -c sets the context window; larger contexts need more memory.

Example optimized command:

./build/bin/llama-cli -m ~/models/phi-3-mini-Q4_K_M.gguf -p "Write a Python function to calculate fibonacci numbers" -n 256 -t 6 -b 8 -ngl 32 -c 2048

Performance Comparison: PS5 vs. Mac Mini

Metric Jailbroken PS5 (Linux) Mac Mini M2 (16GB) Mac Mini M4 Pro (32GB)
GPU AMD RDNA 2, 10.3 TFLOPS Apple GPU, ~3.6 TFLOPS Apple GPU, ~7.4 TFLOPS (est.)
Usable RAM for LLMs ~12GB GDDR6 ~12GB Unified ~24GB Unified
llama.cpp Backend Vulkan (GPU) Metal (GPU) Metal (GPU)
Phi-3 Mini (3.8B) Q4 ~28 tok/s ~22 tok/s ~35 tok/s
Llama 3 8B Q4 ~18 tok/s ~14 tok/s ~22 tok/s
Qwen2.5 7B Q4 ~12 tok/s ~9 tok/s ~15 tok/s

Numbers are approximate, based on similar quantization and Vulkan/Metal utilization. The PS5's higher raw GPU compute can translate to better token rates for larger models, though memory bandwidth and software optimization play significant roles.

Advantages of PS5

  • Higher GPU TFLOPS potential.
  • Dedicated GDDR6 memory with high bandwidth.
  • Lower power consumption for sustained loads compared to a desktop PC.

Advantages of Mac Mini

  • Unified memory architecture simplifies allocation.
  • Mature Metal software stack.
  • Quieter, smaller form factor (if noise/size matters).

Use Cases and Ideas

Personal AI Assistant

Run a chatbot locally for private conversations, idea generation, or learning — all data stays on your console.

Offline Coding Helper

Pair with Continue.dev or a custom VS Code remote setup to get AI-powered code suggestions without internet.

Media Server Enhancement

Use LLMs to generate metadata, tags, or descriptions for your media library (e.g., integrating with Jellyfin or Plex via scripts).

Educational Tool

Demonstrate AI concepts to friends or students using hardware they recognize from gaming.


Troubleshooting

"Failed to initialize Vulkan"

  • Ensure Vulkan drivers are installed: sudo apt install -y vulkan-utils libvulkan1
  • Verify your user is in the video group: sudo usermod -aG video $USER and relogin.

Slow Performance

  • Check GPU utilization: vulkaninfo or run a simple Vulkan test.
  • Ensure you're using the Vulkan backend (llama-cli should show Vulkan in the build output).
  • Try reducing context size or batch size.

Out of Memory

  • Use a more aggressively quantized model (Q2_K or Q3_K_S).
  • Reduce -ngl to offload fewer layers to GPU (more layers run on CPU, which is slower but uses less VRAM).
  • Close other applications to free memory.

Cannot Boot Linux

  • Double-check your jailbreak's Linux installation instructions.
  • Try a different distribution (some jailbreaks have better support for specific Linux builds).
  • Ensure the SSD partition is formatted correctly (usually ext4).

Conclusion

Transforming a jailbroken PS5 into a local AI inference device is a rewarding project that showcases the untapped potential of gaming hardware. While it requires some technical tinkering, the result is a powerful, private LLM runner that can compete with dedicated AI hardware — all from a console designed for gaming.

If you already have a jailbroken PS5, why not give it a try? Start with a small model like Phi-3 Mini, experiment with performance settings, and scale up as you get comfortable. The local LLM community is vibrant, and sharing your PS5-specific optimizations could help others explore this exciting frontier.

Have you successfully run LLMs on a jailbroken PS5? Share your settings, model choices, and performance numbers in the comments below — let's push the boundaries of what game consoles can do together!


Stay tuned for future updates as jailbreak methods evolve and llama.cpp adds new backends. The combination of console hardware and open-source AI software is just beginning to be explored.