chiaki-ng

https://github.com/streetpea/chiaki-ng
Admin
An open source PlayStation 4 and PlayStation 5 Remote Play client for Linux, macOS, Windows,...
Tokens:62,578
Snippets:444
Trust Score:8.5
License:AGPL-3.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install devel Flatpak and SDK

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/builddocs.md

Install the development Flatpak and SDK for chiaki-ng on Linux. The first command installs the devel Flatpak from the chiaki-ng repository, the second installs the required KDE SDK version 6.9, and the third runs the devel Flatpak with a bash shell.

```bash
flatpak install -y --user https://raw.githubusercontent.com/streetpea/chiaki-ng/main/scripts/flatpak/io.github.streetpea.Chiaki4deck-devel.flatpakref
```

```bash
flatpak install -y --user org.kde.Sdk//6.9
```

```bash
flatpak run --devel --command=bash io.github.streetpea.Chiaki4deck-devel
```

--------------------------------

### Example: flatpak-coredumpctl with PID 4822

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Example command using PID 4822 and flatpak name io.github.streetpea.Chiaki4deck-devel.

```bash
flatpak-coredumpctl -m 4822 io.github.streetpea.Chiaki4deck-devel
```

--------------------------------

### Install chiaki-ng from Flathub

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/updates/releases.md

Installs the current version of chiaki-ng from the Flathub repository.

```bash
flatpak install -y --user flathub io.github.streetpea.Chiaki4deck
```

--------------------------------

### Install KDE SDK

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Installs the required KDE SDK version 6.9.

```bash
flatpak install --user org.kde.Sdk//6.9
```

--------------------------------

### Install mkdocs and plugins

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/builddocs.md

Install the Python packages required to build the chiaki-ng documentation: mkdocs, mkdocs-material, mkdocs-git-revision-date-localized-plugin, and mkdocs-print-site-plugin. Requires pip3 to be installed on your system.

```bash
pip3 install mkdocs mkdocs-material mkdocs-git-revision-date-localized-plugin mkdocs-print-site-plugin
```

--------------------------------

### Add Local Remote and Install Self-Built Flatpak

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

These commands add a local remote repository and install the self-built flatpak from it. The remote-add command imports the GPG key and adds the remote named 'chiaki-ng-diy' pointing to the local build directory. The install command then installs the 'io.github.streetpea.Chiaki4deck' application from that remote.

```bash
flatpak --user remote-add --gpg-import chiaki-ng-diy.gpg chiaki-ng-diy ~/build-chiaki-ng-flatpak/chiaki-ng-diy
```

```bash
flatpak --user install chiaki-ng-diy io.github.streetpea.Chiaki4deck
```

--------------------------------

### Install Flatpak runtime and SDK

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Installs the required Flatpak runtime and SDK from Flathub. Use this before building the chiaki-ng Flatpak.

```bash
flatpak install -y flathub org.kde.Platform//6.9 flathub org.kde.Sdk//6.9
```

--------------------------------

### Example chiaki-ng launch script with placeholder values

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

Example bash script with placeholder values for automating chiaki-ng launch. Replace the placeholders with your actual values.

```bash
#!/usr/bin/env bash
```

--------------------------------

### Serve documentation with mkdocs serve

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/builddocs.md

Start a local development server to preview the documentation. The command outputs an address, by default http://127.0.0.1:8000, which is only accessible locally. The docs update automatically when you save changes to the markdown files.

```bash
mkdocs serve
```

--------------------------------

### Target Properties and Installation

Source: https://github.com/streetpea/chiaki-ng/blob/main/gui/CMakeLists.txt

Configures macOS bundle properties and defines installation rules for the executable and support files.

```cmake
set_target_properties(chiaki PROPERTIES
		MACOSX_BUNDLE TRUE
		MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/MacOSXBundleInfo.plist.in"
		MACOSX_BUNDLE_BUNDLE_NAME chiaki-ng
		MACOSX_BUNDLE_BUNDLE_VERSION ${CHIAKI_VERSION}
		MACOSX_BUNDLE_COPYRIGHT "thestr4ng3r (AGPLv3)"
		MACOSX_BUNDLE_GUI_IDENTIFIER "org.streetpea.chiaking"
		MACOSX_BUNDLE_ICON_FILE chiaking.icns
		RESOURCE "${RESOURCE_FILES}")

install(TARGETS chiaki
		RUNTIME DESTINATION bin
		BUNDLE DESTINATION bin)
install(FILES chiaking.desktop DESTINATION share/applications)
install(FILES chiaking.png DESTINATION share/icons/hicolor/512x512/apps)
install(FILES io.github.streetpea.Chiaki4deck.appdata.xml DESTINATION share/metainfo)
```

--------------------------------

### Install Chiaki-ng via winget on Windows

Source: https://github.com/streetpea/chiaki-ng/blob/main/doc/release_notes.md

Use this command to install Chiaki-ng on Windows using the winget package manager.

```bash
winget install --id=StreetPea.chiaki-ng -e
```

--------------------------------

### Install dependencies on Ubuntu/Debian

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Install the required packages (gpg, curl, flatpak, flatpak-builder) on Ubuntu or Debian-based systems.

```bash
sudo apt update && sudo apt install -y gnupg curl flatpak flatpak-builder
```

--------------------------------

### Install Chiaki-ng via Homebrew on macOS

Source: https://github.com/streetpea/chiaki-ng/blob/main/doc/release_notes.md

Use this command to install Chiaki-ng on macOS via Homebrew. Requires Homebrew to be installed.

```bash
brew install --cask streetpea/streetpea/chiaki-ng
```

--------------------------------

### Install chiaki-ng Flatpak via konsole

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/installation.md

Use this command in the konsole terminal to install the official chiaki-ng flatpak from Flathub. This is an alternative if the Discover store doesn't show the app.

```bash
flatpak install -y io.github.streetpea.Chiaki4deck
```

--------------------------------

### CMake project setup and options

Source: https://github.com/streetpea/chiaki-ng/blob/main/CMakeLists.txt

