Repository navigation
Open
Labels
P2Normal priorityNormal prioritysize:XLToo big: split into sub-issues before it is ReadyToo big: split into sub-issues before it is ReadytrackerTracks work in sub-issues or a checklist; not claimable itselfTracks work in sub-issues or a checklist; not claimable itself
Description
Context
User-authorized conversion of the native OBS build from CMake to Cargo-driven Rust build tooling using cc::Build, beginning with obs-sys crates. The intended deliverable is a working OBS Rust application with the existing feature surface and tests, not only a static core archive.
Requirements carried forward
- Very fast native builds; reuse existing explicit unity groups, make unity configurable, and implement optional cross-platform PCH where beneficial. User explicitly authorizes unity/PCH being optional, superseding BUILD.md always-on for this conversion.
- cc::Build handles native compilation, under soldr cargo; setup-soldr integration must demonstrate actual native compiler/cache reuse rather than assuming an archive restore is a compiler hit.
- Preserve public C ABI, existing Rust ports, libobs and libobs-with-rust compatibility checks, shared libraries, plugin loading, generated configuration/manifests, graphics backends, Qt/frontend, resources and packaging capabilities.
- All supported platform configurations remain in scope; host-dependent implementation belongs behind platform modules. No public header or existing C test changes to accommodate the new build.
- One canonical build description; no permanent independently maintained source lists for application and bundled crate.
Implementation and acceptance
- RED then GREEN native-build contract: compile a library and separately loaded plugin through cc::Build, exercise dynamic linking, and validate configuration/input invalidation.
- Add typed native target/dependency/configuration model and obs-sys crate integration; generate outputs in build directories, never select stale same-named source-tree outputs.
- Build both real libobs variants, check dynamic exports and unchanged C test suites; preserve Rust unit/differential tests.
- Convert application and plugin targets, generated Qt code and resources, runtime layout and platform linking; demonstrate startup, scenes, recording, plugin loading, clean shutdown and applicable websocket Tier 4 tests against the new artifacts.
- Integrate the new path into existing CI/setup-soldr lanes without new workflow files. Compare cold, warm, no-change and edited-input builds; verify cache correctness and unity/PCH options. Packaging validation runs packaged artifacts with saved representative profiles.
- Retire CMake as the authoritative OBS build only after the above coverage is demonstrated. An intermediate slice or one successful platform is progress, not completion of this issue.
Decisions
The existing build is the behavioral/artifact reference during migration. Native compiles use cc::Build; shared linking, code generation and packaging need explicit Rust orchestration because cc only makes object files/static archives. Source code is not being ported by this task. Applicable compatibility tests remain required. Full completion requires evidence for the entire requested application build, not a fixture or libobs-only smoke test.
Metadata
Metadata
Assignees
Labels
P2Normal priorityNormal prioritysize:XLToo big: split into sub-issues before it is ReadyToo big: split into sub-issues before it is ReadytrackerTracks work in sub-issues or a checklist; not claimable itselfTracks work in sub-issues or a checklist; not claimable itself
Type
Projects
- StatusShow more project fieldsTracker
Activity
zackees commentedon Oct 17, 2026
Claiming: Cargo/cc::Build conversion. 1. Establish RED native shared-library/plugin and rebuild contracts, then implement the Rust build engine. 2. Bring up the real libobs pair and unchanged compatibility tests. 3. Convert frontend/plugins/resources/platform packaging and verify real application behavior and cache performance. Decisions: preserve the full scope recorded above; unity and PCH are optional as explicitly requested. First draft PR will open with the initial RED contract.
build: compile and dynamically link native targets with cc::Build (GR…
test(build): require the bundled obs-sys crate to build real libobs (…
build: add opt-in Cargo/cc::Build OBS prototype (obs-rust#1333)
zackees commentedon Oct 21, 2026
Coordinating #1587: user-authorized promotion of hybrid Rust/C libobs to the normal application default, with explicit C-reference/rollback builds. This will reuse libobs/build/source-sets.json and preserve the Cargo/cc::Build engine; its backend selection and integration tests will be updated where needed. No competing source manifest or build-system replacement.
zackees commentedon Oct 21, 2026
#1587 / draft #1588 now promotes the hybrid to installed libobs and updates the shared Cargo engine entry points.
libobs::build_with_options/ bundled obs-sys require an externally built release archive via OBS_BUILD_RUST_ARCHIVE; explicit C rollback isbuild_c_reference_with_options/ OBS_SYS_C_ROLLBACK=1.build_pairremains explicit compatibility infrastructure. The canonical source-sets.json is unchanged.Real native validation passed: normal production API builds a hybrid with 1,766 exports and no C-reference output; the explicit pair passes all 59 listed unchanged C executables against each backend (118 runs), plus lifecycle/plugin checks. The run found and fixed archive link order under --as-needed, missing output_delay_fields_stub.c in the native test manifest, stale 52-test inventory, and preserving the selected core dependency for standalone characterizations. Comparison helpers now reject duplicate backend paths. No C test bodies or public headers were edited in this migration.
Packaging/default selection is tracked in #1588; this does not replace or complete #1332's full application build-engine migration. Final platform CI is running in verification-only mode; no merge or release.
zackees commentedon Oct 21, 2026
Taking over stale claim: resuming the full Cargo/cc::Build conversion at the maintainer’s explicit request. Plan: 1. Audit the merged prototype against all six acceptance requirements and current hybrid-default policy. 2. Complete production orchestration and remaining platform/plugin/configuration graphs sequentially, with RED/GREEN evidence. 3. Validate application behavior, unchanged tests, cache/invalidation and packaging on supported configurations, integrate existing CI lanes, and retire CMake authority only after that evidence exists. Prototype progress is not completion. Working in the existing checkout without a Git worktree.
zackees commentedon Oct 21, 2026
Resumed #1332 after aligning the clean obs-websocket submodule checkout with the parent repository's recorded commit (no source edits or gitlink changes).
Merged dependent build-engine step #1664: Objective-C/Objective-C++ inputs now retain their language in ordered compilation batches and generated unity files; individual-source expansion handles
.m.h/.mm.hpp; optional PCH uses its consumer language and separate identity.RED evidence: e81621b fails group expansion; cc45065 selects the actual subprocess contract and fails at unsupported
.m. GREEN 771a0fd passes all 12 native-build contracts, including dynamic loading and header rebuilds across four unity/PCH configurations on Linux Clang. Targeted formatting and Clippy pass; one read-only reviewer found no actionable findings. PR CI 39685451899 and merge-group CI 39685930359 both passed. Merged as dd8a7a6.This is progress, not completion of #1332. No macOS application run is claimed. Remaining full-scope work includes target-specific macOS/Windows graphs and SDK/tool/resource/link integration, production application orchestration, missing plugins and native-test coverage, existing CI/setup-soldr integration with measured cache/invalidation behavior, and packaged saved-profile runtime validation. CMake remains authoritative until the original acceptance requirements are proven. Next prerequisite: language-scoped Objective-C ARC configuration and the real macOS core source/framework graph.
zackees commentedon Oct 21, 2026
Merged the next dependent prerequisite, #1665: native targets can supply Objective-C and Objective-C++ flags separately. Only matching language batches receive them, before PCH generation, so ARC and its PCH settings do not contaminate C/C++.
RED 8b60093 fails actual Clang compilation with missing ARC/language flags. GREEN 67f86fc passes all 12 native-build contracts. The strengthened existing mixed-language contract compiles/links/loads all four unity/PCH configurations, detects cross-language flag leakage, observes changed headers, and separately changes each language's macro to require changed loaded results. Formatting, targeted Clippy, and a single independent read-only review pass. PR run 39686815106 and merge-group run 39687448440 passed; #1665 is merged.
Full #1332 remains incomplete. Language defaults alone do not represent the real macOS core: its cocoa groups use ARC while its loader group explicitly does not. Next dependent implementation is per-source compiler options that survive individual-source expansion, keep ARC/non-ARC PCH identities separate, and wire the real macOS core graph from the canonical source manifest. The host has the Apple 14.5 SDK, Darwin linker and existing universal OBS dependency bundle available for cross-compilation; cross-compilation cannot establish macOS runtime behavior. Full app/plugin/platform/CI/cache/packaging requirements remain unchanged and CMake remains authoritative until proven complete.
zackees commentedon Oct 21, 2026
PR #1669 is ready and waiting for final-head CI (
dcbb4e450; run 39690343380). Auto-merge is enabled through the normal queue. The checkout is clean on the pushed branch; no worktree is used.Implemented the canonical macOS core graph, source-specific ARC/non-ARC compilation and annotation-preserving individual-source expansion, Mac Clang PCH, explicit native dependency bundle selection, preserved framework install identity/deployment target, Rust export hiding and HEVC selection, development framework lookup layout, and bundled obs-sys input tracking. Existing macOS Tier 2 now builds the Cargo pair, compares actual CMake exports, proves dyld loaded each Cargo core and runs the unchanged CMake-built CTest executables against each. No workflow files, public headers, existing C tests or submodule pointers were changed.
RED baf114e fails mixed ARC/manual compilation. RED b285174 fails the missing real macOS graph. GREEN cfb8a1e plus SIMD-alignment follow-up dcbb4e4 implements the graph. Local checkpoints: 14 native contracts pass; ARM64 pair passes all four unity/PCH modes (1,877 matching exports), Intel pair passes (1,877), HEVC-disabled ARM64 pair passes (1,873), and bundled obs-sys ARM64 cross-build passes. The final SIMD-alignment follow-up passes the real ARM64 pair again. Formatting, targeted Clippy, shell syntax and one read-only review pass (including a review of the follow-up).
These local checks cross-compile using Apple SDK 14.5 and the universal OBS dependency bundle on Linux. They do not establish actual macOS runtime behavior or controlled performance. Required next action: monitor final-head CI, fix any actual macOS loader/CTest failures, then merge #1669 through the queue. Full #1332 remains open: macOS application/graphics/plugins, Windows graphs, native test graph coverage, production orchestration, measured cache/invalidation/CI behavior and release packaging validation are still required before CMake authority can be retired.
zackees commentedon Oct 21, 2026
Progress on #1332 via #1669:
dcbb4e450: 1,877 matching exports; bundledobs-syscompilation; loader selection of the Cargo-built cores; all 199 unchanged native tests passed against each Cargo reference/hybrid core.7c03fac8auses fresh processes in the existing test executable, retaining every expected value and rebuild mode. All 14 native contracts pass locally.Remaining work still includes the Windows native graph (including resources and MSVC PCH), macOS graphics/plugins/frontend, complete production orchestration and native test graph, supported configuration coverage, compiler-cache/performance evidence, and packaged application runs with representative saved profiles. CMake remains authoritative until the full application acceptance criteria are proven. This core implementation does not complete #1332.
zackees commentedon Oct 21, 2026
#1669 merged as
74d62835ccdf4feaf1555a87004657db0b9c7194. Both final-head CI (39692497038) and merge-result CI (39694400721) passed. Actual macOS validation includes the Cargo core pair, exact exports, bundled obs-sys and 199 unchanged native tests against each Cargo core. Objective-C rebuild fixtures now use fresh processes; the actual macOS Rust lane passes.Continuing sequentially in the same checkout with Windows core support: native resources, MSVC PCH/object handling, canonical Windows source/export selection and explicit OBS dependency bundle inputs, followed by existing Windows Tier 2 validation against the Cargo artifacts. The Windows SDK and dependency bundle are available locally; DLL/import-library, resource and clang-cl PCH probes have passed.
The full application scope remains open: graphics/plugins/frontend and runtime layout across supported platforms, production orchestration/configurations, native tests, compiler-cache/build measurements and packaged runs with saved representative profiles. CMake remains authoritative until those criteria are satisfied.
zackees commentedon Oct 22, 2026
Windows core conversion in #1679 is GREEN on the final PR head (
12418cb39), and is now in the normal merge queue.Native Windows evidence: 1,794 exports exactly match the CMake reference; the Cargo reference and hybrid each pass all 174 unchanged native tests. Positive DLL file-identity checks and wrong-file negative controls pass for both cores. Resource payload/input invalidation, mixed-language MSVC PCH/object linking, bundled obs-sys and Clippy also pass. Full pair validation uses unity/PCH enabled; bundled obs-sys uses PCH disabled.
PR run: https://github.com/obs-rust/obs-studio/actions/runs/39701275263
Merge-result run (still active): https://github.com/obs-rust/obs-studio/actions/runs/39703158719
This remains core progress toward the full issue. Windows/macOS graphics, plugins and frontend; full native test build coverage; release/configuration and runtime layout; packaging with representative saved profiles; supported architecture/configuration coverage; and controlled native compiler/cache performance evidence remain required. CMake remains authoritative until the complete acceptance criteria are met.
14 remaining items
zackees commentedon Oct 22, 2026
Progress: canonical native test graph merged (#1805)
Merged as
cca43512a622f29dfcc05e7dc1db5b220fda3206through the normal queue. PR CI39866230018and merge-result CI39868534511passed; no admin merge.The shared graph now owns 152 definitions (132 core, 12 graphics, 6 VLC, 2 WHIP); the independent Linux manifest and separate graphics/VLC/WHIP compilation lists are removed. Sources, dependency interfaces, platform/feature guards, runtime commands and indirect inputs are represented for these cases. Original C tests and public headers were preserved.
Local proof: 288 unchanged native core/graphics executions against both cores, all 152 canonical targets compiled through CMake, and 144 CMake core/graphics runtime cases; zero skips/failures. Merge-result CI ran 375 registered Linux cases per mode with zero failures and four PulseAudio environment skips; Windows passed four compatibility runs of 189 cases each, macOS four of 214 each. Non-Linux component checks still use CMake-compiled test executables; they are not full Cargo application proof.
The full issue remains incomplete. CMake is still authoritative. A literal scan finds 222 remaining independent executable declarations (loops/other directories also require evaluation). Missing work includes language/code-generation/export metadata for remaining C++/Qt/scripting tests, non-Linux Cargo test/application orchestration, full configuration coverage, compiler-cache evidence across the complete graph, and packaged saved-profile validation before authority retirement.
Continuing claim, one PR at a time: next add typed language-standard requirements to the shared model/consumers and migrate applicable Qt-free C++ tests with their explicit C++17 settings preserved. Start with a failing contract, prove actual compiler/runtime behavior, and retain unchanged C++ test sources. No worktree or new workflow files.
zackees commentedon Oct 23, 2026
PR #1844 landed through the normal merge queue as a901385. The merged-result workflow passed: https://github.com/obs-rust/obs-studio/actions/runs/39877842636
This adds typed C++ language-standard requirements shared by Cargo and CMake, migrates six unchanged Qt-free C++ helper tests into the canonical graph, and preserves their source order, link edges, and indirect PCH watches. The graph now describes 158 targets. Actual mixed C/C++20 contract checks passed on the supported hosted platforms. The Windows safe-write parity isolation fix also passed and #1849 closed automatically.
Local native proof for this slice covered 300 core/graphics executions, all 158 canonical CMake targets compiling, and 150 core/graphics CMake cases passing without skips. Merged-result Linux compatibility runs each registered 375 cases with the four existing PulseAudio environment skips; Windows and macOS native compatibility jobs passed as well.
#1332 remains open. CMake stays authoritative. Next is the remaining Qt/generated-code and runtime environment contract work, followed by the remaining complete-application, configuration, packaging, and performance acceptance requirements. Work continues one PR at a time in the existing checkout.
zackees commentedon Oct 23, 2026
Claiming: continuing #1332 after #1844 merged, on
infra/1332-canonical-qt-testsin the existing checkout.Open-PR searches found no existing #1332 or canonical Qt PR. First PR follows the RED contract and local evidence; work proceeds one PR at a time, with no worktree.
zackees commentedon Oct 23, 2026
PR #1853 merged normally as b87e0a4. Both current-head CI and merge-result CI passed; merge-result run: https://github.com/obs-rust/obs-studio/actions/runs/39885556054
The canonical graph now has 159 targets, including the unchanged remux queue model test. Both consumers support priority includes, declared Qt moc/UI/resource inputs and ordered runtime path prepending. Imported Qt runtime interfaces are resolved before launching Cargo-built tests; CMake retains the original per-target AUTOMOC and Qt runtime helper. Generated UI filename collisions are rejected before selection.
Evidence includes actual Cargo/CMake Qt generation and execution on Linux (metaobject method invocation, generated widget UI, embedded resources, stale source header control, two targets sharing a moc header), plus the unchanged remux test through both consumers. Hosted Qt passed all 19 tests, and native macOS/Windows compatibility checks passed on the final head and merge result. The macOS manual-moc generation failure was fixed by preserving original AUTOMOC; the include-order regression was fixed using a single ordered BEFORE include operation.
This does not complete #1332. CMake remains authoritative. Remaining work includes Qt SDK discovery/runtime integration for Cargo on non-Linux hosts, the remaining canonical test/application inventory, full supported configurations and complete app orchestration, compiler/cache evidence, packaging and representative saved-profile runtime acceptance. Continuing one PR at a time in the existing checkout.
zackees commentedon Oct 23, 2026
Claiming: continuing #1332 after #1853 merged, on
infra/1332-cargo-native-profiles, in the existing checkout.Decisions: Cargo DEBUG describes debug symbols, not assertions. Cargo PROFILE loses custom profile settings; use effective OPT_LEVEL/DEBUG instead. Cargo does not expose a reliable target debug-assertion value to build scripts, so native assertion policy must be independent and explicitly configurable; do not infer it from DEBUG or claim arbitrary Rust profile assertion settings are discovered. Preserve all native optimization levels rather than silently folding custom levels into the four CMake names.
No open #1332 PR was found. First PR follows configuration RED/GREEN evidence; no worktree or concurrent milestone.
zackees commentedon Oct 23, 2026
PR #1856 merged normally as a72aa4a. Current-head and merge-result CI passed; merge-result run: https://github.com/obs-rust/obs-studio/actions/runs/39889858959
Bundled obs-sys now selects native optimization/debug symbols from effective Cargo OPT_LEVEL/DEBUG instead of hardcoding RelWithDebInfo. The shared model retains all Cargo optimization levels and the four explicit native profiles. Native assertions have an independent documented policy and override; Swift receives explicit assertion configuration. Configuration inputs are tracked for rebuilds and invalid values rejected.
Evidence: focused parsing/custom-level checks and actual same-output native rebuild/fresh-load assertion tests passed; all four actual bundled obs-sys tests (including native startup/shutdown under Xvfb) passed on Linux; native macOS executed the extended Swift fixture for optimized/assertions-enabled and unoptimized/assertions-disabled cases, with all 57 application tests passing. Hosted Windows and macOS compatibility checks passed on both PR head and merge result. Lint and the sole primary review passed.
#1332 remains open. This establishes configuration selection, not full supported-application acceptance. Remaining requirements include complete canonical target/application coverage on supported platforms, Qt SDK/runtime discovery for Cargo on non-Linux hosts, full configurations and compiler/cache/unity/PCH evidence, packaging, saved representative capture profiles, and runtime/protocol acceptance. CMake remains authoritative until that complete acceptance is demonstrated. Continuing one PR at a time in the existing checkout.
zackees commentedon Oct 23, 2026
Releasing #1332 at the maintainer’s request for handoff to another agent. Completed milestones are merged. Draft handoff: #1868 (documentation only); next claimable Qt SDK task: #1869. CMake remains authoritative and this parent remains open. No further implementation or merge will be performed by this run.
zackees commentedon Oct 25, 2026
Triage: a tracker, not one task. It's XL and the maintainer authorized it. Several milestones merged (#1333 prototype, #1805, #1844, #1853, #1856), the claim was released for handoff, and the next named task, #1869 (Qt SDK interfaces), is now closed (fixed by #1877). CMake stays authoritative. Per WORKFLOW.md, an XL issue's work goes through sub-issues: the next step is to file the next Cargo-build slice (for example, the next app target or plugin group built through
cc::Buildwith its parity check) as its own Ready issue and attach it here. Labelledtracker, P2.