libnx ABI Patcher

setTheme(value)} + onKeyDown={(e) => { + if (e.key === "Enter" || e.key === " ") { + e.preventDefault(); + setTheme(value); + } + }} + className={` + group relative flex items-center justify-between py-4 + cursor-pointer outline-none transition-all duration-200 + border-t border-switch-line-sep ${isLast ? "border-b" : ""} + switch-focus-ring hover:bg-switch-selected-bg/10 + `} + > +

+ {/* Preview Box */} +

+ + {/* Label */} + {label} +

+ + {/* Radio Indicator */} +

+ {isSelected && ( +

+ )} +

+ ); +}; + +export function ThemeSelector() { + const [theme, setTheme] = useState(() => { + const saved = localStorage.getItem("theme") as Theme | null; + return saved || "dark"; + }); + + useEffect(() => { + document.documentElement.setAttribute("data-theme", theme); + localStorage.setItem("theme", theme); + }, [theme]); + + return ( +

+ + +

+ ); +} diff --git a/src/components/ui/Button.tsx b/src/components/ui/Button.tsx new file mode 100644 index 0000000..0b5142f --- /dev/null +++ b/src/components/ui/Button.tsx @@ -0,0 +1,84 @@ +import * as React from "react"; + +export interface ButtonProps + extends React.ButtonHTMLAttributes { + variant?: "primary" | "secondary" | "ghost" | "outline"; + size?: "sm" | "md" | "lg" | "icon"; + isLoading?: boolean; +} + +export const Button = React.forwardRef( + ( + { + className = "", + variant = "primary", + size = "md", + isLoading, + children, + disabled, + ...props + }, + ref, + ) => { + // Removed font-bold, added font-normal + const baseStyles = + "inline-flex items-center justify-center font-normal transition-all duration-150 focus-visible:outline-none disabled:opacity-50 disabled:cursor-not-allowed disabled:transform-none rounded-[2px]"; + + const variants = { + primary: + "bg-switch-text-selected text-switch-bg hover:brightness-110 active:scale-95 switch-focus-ring", + secondary: + "bg-switch-selected-bg text-switch-text border border-switch-line-sep hover:border-switch-highlight-1 active:scale-95 switch-focus-ring", + ghost: "bg-transparent text-switch-text hover:text-switch-text-selected", + outline: + "bg-transparent border border-switch-line-sep text-switch-text hover:border-switch-highlight-1", + }; + + const sizes = { + sm: "px-3 py-1.5 text-sm", + md: "px-4 py-2 text-base", + lg: "px-8 py-3 text-lg", + icon: "h-10 w-10", + }; + + return ( + + ); + }, +); + +Button.displayName = "Button"; diff --git a/src/components/ui/Card.tsx b/src/components/ui/Card.tsx new file mode 100644 index 0000000..1738daa --- /dev/null +++ b/src/components/ui/Card.tsx @@ -0,0 +1,45 @@ +import * as React from "react"; + +export const Card = React.forwardRef< + HTMLDivElement, + React.HTMLAttributes +>(({ className = "", ...props }, ref) => ( +

+)); +Card.displayName = "Card"; + +export const CardHeader = React.forwardRef< + HTMLDivElement, + React.HTMLAttributes +>(({ className = "", ...props }, ref) => ( +

+)); +CardHeader.displayName = "CardHeader"; + +export const CardTitle = React.forwardRef< + HTMLHeadingElement, + React.HTMLAttributes +>(({ className = "", ...props }, ref) => ( +

+)); +CardTitle.displayName = "CardTitle"; + +export const CardContent = React.forwardRef< + HTMLDivElement, + React.HTMLAttributes +>(({ className = "", ...props }, ref) => ( +
+)); +CardContent.displayName = "CardContent"; diff --git a/src/components/ui/SectionHeader.tsx b/src/components/ui/SectionHeader.tsx new file mode 100644 index 0000000..e6f9560 --- /dev/null +++ b/src/components/ui/SectionHeader.tsx @@ -0,0 +1,22 @@ +import React from "react"; + +interface SectionHeaderProps { + children: React.ReactNode; + className?: string; +} + +export function SectionHeader({ + children, + className = "", +}: SectionHeaderProps) { + return ( +
+ {children} +
+ ); +} diff --git a/src/components/ui/Switch.tsx b/src/components/ui/Switch.tsx new file mode 100644 index 0000000..e15b4e8 --- /dev/null +++ b/src/components/ui/Switch.tsx @@ -0,0 +1,43 @@ +import * as React from "react"; + +export interface SwitchProps + extends React.InputHTMLAttributes { + onCheckedChange?: (checked: boolean) => void; +} + +export const Switch = React.forwardRef( + ({ className = "", onCheckedChange, onChange, ...props }, ref) => { + const handleChange = (e: React.ChangeEvent) => { + onCheckedChange?.(e.target.checked); + onChange?.(e); + }; + + return ( + + +
+ + ); + }, +); +Switch.displayName = "Switch"; diff --git a/src/index.css b/src/index.css new file mode 100644 index 0000000..f3afd8c --- /dev/null +++ b/src/index.css @@ -0,0 +1,142 @@ +@import "tailwindcss"; + +@import "@fontsource/open-sans/400.css"; +@import "@fontsource/open-sans/600.css"; +@import "@fontsource/open-sans/700.css"; + +@theme { + --color-switch-bg: var(--switch-bg); + --color-switch-popup: var(--switch-popup); + --color-switch-error: var(--switch-error); + --color-switch-focus: var(--switch-focus); + --color-switch-text: var(--switch-text); + --color-switch-text-info: var(--switch-text-info); + --color-switch-text-selected: var(--switch-text-selected); + --color-switch-selected-bg: var(--switch-selected-bg); + --color-switch-sidebar: var(--switch-sidebar); + --color-switch-line: var(--switch-line); + --color-switch-line-sep: var(--switch-line-sep); + --color-switch-highlight-1: var(--switch-highlight-1); + --color-switch-highlight-2: var(--switch-highlight-2); + --color-switch-hover-bg: var(--switch-hover-bg); +} + +@layer base { + :root { + font-family: "Open Sans", system-ui, sans-serif; + } + + /* Dark Theme (default) / + :root, + [data-theme="dark"] { + --switch-bg: #2d2d2d; + --switch-popup: #3a3b3c; + --switch-error: #fa5a3a; + --switch-focus: rgba(0, 0, 0, 0.7); + --switch-text: #ffffff; + --switch-text-info: #a0a0a0; + --switch-text-selected: #00ffc8; + --switch-selected-bg: #202227; + --switch-sidebar: #323232; + --switch-sidebar-focus: #212227; + --switch-line: #ffffff; + --switch-line-sep: #707070; + --switch-highlight-1: #1989c6; + --switch-highlight-2: #89f0f2; + --switch-hover-bg: #00ffc810; + + --switch-scrollbar: #00ffc8; + --switch-scrollbar-bg: transparent; + --switch-progressbar: #00ffc8; + --switch-progressbar-bg: #464646; + } + + / Light Theme / + [data-theme="light"] { + --switch-bg: #ebebeb; + --switch-popup: #f0f0f0; + --switch-error: #fa5a3a; + --switch-focus: rgba(211, 211, 211, 0.63); + --switch-text: #2b2b2b; + --switch-text-info: #707070; + --switch-text-selected: #3250f0; + --switch-selected-bg: #fcfcfc; + --switch-sidebar: #f0f0f0; + --switch-sidebar-focus: #fdfdfd; + --switch-line: #2b2b2b; + --switch-line-sep: #6d787a; + --switch-highlight-1: #1989c6; + --switch-highlight-2: #4ff4d7; + --switch-hover-bg: #3250f010; + + --switch-scrollbar: #b0b0b0; + --switch-scrollbar-bg: transparent; + --switch-progressbar: #3250f0; + --switch-progressbar-bg: #808080; + } + + body { + margin: 0; + min-height: 100vh; + background-color: var(--color-switch-selected-bg); + color: var(--switch-text); + transition: + background-color 0.3s, + color 0.3s; + } + + / Custom Scrollbar / + ::-webkit-scrollbar { + width: 8px; + height: 8px; + } + + ::-webkit-scrollbar-track { + background: var(--switch-scrollbar-bg); + } + + ::-webkit-scrollbar-thumb { + background: var(--switch-scrollbar); + border-radius: 4px; + } + + @keyframes pulse-focus { + 0% { + outline-color: var(--switch-highlight-1); + } + 50% { + outline-color: var(--switch-highlight-2); + } + 100% { + outline-color: var(--switch-highlight-1); + } + } + + .sidebar-shadow { + box-shadow: + 0 50px 50px -50px var(--color-switch-bg) inset, + 0 -50px 50px -50px var(--color-switch-bg) inset; + } + + .switch-focus-ring:focus, + .switch-focus-within:focus-within { + outline: 3px solid var(--switch-highlight-1); + outline-offset: 0px; + animation: pulse-focus 850ms infinite; + } + + .tab-border-selected::after { + content: ""; + position: absolute; + top: 5px; + bottom: 5px; + left: 5px; + width: 3px; + background-color: var(--switch-text-selected); + } + + a { + color: var(--switch-text-selected); + text-decoration: underline; + } +} diff --git a/src/main.tsx b/src/main.tsx new file mode 100644 index 0000000..eff7ccc --- /dev/null +++ b/src/main.tsx @@ -0,0 +1,10 @@ +import { StrictMode } from "react"; +import { createRoot } from "react-dom/client"; +import "./index.css"; +import App from "./App.tsx"; + +createRoot(document.getElementById("root")!).render( + + + , +); diff --git a/src/pages/AboutPage.tsx b/src/pages/AboutPage.tsx new file mode 100644 index 0000000..03be4dc --- /dev/null +++ b/src/pages/AboutPage.tsx @@ -0,0 +1,174 @@ +import { Card, CardContent } from "../components/ui/Card"; + +const GITHUB_URL = "https://github.com/alula/hbpatcher"; + +export function AboutPage() { + return ( +
+
+ + +
Disclaimer
+
+ This tool may or may not work correctly. It is not the + responsibility of the author of this tool or the author of the + homebrew. Users should obtain the latest version of homebrew + recompiled against the latest libnx if possible over using this + tool. This tool is only an assist for unmaintained homebrew to + reduce the impact of kernel changes. +
+ + + + +
Instructions
+
+
+ Drag and drop your homebrew{" "} + .nro file + into the patcher tab. +
+
+ The tool will analyze the file to see if it uses the old ABI. +
+
If patching is needed, click the "Patch File" button.
+
The patched file will be downloaded automatically.
+
Copy the patched file to your Switch SD card.
+
+ + + + +
For Developers
+
+ Do not rely on this tool. Please recompile your homebrew with{" "} + `libnx v4.10.0` (or newer). +
+
+
+ The updated library resolves the memory conflict and stays + backward compatible with older Atmosphère versions and + firmwares. +
+
+ You can find the source code for this tool on{" "} + + GitHub + + . +
+
+ + +
+
+
TL;DR
+
+ Atmosphère 1.10.0+ integrates kernel optimizations from Firmware + 21.0.0. This improves performance but breaks older homebrew, + causing crashes or hangs on exit. If your homebrew is + unmaintained, use this tool to patch the `.nro` files. + If the app is still active, ask the developer to update it. +
+
+ +
+
+ How this tool works +
+
+ This tool scans your `.nro` files to see if they rely + on the old, now-unsafe memory layout. If it detects a conflict, it + modifies the binary to{" "} + + move its Thread Local Storage (TLS) + {" "} + from offset `0x108` to the safe offset{" "} + `0x180`. Effectively, it mimics the result of + recompiling the app with the latest libraries, restoring stability + without needing the source code. +
+
+ +
+
+ Why isn't this built into the Homebrew Loader? +
+
+
+ It might seem logical for the Homebrew Loader (`hbl`) + to handle this automatically, but that's out of scope for a + simple program loader. HBL’s job is to execute code as-is, not + to dynamically repair binaries. +
+
+ Trying to patch memory offsets on the fly is invasive and + fragile; if HBL guesses wrong, it could corrupt the entire + homebrew environment. Furthermore, baking a patcher into the + loader sets a bad precedent. The maintainers want to encourage + proper fixes (recompilation) rather than relying on permanent + "dirty hacks" within the OS itself.{" "} + + Source: Switchbrew + +
+
+
+ +
+
+ Why the breakage happened +
+
+
+ This isn't a bug; it's a conflict over real estate. In Firmware + 21.0.0, Nintendo optimized the kernel to write CPU timing data + to a specific memory address (`usertls + 0x108`) on + every thread switch. +
+
+ Previous versions of `libnx` (the homebrew library) + assumed this space was unused and stored data there. Official + software always respected the reservation, so it wasn't + affected. Now that the kernel—and by extension, + Atmosphère—actively uses that space, old homebrew gets its + memory overwritten, leading to immediate crashes. +
+
+
+ +
+
+ Why Atmosphère didn't add a workaround +
+
+
+ Atmosphère aims to reimplement Nintendo's kernel logic 1:1. When + Nintendo changes how the kernel works, Atmosphère must follow + suit to ensure official games run correctly. +
+
+ While the developers have added quiet workarounds in the past + (like the FW 19.0.0 debug flags), this specific issue was too + risky to mask. A workaround here would require adding + conditional logic to the kernel scheduler—the most time-critical + part of the system. Adding checks for "broken homebrew" during + every thread switch would add complexity, potentially degrade + performance system-wide, and could even introduce bugs in + official games. +
+
+
+
+
+
+ ); +} diff --git a/src/pages/PatcherPage.tsx b/src/pages/PatcherPage.tsx new file mode 100644 index 0000000..10c417c --- /dev/null +++ b/src/pages/PatcherPage.tsx @@ -0,0 +1,144 @@ +import { useState } from "react"; +import { FileDropZone } from "../components/FileDropZone"; +import { FileStatusDisplay } from "../components/FileStatusDisplay"; +import { Button } from "../components/ui/Button"; +import { Card } from "../components/ui/Card"; +import { LogViewer } from "../components/LogViewer"; +import { analyzeFile, patchFile } from "../patcher/NROPatcher"; +import type { AnalysisResult, PatchResult } from "../types"; +import { formatMessage } from "../utils/localization"; +import { Check } from "lucide-react"; + +interface PatcherPageProps { + appendSuffix: boolean; +} + +export function PatcherPage({ appendSuffix }: PatcherPageProps) { + const [currentFile, setCurrentFile] = useState(null); + const [analysis, setAnalysis] = useState(null); + const [patchResult, setPatchResult] = useState(null); + const [isPatching, setIsPatching] = useState(false); + const [patchError, setPatchError] = useState(null); + const [log, setLog] = useState([]); + + const handleFileSelected = async (file: File) => { + setCurrentFile(file); + setPatchResult(null); + setPatchError(null); + setLog([]); + + try { + const result = await analyzeFile(file); + setAnalysis(result); + setLog(result.log); + } catch { + setAnalysis({ + state: "invalid", + fileName: file.name, + messageKey: "error_analysis_failed", + log: [], + } as AnalysisResult); + setLog([]); + } + }; + + const handlePatchClick = async () => { + if (!currentFile) return; + + setIsPatching(true); + setPatchError(null); + + try { + const result = await patchFile(currentFile); + setPatchResult(result); + setLog(result.log); + + if (result.success && result.patchedData) { + // Create Blob from Uint8Array for download + const blob = new Blob([result.patchedData as unknown as BlobPart], { + type: "application/octet-stream", + }); + const url = URL.createObjectURL(blob); + const a = document.createElement("a"); + a.href = url; + + let downloadName = currentFile.name; + if (appendSuffix) { + downloadName = downloadName.replace(/\.nro$/i, "_patched.nro"); + if (downloadName === currentFile.name) downloadName += "_patched.nro"; + } + + a.download = downloadName; + document.body.appendChild(a); + a.click(); + document.body.removeChild(a); + URL.revokeObjectURL(url); + } else if (!result.success) { + setPatchError( + formatMessage(result.errorKey || "error_unknown", result.errorParams), + ); + } + } catch (err) { + const errorMessage = + err instanceof Error ? err.message : "Unknown error occurred"; + setPatchError(formatMessage("error_unknown", { message: errorMessage })); + setPatchResult({ + success: false, + errorKey: "error_unknown", + errorParams: { message: errorMessage }, + log: [], + }); + } finally { + setIsPatching(false); + } + }; + + return ( +
+
+ + + {analysis && ( +
+ +
+ )} + + {patchError && ( + +
Error: {patchError}
+ + )} + + {analysis && analysis.state === "needs-patching" && currentFile && ( +
+ +
+ )} + + {patchResult && patchResult.success && ( + +
+ +
+
+ Success! +
+
File patched and downloaded.
+
+
+ + )} + + +
+
+ ); +} diff --git a/src/pages/SettingsPage.tsx b/src/pages/SettingsPage.tsx new file mode 100644 index 0000000..0d8066b --- /dev/null +++ b/src/pages/SettingsPage.tsx @@ -0,0 +1,57 @@ +import { ThemeSelector } from "../components/ThemeSelector"; +import { SectionHeader } from "../components/ui/SectionHeader"; +import { Switch } from "../components/ui/Switch"; + +interface SettingsPageProps { + appendSuffix: boolean; + onAppendSuffixChange: (value: boolean) => void; +} + +interface SettingsRowProps { + title: string; + description?: string; + children: React.ReactNode; +} + +function SettingsRow({ title, description, children }: SettingsRowProps) { + return ( +
+
+
{title}
+
+ {children} +
+
+ {description && ( +
{description}
+ )} +
+ ); +} + +export function SettingsPage({ + appendSuffix, + onAppendSuffixChange, +}: SettingsPageProps) { + return ( +
+
+
+ Themes + +
+ + Miscellaneous + + + +
+
+ ); +} diff --git a/src/patcher/BinaryReader.ts b/src/patcher/BinaryReader.ts new file mode 100644 index 0000000..e44a6f3 --- /dev/null +++ b/src/patcher/BinaryReader.ts @@ -0,0 +1,72 @@ +export class BinaryReader { + private view: DataView; + private offset: number = 0; + + constructor(buffer: ArrayBuffer | Uint8Array) { + if (buffer instanceof Uint8Array) { + this.view = new DataView( + buffer.buffer, + buffer.byteOffset, + buffer.byteLength, + ); + } else { + this.view = new DataView(buffer); + } + } + + seek(offset: number) { + this.offset = offset; + } + + skip(count: number) { + this.offset += count; + } + + tell(): number { + return this.offset; + } + + readU8(): number { + const val = this.view.getUint8(this.offset); + this.offset += 1; + return val; + } + + readU16(): number { + const val = this.view.getUint16(this.offset, true); // Little Endian + this.offset += 2; + return val; + } + + readU32(): number { + const val = this.view.getUint32(this.offset, true); + this.offset += 4; + return val; + } + + readU64(): bigint { + const val = this.view.getBigUint64(this.offset, true); + this.offset += 8; + return val; + } + + readBytes(length: number): Uint8Array { + const bytes = new Uint8Array( + this.view.buffer, + this.view.byteOffset + this.offset, + length, + ); + this.offset += length; + // Return a copy to avoid issues if the underlying buffer changes or if we want to modify it + return new Uint8Array(bytes); + } + + readString(length: number): string { + const bytes = this.readBytes(length); + const decoder = new TextDecoder(); + // Remove null termination if present + let end = 0; + while (end < bytes.length && bytes[end] !== 0) end++; + return decoder.decode(bytes.subarray(0, end)); + } +} diff --git a/src/patcher/NRO.ts b/src/patcher/NRO.ts new file mode 100644 index 0000000..82fe2e0 --- /dev/null +++ b/src/patcher/NRO.ts @@ -0,0 +1,193 @@ +import { BinaryReader } from "./BinaryReader"; + +export interface NroSection { + offset: number; + size: number; +} + +export interface NroHeader { + magic: string; + version: number; + size: number; + flags: number; + text: NroSection; + rodata: NroSection; + data: NroSection; + bssSize: number; + moduleId: Uint8Array; +} + +export interface Mod0Header { + magic: string; + dynamicOffset: number; + bssStartOffset: number; + bssEndOffset: number; + ehFrameHdrStartOffset: number; + ehFrameHdrEndOffset: number; + runtimeModuleObjectOffset: number; + // Homebrew extensions + lny0Offset?: number; // Offset to LNY0 magic relative to MOD0 start + lny1Offset?: number; // Offset to LNY1 magic relative to MOD0 start + lny2Offset?: number; // Offset to LNY2 magic relative to MOD0 start + lny2Version?: number; // Version of LNY2 + hbpAOffset?: number; // Offset to hbpA magic relative to MOD0 start +} + +export class NRO { + public header: NroHeader; + public mod0?: Mod0Header; + public mod0Offset: number = 0; + private buffer: Uint8Array; + + constructor(buffer: Uint8Array) { + this.buffer = buffer; + this.header = this.parseHeader(); + this.parseMod0(); + } + + private parseHeader(): NroHeader { + const reader = new BinaryReader(this.buffer); + + // Check magic at 0x10 + reader.seek(0x10); + const magic = reader.readString(4); + if (magic !== "NRO0") { + throw new Error("Invalid NRO magic"); + } + + const version = reader.readU32(); + const size = reader.readU32(); + const flags = reader.readU32(); + + const text = { + offset: reader.readU32(), + size: reader.readU32(), + }; + + const rodata = { + offset: reader.readU32(), + size: reader.readU32(), + }; + + const data = { + offset: reader.readU32(), + size: reader.readU32(), + }; + + const bssSize = reader.readU32(); + / const reserved =*/ reader.readU32(); + + const moduleId = reader.readBytes(0x20); + + return { + magic, + version, + size, + flags, + text, + rodata, + data, + bssSize, + moduleId, + }; + } + + private parseMod0() { + // MOD0 is usually at the start of .text + 4 (after the branch instruction) + // But we should scan for it in the first few bytes of .text just in case + const textStart = this.header.text.offset; + const reader = new BinaryReader(this.buffer); + + // Look for MOD0 magic in the first 0x20 bytes of text section + // Standard crt0 has it at offset 4 from start of text + let mod0Found = false; + let mod0Offset = 0; + + for (let i = 0; i < 0x20; i += 4) { + reader.seek(textStart + i); + const magic = reader.readString(4); + if (magic === "MOD0") { + mod0Found = true; + mod0Offset = textStart + i; + break; + } + } + + if (!mod0Found) return; + + this.mod0Offset = mod0Offset; + reader.seek(mod0Offset + 4); // Skip magic + + const dynamicOffset = reader.readU32(); + const bssStartOffset = reader.readU32(); + const bssEndOffset = reader.readU32(); + const ehFrameHdrStartOffset = reader.readU32(); + const ehFrameHdrEndOffset = reader.readU32(); + const runtimeModuleObjectOffset = reader.readU32(); + + const mod0: Mod0Header = { + magic: "MOD0", + dynamicOffset, + bssStartOffset, + bssEndOffset, + ehFrameHdrStartOffset, + ehFrameHdrEndOffset, + runtimeModuleObjectOffset, + }; + + // Check for LNY0 + const lny0Magic = reader.readString(4); + if (lny0Magic === "LNY0") { + mod0.lny0Offset = reader.tell() - 4 - mod0Offset; + reader.skip(8); // got_start, got_end + + // Check for LNY1 + const lny1Magic = reader.readString(4); + if (lny1Magic === "LNY1") { + mod0.lny1Offset = reader.tell() - 4 - mod0Offset; + reader.skip(8); // relro_start, data_start + + // Check for LNY2 + const lny2Magic = reader.readString(4); + if (lny2Magic === "LNY2") { + mod0.lny2Offset = reader.tell() - 4 - mod0Offset; + mod0.lny2Version = reader.readU32(); + reader.skip(4); // Reserved + + // Check for hbpA (Homebrew Patcher Applied) + const hbpAMagic = reader.readString(4); + if (hbpAMagic === "hbpA") { + mod0.hbpAOffset = reader.tell() - 4 - mod0Offset; + } + } + } + } + + this.mod0 = mod0; + } + + get text(): Uint8Array { + return this.buffer.subarray( + this.header.text.offset, + this.header.text.offset + this.header.text.size, + ); + } + + get rodata(): Uint8Array { + return this.buffer.subarray( + this.header.rodata.offset, + this.header.rodata.offset + this.header.rodata.size, + ); + } + + get data(): Uint8Array { + return this.buffer.subarray( + this.header.data.offset, + this.header.data.offset + this.header.data.size, + ); + } + + get fullBuffer(): Uint8Array { + return this.buffer; + } +} diff --git a/src/patcher/NROPatcher.ts b/src/patcher/NROPatcher.ts new file mode 100644 index 0000000..c2915b0 --- /dev/null +++ b/src/patcher/NROPatcher.ts @@ -0,0 +1,120 @@ +import { NRO } from "./NRO"; +import type { AnalysisResult, PatchResult } from "../types"; +import { PatchContext, PATCHES } from "./patches"; + +/** + * Analyzes an NRO file to determine its state. + */ +export async function analyzeFile(file: File): Promise { + let nro: NRO; + + try { + const buffer = new Uint8Array(await file.arrayBuffer()); + nro = new NRO(buffer); + } catch (error) { + console.error("Error parsing NRO:", error); + return { + state: "invalid", + fileName: file.name, + messageKey: "status_invalid_nro", + log: [], + }; + } + const context = new PatchContext(nro); + + // Check for any pattern that needs patching + let needsPatching = false; + for (const patch of PATCHES) { + context._onPatchStart(patch); + if (patch.check(context)) { + needsPatching = true; + } + context._onPatchEnd(); + } + + if (needsPatching) { + return { + state: "needs-patching", + fileName: file.name, + messageKey: "status_needs_patching", + log: context.errorLog, + }; + } + + // If we are here, no patterns matched, meaning it's compatible. + // Now we check if it was patched by THIS tool (hbpA marker) or if it's just compatible (recompiled). + + if (nro.mod0 && nro.mod0.hbpAOffset) { + return { + state: "patched", + fileName: file.name, + messageKey: "status_already_patched", + log: context.errorLog, + }; + } + + if (!nro.mod0?.lny2Offset) { + return { + state: "new-abi", + fileName: file.name, + messageKey: "status_no_pattern", + log: context.errorLog, + }; + } + + return { + state: "new-abi", + fileName: file.name, + messageKey: "status_new_abi", + log: context.errorLog, + }; +} + +/** + * Patches an NRO file to use the new ABI. + */ +export async function patchFile(file: File): Promise { + let log: string[] = []; + try { + const buffer = new Uint8Array(await file.arrayBuffer()); + const nro = new NRO(buffer); + const context = new PatchContext(nro); + log = context.errorLog; + + for (const patch of PATCHES) { + context._onPatchStart(patch); + if (patch.check(context)) { + const success = patch.apply(context); + if (success) { + context.appliedPatches.add(patch.id); + } + } + context._onPatchEnd(); + } + + if (context.appliedPatches.size === 0) { + return { + success: false, + errorKey: "error_pattern_not_found", + log, + }; + } + + // Return the modified buffer directly + return { + success: true, + patchedData: buffer, + log, + }; + } catch (error) { + console.error("Error patching file:", error); + return { + success: false, + errorKey: "error_unknown", + errorParams: { + message: error instanceof Error ? error.message : String(error), + }, + log, + }; + } +} diff --git a/src/patcher/patches.ts b/src/patcher/patches.ts new file mode 100644 index 0000000..50e9917 --- /dev/null +++ b/src/patcher/patches.ts @@ -0,0 +1,286 @@ +import { NRO } from "./NRO"; +import { nhex, PatternMatcher, type Pattern } from "./utils"; + +export class PatchContext { + appliedPatches = new Set(); + nro: NRO; + errorLog: string[] = []; + _currentPatch: Patch | null = null; + + constructor(nro: NRO) { + this.nro = nro; + } + + // track current patch + _onPatchStart(patch: Patch) { + this._currentPatch = patch; + } + + _onPatchEnd() { + this._currentPatch = null; + } + + log(message: string) { + if (this._currentPatch) { + this.errorLog.push(`${this._currentPatch.id}: ${message}`); + } else { + this.errorLog.push(`${message}`); + } + } +} + +export abstract class Patch { + abstract readonly id: string; + + abstract check(context: PatchContext): boolean; + + // When this is called, the patch can safely assume that check() was called and returned true. + abstract apply(context: PatchContext): boolean; +} + +export class LegacyAbiPatch extends Patch { + readonly id = "pattern_legacy_abi"; + + private readonly threadTlsGetOrig = PatternMatcher.parse( + "61 D0 3B D5 " + // mrs x1, TPIDRRO_EL0; + "20 CC 20 8B " + // add x0, x1, w0,sxtw#3; + "00 84 40 F9 " + // ldr x0, [x0,#0x108]; + "C0 03 5F D6", // ret + ); + + private readonly threadTlsGetPatch = PatternMatcher.parse( + "61 D0 3B D5 " + // mrs x1, TPIDRRO_EL0; + "20 CC 20 8B " + // add x0, x1, w0,sxtw#3; + "00 C0 40 F9 " + // ldr x0, [x0,#0x180]; + "C0 03 5F D6", // ret + ); + + private readonly threadTlsSetOrig = PatternMatcher.parse( + "62 D0 3B D5 " + // mrs x2, TPIDRRO_EL0; + "40 CC 20 8B " + // add x0, x2, w0,sxtw#3; + "01 84 00 F9 " + // str x1, [x0,#0x108]; + "C0 03 5F D6", // ret + ); + + private readonly threadTlsSetPatch = PatternMatcher.parse( + "62 D0 3B D5 " + // mrs x2, TPIDRRO_EL0; + "40 CC 20 8B " + // add x0, x2, w0,sxtw#3; + "01 C0 00 F9 " + // str x1, [x0,#0x180]; + "C0 03 5F D6", // ret + ); + + // all of this needs somewhat complex disassembly to patch reliably + // though those stupid patches should work in most cases + private readonly threadEntryOrigGCC15O2 = PatternMatcher.parse( + "01 0C 40 F9 " + // ldr x1, [x0, #24] + "A1 FA 00 F9 " + // str x1, [x21, #496] + "01 00 00 90 " + // adrp x1, 0 + "A3 F6 00 F9 " + // str x3, [x21, #488] + "B5 22 04 91 " + // add x21, x21, #0x108 + "21 00 40 F9 ", // ldr x1, [x1] + ); + private readonly threadEntryPatchGCC15O2 = PatternMatcher.parse( + "01 0C 40 F9 " + // ldr x1, [x0, #24] + "A1 FA 00 F9 " + // str x1, [x21, #496] + "01 00 00 90 " + // adrp x1, 0 + "A3 F6 00 F9 " + // str x3, [x21, #488] + "B5 02 06 91 " + // add x21, x21, #0x180 + "21 00 40 F9 ", // ldr x1, [x1] + ); + private readonly threadEntryOrigGCC14O2 = PatternMatcher.parse( + "75 D0 3B D5 " + // mrs x21, tpidrro_el0 + "64 8A 41 A9 " + // ldp x4, x2, [x19, #24] + "A1 82 07 91 " + // add x1, x21, #0x1e0 + "A5 E6 01 B9 " + // str w5, [x21, #484] + "B5 22 04 91", // add x21, x21, #0x108 + ); + private readonly threadEntryPatchGCC14O2 = PatternMatcher.parse( + "75 D0 3B D5 " + // mrs x21, tpidrro_el0 + "64 8A 41 A9 " + // ldp x4, x2, [x19, #24] + "A1 82 07 91 " + // add x1, x21, #0x1e0 + "A5 E6 01 B9 " + // str w5, [x21, #484] + "B5 02 06 91", // add x21, x21, #0x180 + ); + // this pattern seems consistent back to GCC 9? + private readonly threadEntryOrigGCC13 = PatternMatcher.parse( + "75 D0 3B D5 " + // mrs x21, tpidrro_el0 + "A2 E2 01 B9 " + // str w2, [x21, #480] + "A5 E6 01 B9 " + // str w5, [x21, #484] + "A3 92 1E A9 " + // stp x3, x4, [x21, #488] + "B5 22 04 91 ", // add x21, x21, #0x108 + ); + private readonly threadEntryPatchGCC13 = PatternMatcher.parse( + "75 D0 3B D5 " + // mrs x21, tpidrro_el0 + "A2 E2 01 B9 " + // str w2, [x21, #480] + "A5 E6 01 B9 " + // str w5, [x21, #484] + "A3 92 1E A9 " + // stp x3, x4, [x21, #488] + "B5 02 06 91", // add x21, x21, #0x180 + ); + + // this seems consistent at -O1 level and below + private readonly threadEntryOrigGCC15O1 = PatternMatcher.parse( + "60 02 40 F9 " + // ldr x0, [x19] + "B5 22 04 91 " + // add x21, x21, #0x108 + "15 10 00 F9 " + // str x21, [x0, #32] + "60 02 40 F9 " + // ldr x0, [x19] + "81 22 00 91 " + // add x1, x20, #0x8 + "01 18 00 F9 " + // str x1, [x0, #48] + "61 02 40 F9 " + // ldr x1, [x19] + "80 06 40 F9 " + // ldr x0, [x20, #8] + "20 14 00 F9 ", // str x0, [x1, #40] + ); + private readonly threadEntryPatchGCC15O1 = PatternMatcher.parse( + "60 02 40 F9 " + // ldr x0, [x19] + "B5 02 06 91 " + // add x21, x21, #0x180 + "15 10 00 F9 " + // str x21, [x0, #32] + "60 02 40 F9 " + // ldr x0, [x19] + "81 22 00 91 " + // add x1, x20, #0x8 + "01 18 00 F9 " + // str x1, [x0, #48] + "61 02 40 F9 " + // ldr x1, [x19] + "80 06 40 F9 " + // ldr x0, [x20, #8] + "20 14 00 F9", // str x0, [x1, #40] + ); + private readonly threadEntryOrigLibNx1 = PatternMatcher.parse( + "84 E2 01 B9 " + // str w4, [x20, #0x1e0] + "64 0E 40 F9 " + // ldr x4, [x19, #0x18] + "83 F6 00 F9 " + // str x3, [x20, #0x1e8] + "63 00 40 B9 " + // ldr w3, [x3] + "42 40 00 D1 " + // sub x2, x2, #0x10 + "84 0A 1F A9 " + // stp x4, x2, [x20, #0x1f0] + "94 22 04 91 " + // add x20, x20, #0x108 + "83 DE 00 B9", // str w3, [x20, #0xdc] + ); + + private readonly threadEntryPatchLibNx1 = PatternMatcher.parse( + "84 E2 01 B9 " + // str w4, [x20, #0x1e0] + "64 0E 40 F9 " + // ldr x4, [x19, #0x18] + "83 F6 00 F9 " + // str x3, [x20, #0x1e8] + "63 00 40 B9 " + // ldr w3, [x3] + "42 40 00 D1 " + // sub x2, x2, #0x10 + "84 0A 1F A9 " + // stp x4, x2, [x20, #0x1f0] + "94 02 06 91 " + // add x20, x20, #0x180 + "83 DE 00 B9", // str w3, [x20, #0xdc] + ); + + private readonly threadEntryOrigLibNx2 = PatternMatcher.parse( + "02 02 80 d2 " + // movz x2, #0x10 + "f3 53 01 a9 " + // stp x19, x20, [sp, #0x10] + "f3 03 00 aa " + // mov x19, x0 + "74 d0 3b d5 " + // mrs x20, tpidrro_el0 + "94 22 04 91 " + // add x20, x20, #0x108 + "03 00 40 f9 " + // ldr x3, [x0] + "f5 13 00 f9 " + // str x21, [sp, #0x20] + "81 da 00 b9 " + // str w1, [x20, #0xd8] + "01 0c 40 f9 " + // ldr x1, [x0, #0x18] + "83 72 00 f9 " + // str x3, [x20, #0xe0] + "81 76 00 f9 " + // str x1, [x20, #0xe8] + "?? ?? ?? ?? " + + "?? ?? ?? ?? " + + "21 00 40 f9 " + // ldr x1, [x1] + "3f 40 00 f1 " + // cmp x1, #0x10 + "21 20 82 9a " + // csel x1, x1, x2, hs + "02 10 40 f9 " + // ldr x2, [x0, #0x20] + "?? ?? ?? ?? " + + "?? ?? ?? ?? " + + "41 00 01 cb " + // sub x1, x2, x1 + "81 7a 00 f9 " + // str x1, [x20, #0xf0] + "61 00 40 b9 " + // ldr w1, [x3] + "81 de 00 b9 ", // str w1, [x20, #0xdc] + ); + private readonly threadEntryPatchLibNx2 = PatternMatcher.parse( + "02 02 80 d2 " + //movz x2, #0x10 + "f3 53 01 a9 " + // stp x19, x20, [sp, #0x10] + "f3 03 00 aa " + // mov x19, x0 + "74 d0 3b d5 " + // mrs x20, tpidrro_el0 + "94 02 06 91 " + // add x20, x20, #0x108+0x78 + "03 00 40 f9 " + // ldr x3, [x0] + "f5 13 00 f9 " + // str x21, [sp, #0x20] + "81 62 00 b9 " + // str w1, [x20, #0xd8-0x78] + "01 0c 40 f9 " + // ldr x1, [x0, #0x18] + "83 36 00 f9 " + // str x3, [x20, #0xe0-0x78] + "81 3a 00 f9 " + // str x1, [x20, #0xe8-0x78] + "?? ?? ?? ?? " + + "?? ?? ?? ?? " + + "21 00 40 f9 " + // ldr x1, [x1] + "3f 40 00 f1 " + // cmp x1, #0x10 + "21 20 82 9a " + // csel x1, x1, x2, hs + "02 10 40 f9 " + // ldr x2, [x0, #0x20] + "?? ?? ?? ?? " + + "?? ?? ?? ?? " + + "41 00 01 cb " + // sub x1, x2, x1 + "81 3e 00 f9 " + // str x1, [x20, #0xf0-0x78] + "61 00 40 b9 " + // ldr w1, [x3] + "81 66 00 b9 ", // str w1, [x20, #0xdc-0x78] + ); + + private readonly patchesOrig = [ + this.threadTlsGetOrig, + this.threadTlsSetOrig, + this.threadEntryOrigGCC15O2, + this.threadEntryOrigGCC14O2, + this.threadEntryOrigGCC13, + this.threadEntryOrigGCC15O1, + this.threadEntryOrigLibNx1, + this.threadEntryOrigLibNx2, + ]; + + // prettier-ignore + private readonly patchesPatch: Array<{o: Pattern, p: Pattern, cmt: string}> = [ + {o: this.threadTlsGetOrig, p: this.threadTlsGetPatch, cmt: "threadTlsGet()"}, + {o: this.threadTlsSetOrig, p: this.threadTlsSetPatch, cmt: "threadTlsSet()"}, + {o: this.threadEntryOrigGCC15O2, p: this.threadEntryPatchGCC15O2, cmt: "threadEntry() GCC 15 -O2"}, + {o: this.threadEntryOrigGCC14O2, p: this.threadEntryPatchGCC14O2, cmt: "threadEntry() GCC 14 -O2"}, + {o: this.threadEntryOrigGCC13, p: this.threadEntryPatchGCC13, cmt: "threadEntry() GCC 13 and below -O2"}, + {o: this.threadEntryOrigGCC15O1, p: this.threadEntryPatchGCC15O1, cmt: "threadEntry() GCC 15 and below -O1"}, + {o: this.threadEntryOrigLibNx1, p: this.threadEntryPatchLibNx1, cmt: "threadEntry() LibNX patch 1"}, + {o: this.threadEntryOrigLibNx2, p: this.threadEntryPatchLibNx2, cmt: "threadEntry() LibNX patch 2"}, + ]; + + check(context: PatchContext): boolean { + return this.patchesOrig.some((pattern) => { + if (typeof pattern === "string") { + pattern = PatternMatcher.parse(pattern); + } + return PatternMatcher.find(context.nro.text, pattern) !== -1; + }); + } + + apply(context: PatchContext): boolean { + let anyApplied = false; + for (const { o, p, cmt } of this.patchesPatch) { + const offset = PatternMatcher.find(context.nro.text, o); + if (offset !== -1) { + context.log(`Found pattern ${cmt} at offset ${nhex(offset)}`); + PatternMatcher.applyPattern(context.nro.text, offset, p); + context.appliedPatches.add(this.id); + anyApplied = true; + } else { + // context.log(`Pattern ${cmt} not found`); + } + } + + return anyApplied; + } +} + +// TODO: What approach should we take here to add a LNY2 marker? +// I personally think it's wiser to just leave it as is so that hbmenu keeps the red warning visible - the whole method is a massive hack anyway. +// There's not enough space in the MOD0 header, so the best solution I'm thinking of is to move it to the end of file if possible. + +// export class Crt0Lny2Patch extends Patch { +// readonly id = "pattern_crt0_lny2"; + +// check(context: PatchContext): boolean { +// const { nro } = context; +// return false; +// } + +// apply(context: PatchContext): boolean { +// return false; +// } +// } + +export const PATCHES: Patch[] = [ + new LegacyAbiPatch(), + // new Crt0Lny2Patch() +]; diff --git a/src/patcher/utils.ts b/src/patcher/utils.ts new file mode 100644 index 0000000..9e77936 --- /dev/null +++ b/src/patcher/utils.ts @@ -0,0 +1,136 @@ +export function unhex(hex: string): Uint8Array { + // Remove all spaces and parse every two hex characters as a byte + const clean = hex.replace(/\s+/g, ""); + if (clean.length % 2 !== 0) + throw new Error("Hex string must have even length"); + const arr = []; + for (let i = 0; i < clean.length; i += 2) { + arr.push(parseInt(clean.slice(i, i + 2), 16)); + } + return new Uint8Array(arr); +} + +export function nhex(num: number | bigint): string { + return `0x${num.toString(16).padStart(8, "0")}`; +} + +export interface Pattern { + bytes: Uint8Array; + mask: Uint8Array; +} + +export class PatternMatcher { + /** + * Parses a pattern string into a structure for matching. + * Supports hex bytes (e.g. "AA") and wildcards ("??"). + * Spaces are ignored. + / + static parse(pattern: string): Pattern { + const cleanPattern = pattern.replace(/\s+/g, ""); + if (cleanPattern.length % 2 !== 0) { + throw new Error("Invalid pattern length"); + } + + const length = cleanPattern.length / 2; + const bytes = new Uint8Array(length); + const mask = new Uint8Array(length); + + for (let i = 0; i < length; i++) { + const byteStr = cleanPattern.substr(i 2, 2); + if (byteStr === "??") { + bytes[i] = 0; + mask[i] = 0; + } else { + bytes[i] = parseInt(byteStr, 16); + mask[i] = 0xff; + } + } + + return { bytes, mask }; + } + + /** + * Finds the first occurrence of the pattern in the data. + * Returns the offset or -1 if not found. + */ + static find(data: Uint8Array, pattern: Pattern): number { + const { bytes, mask } = pattern; + + // Optimization: if no wildcards, use simpler search + let hasWildcards = false; + for (let i = 0; i < mask.length; i++) { + if (mask[i] !== 0xff) { + hasWildcards = true; + break; + } + } + + if (!hasWildcards) { + return this.findExact(data, bytes); + } + + return this.findWithWildcards(data, bytes, mask); + } + + private static findExact(data: Uint8Array, pattern: Uint8Array): number { + const len = pattern.length; + const end = data.length - len; + + for (let i = 0; i <= end; i++) { + let found = true; + for (let j = 0; j < len; j++) { + if (data[i + j] !== pattern[j]) { + found = false; + break; + } + } + if (found) return i; + } + return -1; + } + + private static findWithWildcards( + data: Uint8Array, + pattern: Uint8Array, + mask: Uint8Array, + ): number { + const len = pattern.length; + const end = data.length - len; + + for (let i = 0; i <= end; i++) { + let found = true; + for (let j = 0; j < len; j++) { + if (mask[j] === 0xff && data[i + j] !== pattern[j]) { + found = false; + break; + } + } + if (found) return i; + } + return -1; + } + + /** + * Applies a patch pattern to a target buffer, skipping wildcards ('??'). + * Wildcard bytes (mask value 0x00) are not written into the data array. + * + * @param data Target Uint8Array to patch (will be mutated). + * @param offset Offset in data at which to write the pattern. + * @param pattern Patch bytes (with wildcards matching any value). + * @param mask Uint8Array mask (0xFF for bytes to write, 0x00 for wildcards/'??'). + / + static applyPattern( + data: Uint8Array, + offset: number, + pattern: Pattern, + ): void { + const { bytes, mask } = pattern; + const len = Math.min(bytes.length, mask.length, data.length - offset); + for (let i = 0; i < len; i++) { + if (mask[i] === 0xff) { + data[offset + i] = bytes[i]; + } + // if mask[i] === 0x00, skip (wildcard, preserve existing byte) + } + } +} diff --git a/src/types.ts b/src/types.ts new file mode 100644 index 0000000..791a712 --- /dev/null +++ b/src/types.ts @@ -0,0 +1,22 @@ +export type FileState = + | "none" + | "invalid" + | "new-abi" + | "patched" + | "needs-patching"; + +export interface AnalysisResult { + state: FileState; + fileName: string; + messageKey: string; + messageParams?: Record; + log: string[]; +} + +export interface PatchResult { + success: boolean; + patchedData?: Uint8Array; + errorKey?: string; + errorParams?: Record; + log: string[]; +} diff --git a/src/utils/localization.ts b/src/utils/localization.ts new file mode 100644 index 0000000..ee31e49 --- /dev/null +++ b/src/utils/localization.ts @@ -0,0 +1,31 @@ +export const MESSAGES: Record = { + status_invalid_nro: "This file does not appear to be a valid NRO file.", + status_needs_patching: "This file uses the old ABI and can be patched.", + status_new_abi: + "This file already uses the new ABI and does not need patching.", + status_no_pattern: + "This file is a valid NRO but does not contain the expected ABI pattern. It may not need patching.", + pattern_legacy_abi: "Legacy ABI", + pattern_crt0_lny2: "Missing LNY2 (CRT0)", + error_analysis_failed: "Failed to analyze file. Please try again.", + error_already_patched: "File is already patched.", + error_pattern_not_found: "Could not find the ABI pattern to patch.", + error_unknown: "Unknown error occurred: {message}", +}; + +export function formatMessage( + key: string, + params?: Record, +): string { + let message = MESSAGES[key] || key; + if (params) { + Object.entries(params).forEach(([paramKey, paramValue]) => { + let displayValue = String(paramValue); + if (typeof paramValue === "string" && MESSAGES[paramValue]) { + displayValue = MESSAGES[paramValue]; + } + message = message.replace(`{${paramKey}}`, displayValue); + }); + } + return message; +} diff --git a/tsconfig.app.json b/tsconfig.app.json new file mode 100644 index 0000000..a9b5a59 --- /dev/null +++ b/tsconfig.app.json @@ -0,0 +1,28 @@ +{ + "compilerOptions": { + "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo", + "target": "ES2022", + "useDefineForClassFields": true, + "lib": ["ES2022", "DOM", "DOM.Iterable"], + "module": "ESNext", + "types": ["vite/client"], + "skipLibCheck": true, + + / Bundler mode / + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "verbatimModuleSyntax": true, + "moduleDetection": "force", + "noEmit": true, + "jsx": "react-jsx", + + / Linting / + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "erasableSyntaxOnly": true, + "noFallthroughCasesInSwitch": true, + "noUncheckedSideEffectImports": true + }, + "include": ["src"] +} diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..1ffef60 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,7 @@ +{ + "files": [], + "references": [ + { "path": "./tsconfig.app.json" }, + { "path": "./tsconfig.node.json" } + ] +} diff --git a/tsconfig.node.json b/tsconfig.node.json new file mode 100644 index 0000000..8a67f62 --- /dev/null +++ b/tsconfig.node.json @@ -0,0 +1,26 @@ +{ + "compilerOptions": { + "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo", + "target": "ES2023", + "lib": ["ES2023"], + "module": "ESNext", + "types": ["node"], + "skipLibCheck": true, + + / Bundler mode / + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "verbatimModuleSyntax": true, + "moduleDetection": "force", + "noEmit": true, + + / Linting */ + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "erasableSyntaxOnly": true, + "noFallthroughCasesInSwitch": true, + "noUncheckedSideEffectImports": true + }, + "include": ["vite.config.ts"] +} diff --git a/vite.config.ts b/vite.config.ts new file mode 100644 index 0000000..8b0f57b --- /dev/null +++ b/vite.config.ts @@ -0,0 +1,7 @@ +import { defineConfig } from 'vite' +import react from '@vitejs/plugin-react' + +// https://vite.dev/config/ +export default defineConfig({ + plugins: [react()], +})

+ {isDragging ? "Drop file now" : "Select NRO File"} +

+ {getStatusTitle()} +

+ libnx ABI Patcher +

+ {children} +

Disclaimer

Instructions

For Developers

TL;DR

+ How this tool works +

+ Why isn't this built into the Homebrew Loader? +

+ Why the breakage happened +

+ Why Atmosphère didn't add a workaround +

+ Success! +

{title}