Defines the project name, minimum CMake version, and a macro for tri-state options. Sets many build options for features like tests, CLI, GUI, Android, and various decoders.

```cmake
cmake_minimum_required(VERSION 3.10)

project(chiaki)

# Like option(), but the value can also be AUTO
macro(tri_option name desc default)
    set("${name}" "${default}" CACHE STRING "${desc}")
    set_property(CACHE "${name}" PROPERTY STRINGS AUTO ON OFF)
endmacro()

option(CHIAKI_ENABLE_TESTS "Enable tests for Chiaki" ON)
option(CHIAKI_ENABLE_CLI "Enable CLI for Chiaki" ON)
option(CHIAKI_ENABLE_GUI "Enable Qt GUI" ON)
option(CHIAKI_ENABLE_ANDROID "Enable Android (Use only as part of the Gradle Project)" OFF)
option(CHIAKI_ENABLE_BOREALIS "Enable Borealis GUI (For Nintendo Switch or PC)" OFF)
tri_option(CHIAKI_ENABLE_SETSU "Enable libsetsu for touchpad input from controller" AUTO)
tri_option(CHIAKI_ENABLE_STEAMDECK_NATIVE "Enable sdeck for native gyro and haptic feedback from Steam Deck" ON)
option(CHIAKI_LIB_ENABLE_OPUS "Use Opus as part of Chiaki Lib" ON)
tri_option(CHIAKI_ENABLE_SPEEX "Use speex for echo cancelling mic playback" AUTO)
tri_option(CHIAKI_ENABLE_RUDP "Enable Remote Play over Internet" AUTO)
if(CHIAKI_ENABLE_GUI OR CHIAKI_ENABLE_BOREALIS)
	set(CHIAKI_FFMPEG_DEFAULT ON)
else()
	set(CHIAKI_FFMPEG_DEFAULT AUTO)
endif()
tri_option(CHIAKI_ENABLE_FFMPEG_DECODER "Enable FFMPEG video decoder" ${CHIAKI_FFMPEG_DEFAULT})
tri_option(CHIAKI_ENABLE_PI_DECODER "Enable Raspberry Pi-specific video decoder (requires libraspberrypi0 and libraspberrypi-doc)" AUTO)
option(CHIAKI_LIB_ENABLE_MBEDTLS "Use mbedtls instead of OpenSSL as part of Chiaki Lib" OFF)
option(CHIAKI_LIB_MBEDTLS_EXTERNAL_PROJECT "Fetch Mbed TLS instead of using system-provided libs" OFF)
option(CHIAKI_LIB_OPENSSL_EXTERNAL_PROJECT "Use OpenSSL as CMake external project" OFF)
option(CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER "Use SDL Gamecontroller for Input" ON)
option(CHIAKI_CLI_ARGP_STANDALONE "Search for standalone argp lib for CLI" OFF)
option(CHIAKI_ENABLE_STEAM_SHORTCUT "Add ability to create Steam shortcut" ON)
tri_option(CHIAKI_USE_SYSTEM_JERASURE "Use system-provided jerasure instead of submodule" AUTO)
tri_option(CHIAKI_USE_SYSTEM_NANOPB "Use system-provided nanopb instead of submodule" AUTO)
tri_option(CHIAKI_USE_SYSTEM_CURL "Use system-provided curl instead of submodule. Has to be built with experimental WebSocket support!" OFF)
option(CHIAKI_LIB_JSONC_EXTERNAL_PROJECT "Build json-c from source via FetchContent" OFF)
option(CHIAKI_LIB_MINIUPNPC_EXTERNAL_PROJECT "Build miniupnpc from source via FetchContent" OFF)
```

--------------------------------

### Get Registration Key: cat Chiaki.conf | grep regist_key

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

Prints the remote play registration key from the Chiaki configuration file, which is required for the launch script. The example output shows the key '2ebf539d'.

```bash
cat ~/.var/app/io.github.streetpea.Chiaki4deck/config/Chiaki/Chiaki.conf | grep regist_key | cut -d '(' -f2 | cut -d '\' -f1
```

```bash
2ebf539d
```

--------------------------------

### Install Fedora build dependencies

Source: https://github.com/streetpea/chiaki-ng/blob/main/doc/platform-build.md

Install all required build dependencies for Chiaki on Fedora using dnf.

```bash
sudo dnf install cmake make qt5-qtmultimedia-devel qt5-qtsvg-devel qt5-qtbase-gui ffmpeg-devel opus-devel openssl-devel python3-protobuf protobuf-c protobuf-devel qt5-rpm-macros SDL2-devel libevdev-devel systemd-devel speexdsp
```

--------------------------------

### Install development Flatpak

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Installs the development version of the Flatpak with debug extensions enabled.

```bash
flatpak install --user --include-debug -y https://raw.githubusercontent.com/streetpea/chiaki-ng/main/scripts/flatpak/io.github.streetpea.Chiaki4deck-devel.flatpakref
```

--------------------------------

### Install dependencies on RHEL/CentOS

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Install the required packages (gpg, curl, flatpak, flatpak-builder) on RHEL or CentOS systems.

```bash
sudo yum update && sudo yum install -y gnupg curl flatpak flatpak-builder
```

--------------------------------

### Update Flathub installation

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/updates/releases.md

Updates the chiaki-ng flatpak installed via the Discover store.

```bash
flatpak update -y io.github.streetpea.Chiaki4deck
```

--------------------------------

### Install dependencies on Arch Linux

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Install the required packages (gpg, curl, flatpak, flatpak-builder) on Arch Linux.

```bash
sudo pacman -Syy && sudo pacman -S gnupg curl flatpak flatpak-builder
```

--------------------------------

### Install Chiaki-ng via Chocolatey on Windows

Source: https://github.com/streetpea/chiaki-ng/blob/main/doc/release_notes.md

Use this command to install Chiaki-ng on Windows using Chocolatey package manager.

```bash
choco install chiaki-ng
```

