qres 0.1.0__tar.gz

qres-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Farhan Ali
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qres-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: qres
+Version: 0.1.0
+Summary: Fast Qt resource compiler — Python C extension
+Author-email: Farhan Ali <i.farhanali.dev@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Farhan Ali
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/farhaanaliii/qres
+Project-URL: Repository, https://github.com/farhaanaliii/qres
+Project-URL: Issues, https://github.com/farhaanaliii/qres/issues
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<div align="center">
+
+# qres
+
+[![PyPI](https://img.shields.io/pypi/v/qres)](https://pypi.org/project/qres)
+[![Python](https://img.shields.io/pypi/pyversions/qres)](https://pypi.org/project/qres)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Build](https://img.shields.io/github/actions/workflow/status/farhaanaliii/qres/ci.yml?branch=main)](https://github.com/farhaanaliii/qres/actions)
+
+A fast Qt resource compiler for Python, implemented as a C extension. Drop-in replacement for `pyrcc5` / `pyside6-rcc` that compiles `.qrc` files into `_rc.py` modules without requiring a Qt installation.
+
+</div>
+
+## Installation
+
+```
+pip install qres
+```
+
+Pre-built wheels are available for Linux (x86_64, aarch64), macOS (x86_64, arm64), and Windows (AMD64, ARM64) on Python 3.11+.
+
+## Usage
+
+**CLI**
+
+```
+qres resources.qrc
+qres resources.qrc -o path/to/resources_rc.py
+qres resources.qrc --binding PySide6
+```
+
+**Python API**
+
+```python
+import qres
+
+# Compile from a file path
+qres.compile_file("resources.qrc")
+qres.compile_file("resources.qrc", output="resources_rc.py")
+qres.compile_file("resources.qrc", binding="PySide6")
+
+# Compile from an XML string, returns raw blobs
+blobs = qres.compile(xml_string, base_dir="/path/to/qrc/dir")
+# blobs: {"data": bytes, "name": bytes, "struct_v1": bytes, "struct_v2": bytes}
+```
+
+The generated `_rc.py` works with `qtpy`, `PyQt5`, `PyQt6`, `PySide2`, and `PySide6`. By default, it includes an automatic fallback import chain that resolves whichever Qt binding is installed in the active environment.
+
+## How it works
+
+qres parses the `.qrc` XML, builds a virtual file tree sorted by Qt's hash function, compresses each asset with zlib at level 9 (skipping compression when it doesn't help or for `.ico` files), then serializes two binary struct formats — `v1` for Qt < 5.8 and `v2` for Qt >= 5.8 — into Python byte literals.
+
+## Benchmarks
+
+Benchmarked on a 50 MB uncompressed text asset compiled into a registered Qt resource module:
+
+| Metric | Measurement |
+|---|---|
+| Input payload | 50.00 MB (52,428,800 bytes) |
+| Compile duration | 403 ms (0.40 s) |
+| Compilation throughput | 124 MB/s |
+| Generated module size | 1.23 MB (97.5% compression) |
+| Qt resource read speed | 93 ms (534 MB/s) |
+| Data integrity | SHA-256 verified |
+
+
+## Contributing
+
+See [CONTRIBUTING.md](.github/CONTRIBUTING.md).
+
+## Building from source
+
+Requires a C compiler.
+
+```
+git clone https://github.com/farhaanaliii/qres
+cd qres
+pip install -e .
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

qres-0.1.0/README.md

@@ -0,0 +1,83 @@
+<div align="center">
+
+# qres
+
+[![PyPI](https://img.shields.io/pypi/v/qres)](https://pypi.org/project/qres)
+[![Python](https://img.shields.io/pypi/pyversions/qres)](https://pypi.org/project/qres)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Build](https://img.shields.io/github/actions/workflow/status/farhaanaliii/qres/ci.yml?branch=main)](https://github.com/farhaanaliii/qres/actions)
+
+A fast Qt resource compiler for Python, implemented as a C extension. Drop-in replacement for `pyrcc5` / `pyside6-rcc` that compiles `.qrc` files into `_rc.py` modules without requiring a Qt installation.
+
+</div>
+
+## Installation
+
+```
+pip install qres
+```
+
+Pre-built wheels are available for Linux (x86_64, aarch64), macOS (x86_64, arm64), and Windows (AMD64, ARM64) on Python 3.11+.
+
+## Usage
+
+**CLI**
+
+```
+qres resources.qrc
+qres resources.qrc -o path/to/resources_rc.py
+qres resources.qrc --binding PySide6
+```
+
+**Python API**
+
+```python
+import qres
+
+# Compile from a file path
+qres.compile_file("resources.qrc")
+qres.compile_file("resources.qrc", output="resources_rc.py")
+qres.compile_file("resources.qrc", binding="PySide6")
+
+# Compile from an XML string, returns raw blobs
+blobs = qres.compile(xml_string, base_dir="/path/to/qrc/dir")
+# blobs: {"data": bytes, "name": bytes, "struct_v1": bytes, "struct_v2": bytes}
+```
+
+The generated `_rc.py` works with `qtpy`, `PyQt5`, `PyQt6`, `PySide2`, and `PySide6`. By default, it includes an automatic fallback import chain that resolves whichever Qt binding is installed in the active environment.
+
+## How it works
+
+qres parses the `.qrc` XML, builds a virtual file tree sorted by Qt's hash function, compresses each asset with zlib at level 9 (skipping compression when it doesn't help or for `.ico` files), then serializes two binary struct formats — `v1` for Qt < 5.8 and `v2` for Qt >= 5.8 — into Python byte literals.
+
+## Benchmarks
+
+Benchmarked on a 50 MB uncompressed text asset compiled into a registered Qt resource module:
+
+| Metric | Measurement |
+|---|---|
+| Input payload | 50.00 MB (52,428,800 bytes) |
+| Compile duration | 403 ms (0.40 s) |
+| Compilation throughput | 124 MB/s |
+| Generated module size | 1.23 MB (97.5% compression) |
+| Qt resource read speed | 93 ms (534 MB/s) |
+| Data integrity | SHA-256 verified |
+
+
+## Contributing
+
+See [CONTRIBUTING.md](.github/CONTRIBUTING.md).
+
+## Building from source
+
+Requires a C compiler.
+
+```
+git clone https://github.com/farhaanaliii/qres
+cd qres
+pip install -e .
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

qres-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qres"
+version = "0.1.0"
+description = "Fast Qt resource compiler — Python C extension"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Farhan Ali", email = "i.farhanali.dev@gmail.com" }]
+requires-python = ">=3.11"
+dependencies = []
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: C",
+    "Topic :: Software Development :: Build Tools",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/farhaanaliii/qres"
+Repository = "https://github.com/farhaanaliii/qres"
+Issues = "https://github.com/farhaanaliii/qres/issues"
+
+[project.scripts]
+qres = "qres:main"
+
+[tool.setuptools]
+packages = ["qres"]
+
+[tool.setuptools.package-data]
+qres = ["py.typed"]
+

qres-0.1.0/qres/__init__.py

@@ -0,0 +1,110 @@
+import argparse
+from pathlib import Path
+import sys
+
+from ._qres import compile as _compile
+
+_BINDINGS = ("PyQt6", "PySide6", "PyQt5", "PySide2", "qtpy")
+
+_HEADER_BOILERPLATE = """# -*- coding: utf-8 -*-
+
+# Resource object code
+#
+# Created by: qres
+#
+# WARNING! All changes made in this file will be lost!
+
+"""
+
+_FOOTER_BOILERPLATE = """qt_version = [int(v) for v in QtCore.qVersion().split('.')]
+if qt_version < [5, 8, 0]:
+    rcc_version = 1
+    qt_resource_struct = qt_resource_struct_v1
+else:
+    rcc_version = 2
+    qt_resource_struct = qt_resource_struct_v2
+
+def qInitResources():
+    QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
+
+def qCleanupResources():
+    QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
+
+qInitResources()
+"""
+
+_RESOURCE_BLOBS = (
+    ("qt_resource_data", "data"),
+    ("qt_resource_name", "name"),
+    ("qt_resource_struct_v1", "struct_v1"),
+    ("qt_resource_struct_v2", "struct_v2"),
+)
+
+_BYTE_ESCAPES = tuple(f"\\x{byte:02x}" for byte in range(256))
+
+
+def compile(xml: str, base_dir: str) -> dict[str, bytes]:
+    return _compile(xml, base_dir)
+
+def _generate_import_header(binding: str) -> str:
+    if binding != "auto":
+        return f"from {binding} import QtCore\n\n"
+
+    lines = []
+    for i, name in enumerate(_BINDINGS[:-1]):
+        indent = "    " * i
+        lines.append(f"{indent}try:\n{indent}    from {name} import QtCore\n{indent}except ImportError:\n")
+
+    indent = "    " * (len(_BINDINGS) - 1)
+    lines.append(f"{indent}from {_BINDINGS[-1]} import QtCore\n\n")
+    return "".join(lines)
+
+def _generate_resource_blob(name: str, data: bytes) -> str:
+    return (
+        f'{name} = b"\\\n'
+        + "".join(
+            "".join(_BYTE_ESCAPES[byte] for byte in data[i:i + 16]) + "\\\n"
+            for i in range(0, len(data), 16)
+        )
+        + '"\n\n'
+    )
+
+
+def compile_file(
+    qrc_path: str | Path,
+    output: str | Path | None = None,
+    binding: str = "auto",
+) -> None:
+    qrc_path = Path(qrc_path)
+    blobs = compile(qrc_path.read_text(encoding="utf-8"), str(qrc_path.parent))
+
+    target = Path(output) if output else qrc_path.with_name(f"{qrc_path.stem}_rc.py")
+    import_header = _generate_import_header(binding)
+    blobs_code = "".join(_generate_resource_blob(var_name, blobs[key]) for var_name, key in _RESOURCE_BLOBS)
+
+    target.write_text(_HEADER_BOILERPLATE + import_header + blobs_code + _FOOTER_BOILERPLATE, encoding="utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="qres",
+        description="Compile a .qrc file into a Python resource module.",
+    )
+    parser.add_argument("qrc", help="Path to the .qrc file")
+    parser.add_argument("-o", "--output", default=None, help="Output .py file path")
+    parser.add_argument(
+        "--binding",
+        choices=("auto", *_BINDINGS),
+        default="auto",
+        help="Target Qt binding (default: auto)",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Print verbose output")
+    args = parser.parse_args()
+
+    try:
+        compile_file(args.qrc, args.output, binding=args.binding)
+        if args.verbose:
+            print(f"Resource compilation completed successfully: {args.qrc}")
+    except Exception as exc:
+        sys.stderr.write(f"qres: error: {exc}\n")
+        sys.exit(1)

qres-0.1.0/qres/__main__.py

@@ -0,0 +1,4 @@
+from . import main
+
+if __name__ == "__main__":
+    main()

qres-0.1.0/qres/py.typed

@@ -0,0 +1 @@
+

qres-0.1.0/qres.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: qres
+Version: 0.1.0
+Summary: Fast Qt resource compiler — Python C extension
+Author-email: Farhan Ali <i.farhanali.dev@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Farhan Ali
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/farhaanaliii/qres
+Project-URL: Repository, https://github.com/farhaanaliii/qres
+Project-URL: Issues, https://github.com/farhaanaliii/qres/issues
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<div align="center">
+
+# qres
+
+[![PyPI](https://img.shields.io/pypi/v/qres)](https://pypi.org/project/qres)
+[![Python](https://img.shields.io/pypi/pyversions/qres)](https://pypi.org/project/qres)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Build](https://img.shields.io/github/actions/workflow/status/farhaanaliii/qres/ci.yml?branch=main)](https://github.com/farhaanaliii/qres/actions)
+
+A fast Qt resource compiler for Python, implemented as a C extension. Drop-in replacement for `pyrcc5` / `pyside6-rcc` that compiles `.qrc` files into `_rc.py` modules without requiring a Qt installation.
+
+</div>
+
+## Installation
+
+```
+pip install qres
+```
+
+Pre-built wheels are available for Linux (x86_64, aarch64), macOS (x86_64, arm64), and Windows (AMD64, ARM64) on Python 3.11+.
+
+## Usage
+
+**CLI**
+
+```
+qres resources.qrc
+qres resources.qrc -o path/to/resources_rc.py
+qres resources.qrc --binding PySide6
+```
+
+**Python API**
+
+```python
+import qres
+
+# Compile from a file path
+qres.compile_file("resources.qrc")
+qres.compile_file("resources.qrc", output="resources_rc.py")
+qres.compile_file("resources.qrc", binding="PySide6")
+
+# Compile from an XML string, returns raw blobs
+blobs = qres.compile(xml_string, base_dir="/path/to/qrc/dir")
+# blobs: {"data": bytes, "name": bytes, "struct_v1": bytes, "struct_v2": bytes}
+```
+
+The generated `_rc.py` works with `qtpy`, `PyQt5`, `PyQt6`, `PySide2`, and `PySide6`. By default, it includes an automatic fallback import chain that resolves whichever Qt binding is installed in the active environment.
+
+## How it works
+
+qres parses the `.qrc` XML, builds a virtual file tree sorted by Qt's hash function, compresses each asset with zlib at level 9 (skipping compression when it doesn't help or for `.ico` files), then serializes two binary struct formats — `v1` for Qt < 5.8 and `v2` for Qt >= 5.8 — into Python byte literals.
+
+## Benchmarks
+
+Benchmarked on a 50 MB uncompressed text asset compiled into a registered Qt resource module:
+
+| Metric | Measurement |
+|---|---|
+| Input payload | 50.00 MB (52,428,800 bytes) |
+| Compile duration | 403 ms (0.40 s) |
+| Compilation throughput | 124 MB/s |
+| Generated module size | 1.23 MB (97.5% compression) |
+| Qt resource read speed | 93 ms (534 MB/s) |
+| Data integrity | SHA-256 verified |
+
+
+## Contributing
+
+See [CONTRIBUTING.md](.github/CONTRIBUTING.md).
+
+## Building from source
+
+Requires a C compiler.
+
+```
+git clone https://github.com/farhaanaliii/qres
+cd qres
+pip install -e .
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

qres-0.1.0/qres.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+qres/__init__.py
+qres/__main__.py
+qres/py.typed
+qres.egg-info/PKG-INFO
+qres.egg-info/SOURCES.txt
+qres.egg-info/dependency_links.txt
+qres.egg-info/entry_points.txt
+qres.egg-info/top_level.txt
+src/compiler.c
+src/qres.c
+tests/test_compile.py

qres-0.1.0/qres.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qres-0.1.0/qres.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qres = qres:main

qres-0.1.0/qres.egg-info/top_level.txt

@@ -0,0 +1 @@
+qres

qres-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qres-0.1.0/setup.py

@@ -0,0 +1,48 @@
+from setuptools import Extension, setup
+from setuptools.command.build_ext import build_ext
+
+
+class BuildExt(build_ext):
+    def build_extensions(self):
+        compiler_type = self.compiler.compiler_type
+        for ext in self.extensions:
+            if compiler_type == "msvc":
+                ext.extra_compile_args = [
+                    "/O2",
+                    "/W4",
+                    "/std:c11",
+                    "/permissive-",
+                    "/GS",
+                    "/sdl",
+                ]
+            else:
+                ext.extra_compile_args = [
+                    "-std=c11",
+                    "-O2",
+                    "-Wall",
+                    "-Wextra",
+                    "-Wpedantic",
+                    "-Wshadow",
+                    "-Wstrict-prototypes",
+                    "-Wpointer-arith",
+                    "-Wformat=2",
+                    "-D_FORTIFY_SOURCE=2",
+                    "-fstack-protector-strong",
+                ]
+        super().build_extensions()
+
+
+setup(
+    cmdclass={"build_ext": BuildExt},
+    ext_modules=[
+        Extension(
+            name="qres._qres",
+            sources=[
+                "src/qres.c",
+                "src/compiler.c",
+            ],
+            include_dirs=["src"],
+        )
+    ],
+)
+

qres-0.1.0/src/compiler.c

@@ -0,0 +1,541 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include "compiler.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+unsigned int qt_hash(const char *str, unsigned int chained) {
+    unsigned int h = chained;
+    for (const char *p = str; *p; p++) {
+        h = (h << 4) + (unsigned char)(*p);
+        unsigned int g = h & 0xF0000000;
+        if (g) h ^= g >> 23;
+        h &= 0x0FFFFFFF;
+    }
+    return h;
+}
+
+void bb_init(ByteBuffer *bb) {
+    bb->data = NULL;
+    bb->size = 0;
+    bb->capacity = 0;
+}
+
+void bb_free(ByteBuffer *bb) {
+    free(bb->data);
+    bb->data = NULL;
+    bb->size = 0;
+    bb->capacity = 0;
+}
+
+void bb_append(ByteBuffer *bb, const unsigned char *src, size_t len) {
+    if (bb->size + len > bb->capacity) {
+        size_t new_cap = bb->capacity == 0 ? 1024 : bb->capacity * 2;
+        while (bb->size + len > new_cap) new_cap *= 2;
+        unsigned char *new_data = (unsigned char *)realloc((void *)bb->data, new_cap);
+        if (!new_data) return;
+        bb->data = new_data;
+        bb->capacity = new_cap;
+    }
+    memcpy(bb->data + bb->size, src, len);
+    bb->size += len;
+}
+
+void bb_append_u16be(ByteBuffer *bb, unsigned short val) {
+    unsigned char buf[2] = {(unsigned char)((val >> 8) & 0xFF), (unsigned char)(val & 0xFF)};
+    bb_append(bb, buf, 2);
+}
+
+void bb_append_u32be(ByteBuffer *bb, unsigned int val) {
+    unsigned char buf[4] = {
+        (unsigned char)((val >> 24) & 0xFF), (unsigned char)((val >> 16) & 0xFF),
+        (unsigned char)((val >> 8) & 0xFF),  (unsigned char)(val & 0xFF)
+    };
+    bb_append(bb, buf, 4);
+}
+
+void bb_append_i32be(ByteBuffer *bb, int val) {
+    unsigned int u = (unsigned int)val;
+    unsigned char buf[4] = {
+        (unsigned char)((u >> 24) & 0xFF), (unsigned char)((u >> 16) & 0xFF),
+        (unsigned char)((u >> 8) & 0xFF),  (unsigned char)(u & 0xFF)
+    };
+    bb_append(bb, buf, 4);
+}
+
+void bb_append_u64be(ByteBuffer *bb, unsigned long long val) {
+    unsigned char buf[8] = {
+        (unsigned char)((val >> 56) & 0xFF), (unsigned char)((val >> 48) & 0xFF),
+        (unsigned char)((val >> 40) & 0xFF), (unsigned char)((val >> 32) & 0xFF),
+        (unsigned char)((val >> 24) & 0xFF), (unsigned char)((val >> 16) & 0xFF),
+        (unsigned char)((val >> 8) & 0xFF),  (unsigned char)(val & 0xFF)
+    };
+    bb_append(bb, buf, 8);
+}
+
+ResourceNode *create_node(const char *name, int is_dir, PyObject *data_bytes) {
+    ResourceNode *node = (ResourceNode *)calloc(1, sizeof(ResourceNode));
+    if (!node) return NULL;
+    node->name = strdup(name);
+    node->is_dir = is_dir;
+    if (data_bytes) {
+        node->data_bytes = data_bytes;
+        Py_INCREF(data_bytes);
+    }
+    return node;
+}
+
+void free_node(ResourceNode *node) {
+    if (!node) return;
+    for (int i = 0; i < node->child_count; i++) {
+        free_node(node->children[i]);
+    }
+    free((void *)node->children);
+    free(node->name);
+    Py_XDECREF(node->data_bytes);
+    free(node);
+}
+
+static ResourceNode *find_child(ResourceNode *parent, const char *name, int is_dir) {
+    for (int i = 0; i < parent->child_count; i++) {
+        if (parent->children[i]->is_dir == is_dir &&
+            strcmp(parent->children[i]->name, name) == 0) {
+            return parent->children[i];
+        }
+    }
+    return NULL;
+}
+
+static void add_child(ResourceNode *parent, ResourceNode *child) {
+    if (parent->child_count >= parent->child_capacity) {
+        int new_cap = parent->child_capacity == 0 ? 4 : parent->child_capacity * 2;
+        ResourceNode **new_children = (ResourceNode **)realloc((void *)parent->children, sizeof(ResourceNode *) * (size_t)new_cap);
+        if (!new_children) return;
+        parent->children = new_children;
+        parent->child_capacity = new_cap;
+    }
+    parent->children[parent->child_count++] = child;
+}
+
+static void add_to_tree(ResourceNode *root, const char *virtual_path, PyObject *data_bytes, long long lastmod) {
+    char *temp = strdup(virtual_path);
+    if (!temp) return;
+
+    char *p = temp;
+    while (*p == '/') p++;
+
+    char *tok = strtok(p, "/");
+    if (!tok) {
+        free(temp);
+        return;
+    }
+
+    int capacity = 8;
+    int part_count = 0;
+    char **parts = (char **)malloc(sizeof(char *) * (size_t)capacity);
+    if (!parts) {
+        free(temp);
+        return;
+    }
+
+    while (tok) {
+        if (part_count >= capacity) {
+            capacity *= 2;
+            char **new_parts = (char **)realloc(parts, sizeof(char *) * (size_t)capacity);
+            if (!new_parts) {
+                free(parts);
+                free(temp);
+                return;
+            }
+            parts = new_parts;
+        }
+        parts[part_count++] = tok;
+        tok = strtok(NULL, "/");
+    }
+
+    ResourceNode *current = root;
+    for (int i = 0; i < part_count - 1; i++) {
+        ResourceNode *child = find_child(current, parts[i], 1);
+        if (!child) {
+            child = create_node(parts[i], 1, NULL);
+            if (!child) {
+                free(parts);
+                free(temp);
+                return;
+            }
+            add_child(current, child);
+        }
+        current = child;
+    }
+
+    ResourceNode *file_node = create_node(parts[part_count - 1], 0, data_bytes);
+    if (file_node) {
+        file_node->lastmod = lastmod;
+        add_child(current, file_node);
+    }
+
+    free(parts);
+    free(temp);
+}
+
+static int parse_qrc(const char *xml_content, ResourceNode *root, const char *base_dir, char *err_buf, size_t err_size) {
+    PyObject *etree = PyImport_ImportModule("xml.etree.ElementTree");
+    if (!etree) {
+        snprintf(err_buf, err_size, "Failed to import xml.etree.ElementTree");
+        return -1;
+    }
+
+    PyObject *root_elem = PyObject_CallMethod(etree, "fromstring", "s", xml_content);
+    if (!root_elem) {
+        PyObject *ptype, *pvalue, *ptrace;
+        PyErr_Fetch(&ptype, &pvalue, &ptrace);
+        if (pvalue) {
+            PyObject *pstr = PyObject_Str(pvalue);
+            if (pstr) {
+                snprintf(err_buf, err_size, "XML syntax error: %s", PyUnicode_AsUTF8(pstr));
+                Py_DECREF(pstr);
+            }
+            Py_DECREF(pvalue);
+        }
+        Py_XDECREF(ptype);
+        Py_XDECREF(ptrace);
+        Py_DECREF(etree);
+        return -1;
+    }
+
+    PyObject *pathlib = PyImport_ImportModule("pathlib");
+    if (!pathlib) {
+        Py_DECREF(root_elem);
+        Py_DECREF(etree);
+        snprintf(err_buf, err_size, "Failed to import pathlib");
+        return -1;
+    }
+
+    PyObject *path_cls = PyObject_GetAttrString(pathlib, "Path");
+    PyObject *base_path_obj = PyObject_CallFunction(path_cls, "s", base_dir);
+    Py_DECREF(path_cls);
+
+    PyObject *qresources = PyObject_CallMethod(root_elem, "findall", "s", "qresource");
+    if (!qresources) {
+        Py_DECREF(base_path_obj);
+        Py_DECREF(pathlib);
+        Py_DECREF(root_elem);
+        Py_DECREF(etree);
+        return -1;
+    }
+
+    Py_ssize_t qres_count = PyList_Size(qresources);
+    for (Py_ssize_t i = 0; i < qres_count; i++) {
+        PyObject *qres = PyList_GetItem(qresources, i);
+        PyObject *prefix_obj = PyObject_CallMethod(qres, "get", "ss", "prefix", "");
+        const char *raw_prefix = prefix_obj ? PyUnicode_AsUTF8(prefix_obj) : "";
+        while (*raw_prefix == '/') raw_prefix++;
+
+        char clean_prefix[256];
+        strncpy(clean_prefix, raw_prefix, sizeof(clean_prefix) - 1);
+        clean_prefix[sizeof(clean_prefix) - 1] = '\0';
+        size_t plen = strlen(clean_prefix);
+        while (plen > 0 && clean_prefix[plen - 1] == '/') {
+            clean_prefix[--plen] = '\0';
+        }
+
+        PyObject *files = PyObject_CallMethod(qres, "findall", "s", "file");
+        if (!files) {
+            Py_XDECREF(prefix_obj);
+            continue;
+        }
+
+        Py_ssize_t file_count = PyList_Size(files);
+        for (Py_ssize_t j = 0; j < file_count; j++) {
+            PyObject *file_item = PyList_GetItem(files, j);
+            PyObject *text_obj = PyObject_GetAttrString(file_item, "text");
+            if (!text_obj || text_obj == Py_None) {
+                Py_XDECREF(text_obj);
+                continue;
+            }
+
+            PyObject *stripped_text = PyObject_CallMethod(text_obj, "strip", NULL);
+            Py_DECREF(text_obj);
+            if (!stripped_text) continue;
+
+            const char *rel_path = PyUnicode_AsUTF8(stripped_text);
+            if (!rel_path || strlen(rel_path) == 0) {
+                Py_DECREF(stripped_text);
+                continue;
+            }
+
+            PyObject *file_path_obj = PyObject_CallMethod(base_path_obj, "joinpath", "s", rel_path);
+            PyObject *data_bytes = PyObject_CallMethod(file_path_obj, "read_bytes", NULL);
+            if (!data_bytes) {
+                PyErr_Clear();
+                PyObject *path_str = PyObject_Str(file_path_obj);
+                snprintf(err_buf, err_size, "Cannot open file: %s", path_str ? PyUnicode_AsUTF8(path_str) : rel_path);
+                Py_XDECREF(path_str);
+                Py_DECREF(file_path_obj);
+                Py_DECREF(stripped_text);
+                Py_DECREF(files);
+                Py_XDECREF(prefix_obj);
+                Py_DECREF(qresources);
+                Py_DECREF(base_path_obj);
+                Py_DECREF(pathlib);
+                Py_DECREF(root_elem);
+                Py_DECREF(etree);
+                return -1;
+            }
+
+            long long lastmod = 0;
+            PyObject *stat_obj = PyObject_CallMethod(file_path_obj, "stat", NULL);
+            if (stat_obj) {
+                PyObject *mtime_obj = PyObject_GetAttrString(stat_obj, "st_mtime");
+                if (mtime_obj) {
+                    double mtime = PyFloat_AsDouble(mtime_obj);
+                    lastmod = (long long)(mtime * 1000.0);
+                    Py_DECREF(mtime_obj);
+                }
+                Py_DECREF(stat_obj);
+            }
+            Py_DECREF(file_path_obj);
+
+            PyObject *alias_obj = PyObject_CallMethod(file_item, "get", "s", "alias");
+            const char *target = (alias_obj && alias_obj != Py_None) ? PyUnicode_AsUTF8(alias_obj) : rel_path;
+            while (*target == '/') target++;
+
+            size_t vpath_len = plen + strlen(target) + 2;
+            char *vpath = (char *)malloc(vpath_len);
+            if (vpath) {
+                if (plen > 0) {
+                    snprintf(vpath, vpath_len, "%s/%s", clean_prefix, target);
+                } else {
+                    snprintf(vpath, vpath_len, "%s", target);
+                }
+                for (char *c = vpath; *c; c++) {
+                    if (*c == '\\') *c = '/';
+                }
+                add_to_tree(root, vpath, data_bytes, lastmod);
+                free(vpath);
+            }
+
+            Py_XDECREF(alias_obj);
+            Py_DECREF(data_bytes);
+            Py_DECREF(stripped_text);
+        }
+        Py_DECREF(files);
+        Py_XDECREF(prefix_obj);
+    }
+
+    Py_DECREF(qresources);
+    Py_DECREF(base_path_obj);
+    Py_DECREF(pathlib);
+    Py_DECREF(root_elem);
+    Py_DECREF(etree);
+    return 0;
+}
+
+static int compare_nodes(const void *a, const void *b) {
+    ResourceNode *const *node_a = (ResourceNode *const *)a;
+    ResourceNode *const *node_b = (ResourceNode *const *)b;
+    unsigned int hash_a = qt_hash((*node_a)->name, 0);
+    unsigned int hash_b = qt_hash((*node_b)->name, 0);
+    if (hash_a < hash_b) return -1;
+    if (hash_a > hash_b) return 1;
+    return strcmp((*node_a)->name, (*node_b)->name);
+}
+
+static void sort_tree(ResourceNode *node) {
+    if (node->child_count > 0) {
+        qsort((void *)node->children, (size_t)node->child_count, sizeof(ResourceNode *), compare_nodes);
+        for (int i = 0; i < node->child_count; i++) {
+            sort_tree(node->children[i]);
+        }
+    }
+}
+
+static void flatten_tree(ResourceNode *root, FlatList *fl) {
+    int queue_capacity = 1000;
+    ResourceNode **queue = (ResourceNode **)malloc(sizeof(ResourceNode *) * (size_t)queue_capacity);
+    if (!queue) return;
+    int head = 0, tail = 0;
+    queue[tail++] = root;
+
+    while (head < tail) {
+        ResourceNode *curr = queue[head++];
+
+        if (fl->count >= fl->capacity) {
+            int new_cap = fl->capacity == 0 ? 1000 : fl->capacity * 2;
+            ResourceNode **new_nodes = (ResourceNode **)realloc((void *)fl->nodes, sizeof(ResourceNode *) * (size_t)new_cap);
+            if (!new_nodes) {
+                free((void *)queue);
+                return;
+            }
+            fl->nodes = new_nodes;
+            fl->capacity = new_cap;
+        }
+        fl->nodes[fl->count++] = curr;
+
+        for (int i = 0; i < curr->child_count; i++) {
+            if (tail >= queue_capacity) {
+                int new_q_cap = queue_capacity * 2;
+                ResourceNode **new_q = (ResourceNode **)realloc((void *)queue, sizeof(ResourceNode *) * (size_t)new_q_cap);
+                if (!new_q) {
+                    free((void *)queue);
+                    return;
+                }
+                queue = new_q;
+                queue_capacity = new_q_cap;
+            }
+            queue[tail++] = curr->children[i];
+        }
+    }
+    free((void *)queue);
+}
+
+int compile_qrc(const char *xml_content, const char *base_dir, CompileResult *out) {
+    bb_init(&out->name_bytes);
+    bb_init(&out->data_bytes);
+    bb_init(&out->struct_v1_bytes);
+    bb_init(&out->struct_v2_bytes);
+    out->error[0] = '\0';
+
+    ResourceNode *root = create_node("", 1, NULL);
+    if (!root) {
+        snprintf(out->error, sizeof(out->error), "Failed to allocate root node");
+        return -1;
+    }
+
+    if (parse_qrc(xml_content, root, base_dir, out->error, sizeof(out->error)) != 0) {
+        free_node(root);
+        return -1;
+    }
+
+    sort_tree(root);
+
+    FlatList fl = {NULL, 0, 0};
+    flatten_tree(root, &fl);
+
+    for (int i = 0; i < fl.count; i++) {
+        ResourceNode *node = fl.nodes[i];
+        if (i == 0) {
+            node->name_offset = 0;
+            continue;
+        }
+        node->name_offset = (int)out->name_bytes.size;
+
+        PyObject *py_name = PyUnicode_FromString(node->name);
+        if (!py_name) {
+            snprintf(out->error, sizeof(out->error), "Invalid name: %s", node->name);
+            free((void *)fl.nodes);
+            free_node(root);
+            return -1;
+        }
+
+        PyObject *u16_bytes = PyUnicode_AsEncodedString(py_name, "utf-16be", "strict");
+        Py_DECREF(py_name);
+        if (!u16_bytes) {
+            snprintf(out->error, sizeof(out->error), "Failed to encode name to UTF-16: %s", node->name);
+            free((void *)fl.nodes);
+            free_node(root);
+            return -1;
+        }
+
+        char *u16_data = NULL;
+        Py_ssize_t u16_len = 0;
+        PyBytes_AsStringAndSize(u16_bytes, &u16_data, &u16_len);
+
+        unsigned short u16_units = (unsigned short)(u16_len / 2);
+        bb_append_u16be(&out->name_bytes, u16_units);
+        bb_append_u32be(&out->name_bytes, qt_hash(node->name, 0));
+        bb_append(&out->name_bytes, (const unsigned char *)u16_data, (size_t)u16_len);
+        Py_DECREF(u16_bytes);
+    }
+
+    PyObject *zlib_mod = PyImport_ImportModule("zlib");
+    if (!zlib_mod) {
+        snprintf(out->error, sizeof(out->error), "Failed to import Python zlib module");
+        free((void *)fl.nodes);
+        free_node(root);
+        return -1;
+    }
+
+    for (int i = 0; i < fl.count; i++) {
+        ResourceNode *node = fl.nodes[i];
+        if (node->is_dir) continue;
+
+        node->data_offset = (int)out->data_bytes.size;
+
+        char *raw_data = NULL;
+        Py_ssize_t raw_size = 0;
+        PyBytes_AsStringAndSize(node->data_bytes, &raw_data, &raw_size);
+
+        PyObject *comp_obj = PyObject_CallMethod(zlib_mod, "compress", "y#i", raw_data, raw_size, 9);
+        if (!comp_obj) {
+            PyErr_Clear();
+            snprintf(out->error, sizeof(out->error), "Failed to compress file data: %s", node->name);
+            Py_DECREF(zlib_mod);
+            free((void *)fl.nodes);
+            free_node(root);
+            return -1;
+        }
+
+        char *comp_data = NULL;
+        Py_ssize_t comp_size = 0;
+        PyBytes_AsStringAndSize(comp_obj, &comp_data, &comp_size);
+
+        size_t name_len = strlen(node->name);
+        int is_ico = (name_len >= 4 && strcmp(node->name + name_len - 4, ".ico") == 0);
+
+        if (is_ico || comp_size >= raw_size) {
+            node->flags = 0x0000;
+            bb_append_u32be(&out->data_bytes, (unsigned int)raw_size);
+            bb_append(&out->data_bytes, (const unsigned char *)raw_data, (size_t)raw_size);
+        } else {
+            node->flags = 0x0001;
+            unsigned int payload_size = (unsigned int)comp_size + 4;
+            bb_append_u32be(&out->data_bytes, payload_size);
+            bb_append_u32be(&out->data_bytes, (unsigned int)raw_size);
+            bb_append(&out->data_bytes, (const unsigned char *)comp_data, (size_t)comp_size);
+        }
+
+        Py_DECREF(comp_obj);
+    }
+
+    Py_DECREF(zlib_mod);
+
+    for (int i = 0; i < fl.count; i++) {
+        ResourceNode *node = fl.nodes[i];
+        unsigned int mix, offset = 0;
+
+        if (node->is_dir) {
+            node->flags = 2;
+            mix = (unsigned int)node->child_count;
+            if (node->child_count > 0) {
+                ResourceNode *first_child = node->children[0];
+                for (int j = 0; j < fl.count; j++) {
+                    if (fl.nodes[j] == first_child) {
+                        offset = (unsigned int)j;
+                        break;
+                    }
+                }
+            }
+        } else {
+            mix = 1;
+            offset = (unsigned int)node->data_offset;
+        }
+
+        bb_append_u32be(&out->struct_v1_bytes, (unsigned int)node->name_offset);
+        bb_append_u16be(&out->struct_v1_bytes, node->flags);
+        bb_append_u32be(&out->struct_v1_bytes, mix);
+        bb_append_u32be(&out->struct_v1_bytes, offset);
+
+        bb_append_u32be(&out->struct_v2_bytes, (unsigned int)node->name_offset);
+        bb_append_u16be(&out->struct_v2_bytes, node->flags);
+        bb_append_u32be(&out->struct_v2_bytes, mix);
+        bb_append_i32be(&out->struct_v2_bytes, (int)offset);
+        bb_append_u64be(&out->struct_v2_bytes, (unsigned long long)node->lastmod);
+    }
+
+    free((void *)fl.nodes);
+    free_node(root);
+    return 0;
+}

qres-0.1.0/src/qres.c

@@ -0,0 +1,74 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "compiler.h"
+
+static PyObject *py_compile(PyObject *self, PyObject *args) {
+    (void)self;
+    const char *xml_content;
+    const char *base_dir;
+
+    if (!PyArg_ParseTuple(args, "ss", &xml_content, &base_dir))
+        return NULL;
+
+    CompileResult result;
+    if (compile_qrc(xml_content, base_dir, &result) != 0) {
+        PyErr_SetString(PyExc_RuntimeError, result.error);
+        return NULL;
+    }
+
+    PyObject *data      = PyBytes_FromStringAndSize((char *)result.data_bytes.data,      (Py_ssize_t)result.data_bytes.size);
+    PyObject *name      = PyBytes_FromStringAndSize((char *)result.name_bytes.data,      (Py_ssize_t)result.name_bytes.size);
+    PyObject *struct_v1 = PyBytes_FromStringAndSize((char *)result.struct_v1_bytes.data, (Py_ssize_t)result.struct_v1_bytes.size);
+    PyObject *struct_v2 = PyBytes_FromStringAndSize((char *)result.struct_v2_bytes.data, (Py_ssize_t)result.struct_v2_bytes.size);
+
+    bb_free(&result.data_bytes);
+    bb_free(&result.name_bytes);
+    bb_free(&result.struct_v1_bytes);
+    bb_free(&result.struct_v2_bytes);
+
+    if (!data || !name || !struct_v1 || !struct_v2) {
+        Py_XDECREF(data);
+        Py_XDECREF(name);
+        Py_XDECREF(struct_v1);
+        Py_XDECREF(struct_v2);
+        return NULL;
+    }
+
+    PyObject *dict = PyDict_New();
+    PyDict_SetItemString(dict, "data",      data);
+    PyDict_SetItemString(dict, "name",      name);
+    PyDict_SetItemString(dict, "struct_v1", struct_v1);
+    PyDict_SetItemString(dict, "struct_v2", struct_v2);
+
+    Py_DECREF(data);
+    Py_DECREF(name);
+    Py_DECREF(struct_v1);
+    Py_DECREF(struct_v2);
+
+    return dict;
+}
+
+static PyMethodDef qres_methods[] = {
+    {"compile", py_compile, METH_VARARGS,
+     "compile(xml: str, base_dir: str) -> dict\n\n"
+     "Compile a .qrc XML string into Qt resource blobs.\n\n"
+     "Returns a dict with keys: 'data', 'name', 'struct_v1', 'struct_v2'.\n"
+     "base_dir is the directory used to resolve relative file paths in the XML."},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef qres_module = {
+    PyModuleDef_HEAD_INIT,
+    "qres._qres",
+    "Qt resource compiler C extension.",
+    -1,
+    qres_methods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit__qres(void) {
+    return PyModule_Create(&qres_module);
+}

qres-0.1.0/tests/test_compile.py

@@ -0,0 +1,160 @@
+from pathlib import Path
+import pytest
+import qres
+
+
+def test_compile_basic(tmp_path: Path) -> None:
+    asset = tmp_path / "hello.txt"
+    asset.write_text("Hello Qt Resources!", encoding="utf-8")
+
+    qrc = f"""<RCC>
+    <qresource>
+        <file>{asset.name}</file>
+    </qresource>
+</RCC>"""
+
+    blobs = qres.compile(qrc, str(tmp_path))
+    assert "data" in blobs
+    assert "name" in blobs
+    assert "struct_v1" in blobs
+    assert "struct_v2" in blobs
+    assert len(blobs["data"]) > 0
+    assert len(blobs["name"]) > 0
+
+
+def test_compile_with_alias(tmp_path: Path) -> None:
+    asset = tmp_path / "actual_file.txt"
+    asset.write_text("Aliased Content", encoding="utf-8")
+
+    qrc = f"""<RCC>
+    <qresource>
+        <file alias="virtual_alias.txt">{asset.name}</file>
+    </qresource>
+</RCC>"""
+
+    blobs = qres.compile(qrc, str(tmp_path))
+    assert len(blobs["data"]) > 0
+    # In Qt name table, "virtual_alias.txt" is encoded in UTF-16BE
+    alias_bytes = "virtual_alias.txt".encode("utf-16-be")
+    assert alias_bytes in blobs["name"]
+
+
+def test_compile_with_prefix(tmp_path: Path) -> None:
+    asset = tmp_path / "icon.png"
+    asset.write_bytes(b"\x89PNG\r\n\x1a\nfake_png_data")
+
+    qrc = f"""<RCC>
+    <qresource prefix="/icons/toolbar">
+        <file>{asset.name}</file>
+    </qresource>
+</RCC>"""
+
+    blobs = qres.compile(qrc, str(tmp_path))
+    assert len(blobs["data"]) > 0
+    icons_bytes = "icons".encode("utf-16-be")
+    toolbar_bytes = "toolbar".encode("utf-16-be")
+    icon_name_bytes = "icon.png".encode("utf-16-be")
+    assert icons_bytes in blobs["name"]
+    assert toolbar_bytes in blobs["name"]
+    assert icon_name_bytes in blobs["name"]
+
+
+def test_compile_ignores_comments(tmp_path: Path) -> None:
+    asset = tmp_path / "kept.txt"
+    asset.write_text("Keep me", encoding="utf-8")
+
+    qrc = f"""<RCC>
+    <!-- This is a comment: <file>missing.txt</file> -->
+    <qresource>
+        <file>{asset.name}</file>
+    </qresource>
+</RCC>"""
+
+    blobs = qres.compile(qrc, str(tmp_path))
+    assert len(blobs["data"]) > 0
+    missing_bytes = "missing.txt".encode("utf-16-be")
+    assert missing_bytes not in blobs["name"]
+
+
+def test_compile_utf8_filename(tmp_path: Path) -> None:
+    asset = tmp_path / "café_res.txt"
+    asset.write_text("Coffee", encoding="utf-8")
+
+    qrc = f"""<RCC>
+    <qresource>
+        <file>{asset.name}</file>
+    </qresource>
+</RCC>"""
+
+    blobs = qres.compile(qrc, str(tmp_path))
+    expected_utf16be = asset.name.encode("utf-16-be")
+    assert expected_utf16be in blobs["name"]
+
+
+def test_compile_malformed_xml_raises(tmp_path: Path) -> None:
+    qrc = "<RCC><qresource><file>unclosed"
+    with pytest.raises(RuntimeError, match="XML syntax error"):
+        qres.compile(qrc, str(tmp_path))
+
+
+def test_compile_missing_file_raises(tmp_path: Path) -> None:
+    qrc = """<RCC>
+    <qresource>
+        <file>non_existent_asset.txt</file>
+    </qresource>
+</RCC>"""
+    with pytest.raises(RuntimeError, match="Cannot open file"):
+        qres.compile(qrc, str(tmp_path))
+
+
+def test_compile_file_and_binding(tmp_path: Path) -> None:
+    asset = tmp_path / "data.bin"
+    asset.write_bytes(b"\x00\x01\x02\x03")
+
+    qrc_file = tmp_path / "test.qrc"
+    qrc_file.write_text(
+        f"""<RCC>
+    <qresource prefix="assets">
+        <file>{asset.name}</file>
+    </qresource>
+</RCC>""",
+        encoding="utf-8",
+    )
+
+    out_file = tmp_path / "test_rc.py"
+    qres.compile_file(qrc_file, out_file, binding="PySide6")
+
+    assert out_file.exists()
+    content = out_file.read_text(encoding="utf-8")
+    assert "from PySide6 import QtCore" in content
+    assert "qt_resource_data = b\"" in content
+    assert "qt_resource_name = b\"" in content
+    assert "qt_resource_struct_v1 = b\"" in content
+    assert "qt_resource_struct_v2 = b\"" in content
+    assert "qInitResources()" in content
+    assert "qCleanupResources()" in content
+
+
+def test_compile_file_default_auto_binding(tmp_path: Path) -> None:
+    asset = tmp_path / "data.bin"
+    asset.write_bytes(b"\x00\x01")
+
+    qrc_file = tmp_path / "test.qrc"
+    qrc_file.write_text(
+        f"""<RCC>
+    <qresource>
+        <file>{asset.name}</file>
+    </qresource>
+</RCC>""",
+        encoding="utf-8",
+    )
+
+    out_file = tmp_path / "auto_rc.py"
+    qres.compile_file(qrc_file, out_file)
+
+    assert out_file.exists()
+    content = out_file.read_text(encoding="utf-8")
+    assert "except ImportError:" in content
+    assert "from PyQt6 import QtCore" in content
+    assert "from qtpy import QtCore" in content
+