--------------------------------

### Install KDE SDK Debug extensions

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Installs the debug extensions for the KDE SDK version 6.9.

```bash
flatpak install --user org.kde.Sdk.Debug//6.9
```

--------------------------------

### Build bundled libcurl with WebSocket support

Source: https://github.com/streetpea/chiaki-ng/blob/main/third-party/CMakeLists.txt

Configures and builds bundled libcurl with experimental WebSocket support when CHIAKI_USE_SYSTEM_CURL is not set and the target is not the Switch. Disables executables, shared libs, testing, examples, and install; enables HTTP-only and WebSockets. On Windows, includes CurlSchannelAia.cmake and enables Schannel. Optionally finds libidn2 via pkg-config and creates the Libidn2::Libidn2 alias. The exported library is CURL::libcurl_static.

```CMake
if (NOT CHIAKI_IS_SWITCH) 
	if(NOT CHIAKI_USE_SYSTEM_CURL) 
		##################
		# libcurl (with experimental WebSocket support enabled)
		##################
		set(BUILD_CURL_EXE OFF)
		set(BUILD_SHARED_LIBS OFF)
		set(BUILD_STATIC_LIBS ON)
		set(BUILD_TESTING OFF)
		set(BUILD_EXAMPLES OFF)
		set(CURL_DISABLE_INSTALL ON)
		set(HTTP_ONLY ON)
		set(ENABLE_WEBSOCKETS ON)
		set(CHIAKI_CURL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/curl")
	if(WIN32)
		include("${PROJECT_SOURCE_DIR}/cmake/CurlSchannelAia.cmake")
		set(USE_SSLEAY ON)
		set(CURL_USE_SCHANNEL ON)
	endif()
		find_package(PkgConfig QUIET)
		if (PKG_CONFIG_FOUND)
			pkg_check_modules(PkgLibIdn2 IMPORTED_TARGET GLOBAL libidn2)
		endif ()

		if (PkgLibIdn2_FOUND)
			set(LIBIDN2_INCLUDE_DIR ${PkgLibIdn2_INCLUDE_DIRS} CACHE FILEPATH "libidn2 include path")
			set(LIBIDN2_LIBRARIES ${PkgLibIdn2_LIBRARIES} CACHE STRING "libidn2 libraries")
			set(LIBIDN2_VERSION ${PkgLibIdn2_VERSION})
			add_library(Libidn2::Libidn2 ALIAS PkgConfig::PkgLibIdn2)
			set(Libidn2_FOUND ON)
		endif()
		add_subdirectory("${CHIAKI_CURL_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/curl")
		# Exported library is CURL::libcurl_static
	endif()
endif()
```

--------------------------------

### Chiaki Config File Example

Source: https://github.com/streetpea/chiaki-ng/blob/main/switch/README.md

Example chiaki.conf configuration file generated by the application. Contains sensitive data, so do not share it. Required fields: PS*-*** section name, host_addr, psn_online_id, and psn_account_id (for PS4>7.0). Optional fields: video_fps (default 60, must be 30 or 60) and video_resolution (default 720p, must be 720p, 540p or 360p).

```ini
# required: PS*-*** (PS4/PS5 local name)
# name from Settings > System > system information
[PS*-***]
# required: lan PlayStation IP address
# IP from Settings > System > system information
host_addr = *.*.*.*
# required: sony oline id (login)
psn_online_id = ps_online_id
# required (PS4>7.0 Only): https://git.sr.ht/~thestr4ng3r/chiaki/tree/master/item/README.md#obtaining-your-psn-accountid
psn_account_id = ps_base64_account_id
# optional(default 60): remote play fps (must be 30 or 60)
video_fps = 60
# optional(default 720p): remote play resolution (must be 720p, 540p or 360p)
video_resolution = 720p
```

--------------------------------

### Build Chiaki with CMake

Source: https://github.com/streetpea/chiaki-ng/blob/main/doc/platform-build.md

Standard CMake build steps for Chiaki after installing dependencies.

```bash
git submodule update --init
mkdir build && cd build
cmake ..
make
```

--------------------------------

### Install flatpak-builder on Steam OS

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Steam OS has a read-only filesystem, so you must temporarily disable it, initialize and populate the keyring with Arch and Holo keys, install flatpak-builder, then re-enable read-only mode. Note that installed packages may be wiped during a system update.

```bash
sudo steamos-readonly disable
```

```bash
sudo pacman-key --init
```

```bash
sudo pacman-key --populate archlinux
```

```bash
sudo pacman-key --populate holo
```

```bash
sudo pacman -Syy && sudo pacman -S flatpak-builder
```

```bash
sudo steamos-readonly enable
```

--------------------------------

### Open gdb session with flatpak-coredumpctl

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Use flatpak-coredumpctl with the given PID and flatpak name to start a gdb session for the flatpak application.

```bash
flatpak-coredumpctl -m given_pid flatpak_name
```

--------------------------------

### Update legacy flatpak installation

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/updates/releases.md

Updates the legacy chiaki-ng flatpak installation via the terminal.

```bash
flatpak update --user -y re.chiaki.Chiaki4deck
```

--------------------------------

### Run gen-launcher.sh script

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

Runs the gen-launcher.sh script to generate a launcher script for waking the PlayStation and launching Chiaki. The script prompts for the IP address from step 2 and optionally supports external IP/hostname setup.

```bash
bash <(curl -sLo- https://raw.githubusercontent.com/streetpea/chiaki-ng/main/scripts/gen-launcher.sh)
```

--------------------------------

### Build chiaki-borealis executable with dependencies and Switch NRO target

Source: https://github.com/streetpea/chiaki-ng/blob/main/switch/CMakeLists.txt

Builds the chiaki-borealis executable: finds FFMPEG, SDL2, swresample, and dav1d; compiles the listed source files with C++17 and output name chiaki; links chiaki-lib, borealis, and media libraries; adds Switch-specific Z/GLAPI/DRM_NOUVEAU libraries; installs to bin; and creates an NRO target for Switch with metadata and resources.

```cmake
find_package(FFMPEG REQUIRED COMPONENTS avcodec avutil swscale)
find_library(SDL2 SDL2)
find_library(SWRESAMPLE swresample)
find_library(DAV1D dav1d)
```

```cmake
# find -type f | grep -P '\.(h|cpp)$' | sed 's#\./#\t\t#g'
add_executable(chiaki-borealis WIN32
	src/views/enter_pin_view.cpp
	src/views/ps_remote_play.cpp
	src/discoverymanager.cpp
	src/settings.cpp
	src/io.cpp
	src/host.cpp
	src/main.cpp
	src/gui.cpp)
```

```cmake
set_target_properties(chiaki-borealis PROPERTIES
	CXX_STANDARD 17
	OUTPUT_NAME chiaki)
```

```cmake
target_include_directories(chiaki-borealis PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
```

```cmake
target_link_libraries(chiaki-borealis
	chiaki-lib
	borealis
	${SDL2}
	dav1d
	FFMPEG::avcodec
	FFMPEG::avutil
	FFMPEG::swscale
	${SWRESAMPLE}
	${SWSCALE})
```

```cmake
if(CHIAKI_IS_SWITCH)
	# libnx is forced by the switch toolchain
	find_library(Z z)
	find_library(GLAPI glapi) # TODO: make it transitive from borealis
	find_library(DRM_NOUVEAU drm_nouveau) # TODO: make it transitive from borealis
	target_link_libraries(chiaki-borealis ${Z} ${GLAPI} ${DRM_NOUVEAU})
endif()
```

```cmake
install(TARGETS chiaki-borealis
	RUNTIME DESTINATION bin
	BUNDLE DESTINATION bin)
```

```cmake
if(CHIAKI_IS_SWITCH)
	add_nro_target(chiaki
		chiaki-borealis
		"Chiaki-ng"
		"StreetPea, kkWong, xlanor, H0neyBadger and thestr4ng3r"
		"${CHIAKI_VERSION}"
		"${CMAKE_CURRENT_SOURCE_DIR}/nro_icon.jpg"
		"${CMAKE_CURRENT_SOURCE_DIR}/res")
endif()
```

--------------------------------

### Bash script to automate chiaki-ng launch

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

This script checks if the Steam Deck is on the local network, discovers the PlayStation console, wakes it if needed, waits for it to be ready, and then starts remote play. It uses flatpak commands for Chiaki4deck. The script includes error handling for timeouts and connection issues.

```bash
timeout_error()
{
    echo "Error: PlayStation console didn't become ready in 35 seconds!" >&2
    echo "Error: Please change 35 to a higher number in your script if this persists." >&2
    exit 1
}
if [ "$(iwgetid -r)" == "<local_ssid>" ]
then
    addr="<local_addr>"
    local=true
else
    addr="<external_addr>"
    local=false
fi
SECONDS=0
# Wait for console to be in sleep/rest mode or on (otherwise console isn't available)
ps_status="$(flatpak run io.github.streetpea.Chiaki4deck discover -h ${addr} 2>/dev/null)"
while ! echo "${ps_status}" | grep -q 'ready\|standby'
do
    if [ ${SECONDS} -gt 35 ]
    then
        if [ "${local}" = true ]
        then
            connect_error_loc
        else
            connect_error_ext
        fi
    fi
    sleep 1
    ps_status="$(flatpak run io.github.streetpea.Chiaki4deck discover -h ${addr} 2>/dev/null)"
done

# Wake up console from sleep/rest mode if not already awake
if ! echo "${ps_status}" | grep -q ready
then
    flatpak run io.github.streetpea.Chiaki4deck wakeup -<playstation_console> -h ${addr} -r '<remote_play_registration_key>' 2>/dev/null
fi

# Wait for PlayStation to report ready status, exit script on error if it never happens.
while ! echo "${ps_status}" | grep -q ready
do
    if [ ${SECONDS} -gt 35 ]
    then
        if echo "${ps_status}" | grep -q standby
        then
            wakeup_error
        else
            timeout_error
        fi
    fi
    sleep 1
    ps_status="$(flatpak run io.github.streetpea.Chiaki4deck discover -h ${addr} 2>/dev/null)"
done

# Begin playing PlayStation remote play via Chiaki on your Steam Deck :)
flatpak run io.github.streetpea.Chiaki4deck --passcode <login_passcode> --<launch_option> stream '<console_nickname>' ${addr}
```

--------------------------------

### Build Chiaki-ng for Switch with Podman

Source: https://github.com/streetpea/chiaki-ng/blob/main/switch/README.md

Builds the Chiaki-ng project for Nintendo Switch using a Podman container. Requires the devkitpro toolchain, which can be installed on your personal computer or used via the provided container.

```bash
bash scripts/switch/run-podman-build-chiaki.sh
```

--------------------------------

### Bash script to automate chiaki-ng launch

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

This script checks the local network, discovers the PlayStation console, wakes it if needed, and starts streaming via chiaki-ng. It includes error handling functions for connection and wake-up failures. The script uses the flatpak command for chiaki-ng and assumes a specific network SSID and IP address.

```bash
connect_error_loc()
{
    echo "Error: Couldn't connect to your PlayStation console from your local address!" >&2
    echo "Error: Please check that your Steam Deck and PlayStation are on the same network" >&2
    echo "Error: ...and that you have the right PlayStation IP address or hostname!" >&2
    exit 1
}

connect_error_ext()
{
    echo "Error: Couldn't connect to your PlayStation console from your external address!" >&2
    echo "Error: Please check that you have forwarded the necessary ports on your router" >&2
    echo "Error: ...and that you have the right external PlayStation IP address or hostname!" >&2
    exit 1
}

wakeup_error()
{
    echo "Error: Couldn't wake up PlayStation console from sleep!" >&2
    echo "Error: Please make sure you are using a PlayStation 5." >&2
    echo "Error: If not, change the wakeup call to use the number of your PlayStation console" >&2
    exit 2
}

timeout_error()
{
    echo "Error: PlayStation console didn't become ready in 35 seconds!" >&2
    echo "Error: Please change 35 to a higher number in your script if this persists." >&2
    exit 1
}
if [ "$(iwgetid -r)" == "StreetPea-5G" ]
then
    addr="192.168.1.16"
    local=true
else
    addr="foo.bar.com"
    local=false
fi
SECONDS=0
# Wait for console to be in sleep/rest mode or on (otherwise console isn't available)
ps_status="$(flatpak run io.github.streetpea.Chiaki4deck discover -h ${addr} 2>/dev/null)"
while ! echo "${ps_status}" | grep -q 'ready\|standby'
do
    if [ ${SECONDS} -gt 35 ]
    then
        if [ "${local}" = true ]
        then
            connect_error_loc
        else
            connect_error_ext
        fi
    fi
    sleep 1
    ps_status="$(flatpak run io.github.streetpea.Chiaki4deck discover -h ${addr} 2>/dev/null)"
done

# Wake up console from sleep/rest mode if not already awake
if ! echo "${ps_status}" | grep -q ready
then
    flatpak run io.github.streetpea.Chiaki4deck wakeup -5 -h ${addr} -r '2ebf539d' 2>/dev/null
fi

# Wait for PlayStation to report ready status, exit script on error if it never happens.
while ! echo "${ps_status}" | grep -q ready
do
    if [ ${SECONDS} -gt 35 ]
    then
        if echo "${ps_status}" | grep -q standby
        then
            wakeup_error
        else
            timeout_error
        fi
    fi
    sleep 1
    ps_status="$(flatpak run io.github.streetpea.Chiaki4deck discover -h ${addr} 2>/dev/null)"
done

# Begin playing PlayStation remote play via Chiaki on your Steam Deck :)
flatpak run io.github.streetpea.Chiaki4deck --passcode --zoom stream 'PS5-012' ${addr}
```

--------------------------------

### Get local SSID via konsole

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

Command to retrieve the current network SSID using iwgetid. Must be connected to the local network for this method to work.

```bash
iwgetid -r
```

--------------------------------

### Convert Backtrace Address with addr2line

Source: https://github.com/streetpea/chiaki-ng/blob/main/switch/README.md

Troubleshooting command to convert a backtrace address to a source line. Replace 0xCCB5C with the backtrace address (PC - Backtrace Start Address).

```bash
# replace 0xCCB5C with the backtrace adress (PC - Backtrace Start Address)
aarch64-none-elf-addr2line \
	-e ./build_switch/switch/chiaki \
	-f -p -C -a 0xCCB5C
```

--------------------------------

### Clone chiaki-ng repository

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/builddocs.md

Clone the chiaki-ng source code repository using your preferred method: HTTPS, SSH, or GitHub CLI. Choose the appropriate command based on your authentication setup.

```bash
git clone https://github.com/streetpea/chiaki-ng.git
```

```bash
git clone git@github.com:streetpea/chiaki-ng.git
```

```bash
gh repo clone streetpea/chiaki-ng
```

--------------------------------

### Create and enter build directory

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Creates a directory for build files and switches into it.

```bash
mkdir -p ~/build-chiaki-ng-flatpak && cd ~/build-chiaki-ng-flatpak
```

--------------------------------

### Get Console Nickname: flatpak run io.github.streetpea.Chiaki4deck list

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

Lists the PlayStation consoles found by chiaki-ng, used to identify the console nickname needed for the launch script. The example output shows the nickname 'PS5-012'.

```bash
flatpak run io.github.streetpea.Chiaki4deck list
```

```bash
Host: PS5-012
```

--------------------------------

### Enter development Flatpak environment

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Use this command to enter the development version of the Flatpak with the source code mounted.

```bash
flatpak run --command=bash --devel io.github.streetpea.Chiaki4deck-devel
```

--------------------------------

### CMake Project Initialization and Qt6 Dependencies

Source: https://github.com/streetpea/chiaki-ng/blob/main/gui/CMakeLists.txt

Sets up basic CMake automation for Qt and finds required Qt6 components, including optional private modules for newer versions.

```cmake
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)

if(APPLE)
	enable_language(OBJCXX)
endif()

find_package(Qt6 REQUIRED COMPONENTS Core Gui Concurrent Svg Qml Quick Widgets)
if(Qt6_VERSION VERSION_GREATER_EQUAL "6.10.0")
	find_package(Qt6 REQUIRED COMPONENTS GuiPrivate)
endif()

find_package(Qt6 COMPONENTS WebEngineQuick)
find_package(Qt6 COMPONENTS DBus)

if(WIN32)
	add_definitions(-DWIN32_LEAN_AND_MEAN)
endif()
```

--------------------------------

### Run Release build

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Execute the Release build directly.

```bash
./gui/chiaki
```

--------------------------------

### Build Flatpak with flatpak-builder

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Builds the Flatpak for chiaki-ng. The first build takes 15+ minutes; subsequent builds are faster because dependencies are cached.

```bash
flatpak-builder --repo=chiaki-ng-diy --force-clean build chiaki-ng.yaml --gpg-sign chiaki-ng-diy
```

--------------------------------

### Run the chiaki-ng launcher script

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

This command executes the chiaki-ng launcher script to test the automation. If successful, chiaki-ng launches in the desired screen mode on the client device.

```bash
"${HOME}/.var/app/io.github.streetpea.Chiaki4deck/config/Chiaki/Chiaki-launcher.sh"
```

--------------------------------

### Copy configuration file

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Copies the existing Chiaki configuration to the development environment.

```bash
cp ~/.var/app/io.github.streetpea.Chiaki4deck/config/Chiaki/Chiaki.conf ~/.var/app/io.github.streetpea.Chiaki4deck-devel/config/Chiaki/Chiaki.conf
```

--------------------------------

### Configure local Flatpak manifest sources

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Shows the transition from a git-based source to a local directory source in the Flatpak manifest.

```bash
sources:
- type: git
  url: https://github.com/streetpea/chiaki-ng.git
  branch: main
```

```bash
sources:
- type: dir
  path: path-to-chiaki-ng-git
```

--------------------------------

### mbedTLS Configuration and FetchContent

Source: https://github.com/streetpea/chiaki-ng/blob/main/CMakeLists.txt

If CHIAKI_LIB_ENABLE_MBEDTLS is set, adds definition and optionally fetches mbedtls v2.28.0 from GitHub.

```cmake
if(CHIAKI_LIB_ENABLE_MBEDTLS)
	add_definitions(-DCHIAKI_LIB_ENABLE_MBEDTLS)
	if(CHIAKI_LIB_MBEDTLS_EXTERNAL_PROJECT)
		set(FETCHCONTENT_QUIET CACHE BOOL FALSE)
		include(FetchContent)
		set(ENABLE_TESTING CACHE INTERNAL OFF)
		set(ENABLE_PROGRAMS CACHE INTERNAL OFF)
		set(USE_SHARED_MBEDTLS_LIBRARY CACHE INTERNAL OFF)
		FetchContent_Declare(
			mbedtls
			GIT_REPOSITORY https://github.com/Mbed-TLS/mbedtls.git
			GIT_TAG 8b3f26a5ac38d4fdccbc5c5366229f3e01dafcc0 # v2.28.0
			GIT_PROGRESS TRUE
		)
		FetchContent_MakeAvailable(mbedtls)
	endif()
endif()
```

--------------------------------

### Create Release build

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Commands to configure and compile a Release build of chiaki-ng.

```bash
mkdir Release
```

```bash
cd Release
```

```bash
cmake -DCMAKE_BUILD_TYPE=Release ..
```

```bash
make
```

--------------------------------

### Create Chiaki-launcher.sh: touch Command

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

Creates a new blank file named 'Chiaki-launcher.sh' in the specified directory to store the launch script.

```bash
touch "${HOME}/.var/app/io.github.streetpea.Chiaki4deck/config/Chiaki/Chiaki-launcher.sh"
```

--------------------------------

### Uninstall legacy flatpak

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/updates/releases.md

Removes the deprecated legacy flatpak installation.

```bash
flatpak uninstall -y re.chiaki.Chiaki4deck
```

--------------------------------

### Download Flatpak manifest

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Downloads the Flatpak manifest file for chiaki-ng.

```bash
curl -Lo chiaki-ng.yaml https://raw.githubusercontent.com/streetpea/chiaki-ng/main/scripts/flatpak/chiaki4deck.yaml
```

--------------------------------

### System Nanopb Option Handling

Source: https://github.com/streetpea/chiaki-ng/blob/main/CMakeLists.txt

Checks CHIAKI_USE_SYSTEM_NANOPB. If AUTO, finds package quietly and sets to found status; otherwise requires package and sets ON.

```cmake
if(CHIAKI_USE_SYSTEM_NANOPB)
	if(CHIAKI_USE_SYSTEM_NANOPB STREQUAL AUTO)
		find_package(Nanopb QUIET)
		set(CHIAKI_USE_SYSTEM_NANOPB ${Nanopb_FOUND})
	else()
		find_package(Nanopb REQUIRED)
		set(CHIAKI_USE_SYSTEM_NANOPB ON)
	endif()
endif()
```

--------------------------------

### Configure Nanopb generator environment

Source: https://github.com/streetpea/chiaki-ng/blob/main/lib/protobuf/CMakeLists.txt

Sets up the environment variables to ensure the protoc compiler is available in the PATH when running the Nanopb generator on Unix systems.

```cmake
set(SOURCE_FILES "${CMAKE_CURRENT_BINARY_DIR}/takion.pb.c")
set(HEADER_FILES "${CMAKE_CURRENT_BINARY_DIR}/takion.pb.h")

if(UNIX AND IS_ABSOLUTE "${PROTOC}")
	# make sure protoc is in PATH when invoking the generator below, which needs it.
	get_filename_component(PROTOC_PATH "${PROTOC}" DIRECTORY)
	set(GEN_PREFIX "${CMAKE_COMMAND}" -E env "PATH=${PROTOC_PATH}:$ENV{PATH}")
else()
	set(GEN_PREFIX "")
endif()
```

--------------------------------

### Make the chiaki-ng launcher script executable

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

This command sets the executable permission on the chiaki-ng launcher script located in the Chiaki config directory.

```bash
chmod +x "${HOME}/.var/app/io.github.streetpea.Chiaki4deck/config/Chiaki/Chiaki-launcher.sh"
```

--------------------------------

### Add bundled nanopb library with PB_C99_STATIC_ASSERT

Source: https://github.com/streetpea/chiaki-ng/blob/main/third-party/CMakeLists.txt

Adds the bundled nanopb library when CHIAKI_USE_SYSTEM_NANOPB is not set. Defines PB_C99_STATIC_ASSERT to fix PB_STATIC_ASSERT on MSVC without C11, creates an INTERFACE library named nanopb, links protobuf-nanopb-static, and exposes the Nanopb::nanopb alias.

```CMake
if(NOT CHIAKI_USE_SYSTEM_NANOPB)
	##################
	# nanopb
	##################

	add_definitions(-DPB_C99_STATIC_ASSERT) # Fix PB_STATIC_ASSERT on msvc without using C11 for now
	add_subdirectory(nanopb EXCLUDE_FROM_ALL)
	set(NANOPB_GENERATOR_PY "${CMAKE_CURRENT_SOURCE_DIR}/nanopb/generator/nanopb_generator.py" PARENT_SCOPE)
	add_library(nanopb INTERFACE)
	target_link_libraries(nanopb INTERFACE protobuf-nanopb-static)
	target_include_directories(nanopb INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/nanopb")
	target_compile_definitions(nanopb INTERFACE -DPB_C99_STATIC_ASSERT) # see above
	add_library(Nanopb::nanopb ALIAS nanopb)
endif()
```

--------------------------------

### Copy Chiaki configuration file

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/configuration.md

Command to copy the Chiaki flatpak configuration file to the chiaki-ng location. Used when upgrading from the Chiaki flatpak.

```bash
cp ~/.var/app/re.chiaki.Chiaki/config/Chiaki/Chiaki.conf ~/.var/app/io.github.streetpea.Chiaki4deck/config/Chiaki/Chiaki.conf
```

--------------------------------

### Launch Chiaki via flatpak

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/automation.md

Launches Chiaki from the command line to view the console widget and retrieve the PlayStation's IP address.

```bash
flatpak run io.github.streetpea.Chiaki4deck
```

--------------------------------

### Build bundled gf-complete and jerasure libraries

Source: https://github.com/streetpea/chiaki-ng/blob/main/third-party/CMakeLists.txt

Builds bundled gf-complete and jerasure static libraries when CHIAKI_USE_SYSTEM_JERASURE is not set. gf_complete is built from the listed source files with public include directory gf-complete/include; jerasure links against gf_complete and exposes the Jerasure::Jerasure alias. NEON support is not yet implemented.

```CMake
if(NOT CHIAKI_USE_SYSTEM_JERASURE)
	##################
	# gf-complete
	##################

	set(GF_COMPLETE_SOURCE
			gf-complete/src/gf.c
			gf-complete/src/gf_wgen.c
			gf-complete/src/gf_w4.c
			gf-complete/src/gf_w8.c
			gf-complete/src/gf_w16.c
			gf-complete/src/gf_w32.c
			gf-complete/src/gf_w64.c
			gf-complete/src/gf_w128.c
			gf-complete/src/gf_rand.c
			gf-complete/src/gf_general.c
			gf-complete/src/gf_cpu.c)

	# TODO: support NEON

	add_library(gf_complete STATIC ${GF_COMPLETE_SOURCE})
	target_include_directories(gf_complete PUBLIC gf-complete/include)

	##################
	# jerasure
	##################

	set(JERASURE_SOURCE
			jerasure/src/galois.c
			jerasure/src/jerasure.c
			jerasure/src/reed_sol.c
			jerasure/src/cauchy.c
			jerasure/src/liberation.c)

	add_library(jerasure STATIC ${JERASURE_SOURCE})
	target_include_directories(jerasure PUBLIC jerasure/include)
	target_link_libraries(jerasure gf_complete)

	add_library(Jerasure::Jerasure ALIAS jerasure)
endif()
```

--------------------------------

### Download patch file

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Downloads the patch file 0001-vulkan-ignore-frames-without-hw-context.patch.

```bash
curl -LO https://raw.githubusercontent.com/streetpea/chiaki-ng/main/scripts/flatpak/0001-vulkan-ignore-frames-without-hw-context.patch
```

--------------------------------

### List coredumps with coredumpctl

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Run coredumpctl to list all coredumps and find the PID for your application.

```bash
coredumpctl
```

--------------------------------

### Push to Homebrew Netloader

Source: https://github.com/streetpea/chiaki-ng/blob/main/switch/README.md

Pushes the built Chiaki-ng to the Switch's homebrew Netloader. Replace the IP address with your Switch's IP.

```bash
# where X.X.X.X is the IP of your switch
bash scripts/switch/push-podman-build-chiaki.sh -a 192.168.0.200
```

--------------------------------

### Create Debug build

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Commands to configure and compile a Debug build of chiaki-ng.

```bash
mkdir Debug
```

```bash
cd Debug
```

```bash
cmake -DCMAKE_BUILD_TYPE=Debug ..
```

```bash
make
```

--------------------------------

### Steamdeck Native Dependencies and Subdirectory

Source: https://github.com/streetpea/chiaki-ng/blob/main/CMakeLists.txt

Finds HIDAPI and FFTW3 via pkg-config. If found, enables Steamdeck native; otherwise fatal errors for missing dependencies. Adds steamdeck_native subdirectory if enabled.

```cmake
if(CHIAKI_ENABLE_STEAMDECK_NATIVE)
	find_package(HIDAPI QUIET)
	find_package(PkgConfig REQUIRED)
	pkg_search_module(FFTW REQUIRED fftw3 IMPORTED_TARGET)
	if(HIDAPI_FOUND AND FFTW_FOUND)
		set(CHIAKI_ENABLE_STEAMDECK_NATIVE ON)
	else()
		if(NOT CHIAKI_ENABLE_STEAMDECK_NATIVE STREQUAL AUTO)
			if(NOT HIDAPI_FOUND AND NOT FFTW_FOUND)
				message(FATAL_ERROR "
				CHIAKI_ENABLE_STEAMDECK_NATIVE is set to ON, but its dependencies (HIDAPI & FFTW3) could not be resolved.")
			endif()
			if(NOT HIDAPI_FOUND)
				message(FATAL_ERROR "
				CHIAKI_ENABLE_STEAMDECK_NATIVE is set to ON, but its dependency (HIDAPI) could not be resolved.")
			endif()
			if(NOT FFTW_FOUND)
				message(FATAL_ERROR "
				CHIAKI_ENABLE_STEAMDECK_NATIVE is set to ON, but its dependency (FFTW3) could not be resolved.")
			endif()
		endif()
		set(CHIAKI_ENABLE_STEAMDECK_NATIVE OFF)
	endif()
	if(CHIAKI_ENABLE_STEAMDECK_NATIVE)
		add_subdirectory(steamdeck_native)
	endif()
endif()
```

--------------------------------

### Move chiaki-ng configuration files

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/updates/releases.md

Moves the configuration directory from the legacy location to the new Flathub-compliant path.

```bash
mv ~/.var/app/re.chiaki.Chiaki4deck ~/.var/app/io.github.streetpea.Chiaki4deck
```

--------------------------------

### Version and CPack packaging configuration

Source: https://github.com/streetpea/chiaki-ng/blob/main/CMakeLists.txt

Sets the Chiaki version numbers and configures CPack for Debian packaging with package name, description, and version.

```cmake
set(CHIAKI_VERSION_MAJOR 1)
set(CHIAKI_VERSION_MINOR 10)
set(CHIAKI_VERSION_PATCH 0)
set(CHIAKI_VERSION ${CHIAKI_VERSION_MAJOR}.${CHIAKI_VERSION_MINOR}.${CHIAKI_VERSION_PATCH})

set(CPACK_PACKAGE_NAME "chiaki-ng")
set(CPACK_PACKAGE_DESCRIPTION "Open Source PlayStation Remote Play client for Linux, Mac, and Windows")
set(CPACK_PACKAGE_VERSION_MAJOR ${CHIAKI_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${CHIAKI_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${CHIAKI_VERSION_PATCH})
set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
set(CPACK_DEBIAN_PACKAGE_DESCRIPTION ${CPACK_PACKAGE_DESCRIPTION})
set(CPACK_DEBIAN_PACKAGE_SECTION "games")
include(CPack)
```

--------------------------------

### Add Flathub repository

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/buildit.md

Add Flathub as the default flatpak repository if it is not already present.

```bash
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
```

--------------------------------

### Open Add Non-Steam Game prompt via konsole

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/setup/steaming.md

Run this command in a konsole window to bring up the Add Non-Steam Game prompt in Steam.

```bash
steam steam://AddNonSteamGame
```

--------------------------------

### Add GUI Subdirectory

Source: https://github.com/streetpea/chiaki-ng/blob/main/CMakeLists.txt

Adds the gui subdirectory if CHIAKI_ENABLE_GUI is set.

```cmake
if(CHIAKI_ENABLE_GUI)
	add_subdirectory(gui)
endif()
```

--------------------------------

### Executable Creation and Linking

Source: https://github.com/streetpea/chiaki-ng/blob/main/gui/CMakeLists.txt

Defines the executable target and links necessary libraries, including platform-specific dependencies and optional features.

```cmake
add_executable(chiaki WIN32
		${RESOURCE_FILES}
		${SOURCE_FILES}
)
target_include_directories(chiaki PRIVATE include)

add_library(placebo-libav-impl src/libav_impl.c)
target_link_libraries(placebo-libav-impl PkgConfig::LIBPLACEBO FFMPEG::avcodec FFMPEG::avutil FFMPEG::avformat)
target_link_libraries(chiaki PkgConfig::LIBPLACEBO placebo-libav-impl)

target_link_libraries(chiaki chiaki-lib)
if(CHIAKI_ENABLE_CLI)
	add_definitions(-DCHIAKI_ENABLE_CLI)
	target_link_libraries(chiaki chiaki-cli-lib)
endif()

target_link_libraries(chiaki Qt::Core Qt::Gui Qt::GuiPrivate Qt::Concurrent Qt::Svg Qt::Qml Qt::Quick Qt::Widgets)
if (${Qt6DBus_FOUND} AND NOT WIN32)
	target_link_libraries(chiaki Qt::DBus)
if (NOT APPLE)
	target_compile_definitions(chiaki PRIVATE CHIAKI_HAVE_DBUS)
endif()
endif()
if (${Qt6WebEngineQuick_FOUND})
	target_link_libraries(chiaki Qt::WebEngineQuick)
	target_compile_definitions(chiaki PRIVATE CHIAKI_HAVE_WEBENGINE)
endif()
target_link_libraries(chiaki SDL2::SDL2)
if(CHIAKI_ENABLE_SPEEX)
  target_link_libraries(chiaki PkgConfig::SpeexDSP)
  target_compile_definitions(chiaki PRIVATE CHIAKI_GUI_ENABLE_SPEEX)
endif()
if(CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER)
	target_compile_definitions(chiaki PRIVATE CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER)
endif()
if(CHIAKI_ENABLE_SETSU)
	target_link_libraries(chiaki setsu)
	target_compile_definitions(chiaki PRIVATE CHIAKI_GUI_ENABLE_SETSU)
endif()
if(CHIAKI_ENABLE_STEAMDECK_NATIVE)
	target_link_libraries(chiaki sdeck)
	target_compile_definitions(chiaki PRIVATE QT_STATICPLUGIN CHIAKI_GUI_ENABLE_STEAMDECK_NATIVE)
endif()
if(CHIAKI_ENABLE_STEAM_SHORTCUT)
	target_link_libraries(chiaki cpp-steam-tools)
	target_compile_definitions(chiaki PRIVATE CHIAKI_GUI_ENABLE_STEAM_SHORTCUT)
endif()
if(NOT CHIAKI_ENABLE_FFMPEG_DECODER)
	message(FATAL_ERROR "Chiaki GUI requires CHIAKI_ENABLE_FFMPEG_DECODER=ON")
endif()
if(APPLE)
	target_link_libraries(chiaki "-framework AVFoundation" "-framework IOKit")
endif()
```

--------------------------------

### Clone project repository

Source: https://github.com/streetpea/chiaki-ng/blob/main/docs/diy/steamdeckdev.md

Provides different methods to clone the chiaki-ng repository onto the Steam Deck.

```bash
git clone --recurse-submodules https://github.com/streetpea/chiaki-ng.git
```

```bash
git clone --recurse-submodules git@github.com:streetpea/chiaki-ng.git
```

```bash
gh repo clone streetpea/chiaki-ng
```

--------------------------------

### Enable Testing and Add Test Subdirectory

Source: https://github.com/streetpea/chiaki-ng/blob/main/CMakeLists.txt

Enables testing and adds test subdirectory if CHIAKI_ENABLE_TESTS is set.

```cmake
if(CHIAKI_ENABLE_TESTS)
	enable_testing()
	add_subdirectory(test)
endif()
```

--------------------------------

### Add Third-Party Subdirectory

Source: https://github.com/streetpea/chiaki-ng/blob/main/CMakeLists.txt

Adds the third-party subdirectory to the build.

```cmake
add_subdirectory(third-party)
```
Tokens:
Raw