mirror of
https://github.com/anomalyco/hex.git
synced 2026-11-22 21:23:02 +01:00
* x86_64: opt-in Ivy Bridge source build (HEX_X86_BASELINE=ivybridge) * x86_64 ivybridge build: review fixes
374 lines
15 KiB
Rust
374 lines
15 KiB
Rust
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
|
|
fn main() {
|
|
check_windows_split();
|
|
x86_baseline();
|
|
build_version();
|
|
test_build_commit();
|
|
// `hex_dev_onboarding`: the first run's replay strip and its swearing
|
|
// jokes, in debug and `HEX_TEST_BUILD=1` builds only.
|
|
println!("cargo::rustc-check-cfg=cfg(hex_dev_onboarding)");
|
|
if std::env::var_os("CARGO_CFG_DEBUG_ASSERTIONS").is_some()
|
|
|| std::env::var("HEX_TEST_BUILD").as_deref() == Ok("1")
|
|
{
|
|
println!("cargo::rustc-cfg=hex_dev_onboarding");
|
|
}
|
|
// `hex_capture`: the `capture` experiment's code, in every macOS, Linux,
|
|
// and Windows build (`scrawl-capture` is their dependency).
|
|
println!("cargo::rustc-check-cfg=cfg(hex_capture)");
|
|
if matches!(
|
|
std::env::var("CARGO_CFG_TARGET_OS").as_deref(),
|
|
Ok("macos" | "linux" | "windows")
|
|
) {
|
|
println!("cargo::rustc-cfg=hex_capture");
|
|
}
|
|
if std::env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("macos") {
|
|
if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux") {
|
|
// transcribe-cpp's static manifest records OpenBLAS as an absolute
|
|
// link argument, which Cargo does not propagate through the -sys
|
|
// crate to this final binary. Keep it after the static archives so
|
|
// GNU ld's --as-needed does not discard it before seeing cblas_*.
|
|
println!("cargo:rustc-link-arg=-lopenblas");
|
|
}
|
|
if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
|
|
// transcribe-cpp's Vulkan backend links the vulkan-1 import
|
|
// library by name without its search path. The DLL itself ships
|
|
// with the GPU driver, so it is delay-loaded: a missing or
|
|
// Vulkan 1.0 loader must not stop Hex at launch (#1240;
|
|
// `windows::vulkan` keeps ggml off it then).
|
|
println!("cargo:rerun-if-env-changed=VULKAN_SDK");
|
|
if std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64") {
|
|
if let Some(sdk) = std::env::var_os("VULKAN_SDK") {
|
|
println!(
|
|
"cargo:rustc-link-search=native={}",
|
|
PathBuf::from(sdk).join("Lib").display()
|
|
);
|
|
}
|
|
println!("cargo:rustc-link-arg=/DELAYLOAD:vulkan-1.dll");
|
|
println!("cargo:rustc-link-lib=delayimp");
|
|
}
|
|
#[cfg(windows)]
|
|
embed_windows_resources();
|
|
}
|
|
return;
|
|
}
|
|
let output = Command::new("xcode-select")
|
|
.arg("-p")
|
|
.output()
|
|
.expect("xcode-select is required to link ScreenCaptureKit");
|
|
assert!(output.status.success(), "xcode-select -p failed");
|
|
let developer_dir = String::from_utf8(output.stdout).expect("Xcode path must be UTF-8");
|
|
compile_swift_bridge("apple_speech", "HEXAppleSpeechBridge", &[]);
|
|
println!("cargo:rustc-link-lib=framework=AVFAudio");
|
|
println!("cargo:rustc-link-lib=framework=Speech");
|
|
// AVFoundation decodes an imported meeting's audio into a 16 kHz WAV.
|
|
compile_swift_bridge("meeting_import", "HEXMeetingImportBridge", &[]);
|
|
println!("cargo:rustc-link-lib=framework=AudioToolbox");
|
|
// FoundationModels exists only on macOS 26 and later. Weak-link it, and
|
|
// drop the object's strong autolink entry, so Hex still launches on older
|
|
// systems and reports Apple Intelligence as unavailable.
|
|
compile_swift_bridge(
|
|
"apple_intelligence",
|
|
"HEXAppleIntelligenceBridge",
|
|
&["FoundationModels"],
|
|
);
|
|
println!("cargo:rustc-link-arg=-Wl,-weak_framework,FoundationModels");
|
|
compile_swift_bridge("calendar", "HEXCalendarBridge", &[]);
|
|
println!("cargo:rustc-link-lib=framework=EventKit");
|
|
compile_permission_guide();
|
|
println!("cargo:rustc-link-arg=-Wl,-rpath,/usr/lib/swift");
|
|
for runtime in ["swift-5.5/macosx", "swift/macosx"] {
|
|
let swift_runtime = format!(
|
|
"{}/Toolchains/XcodeDefault.xctoolchain/usr/lib/{runtime}",
|
|
developer_dir.trim()
|
|
);
|
|
println!("cargo:rustc-link-arg=-Wl,-rpath,{swift_runtime}");
|
|
}
|
|
}
|
|
|
|
/// The version Hex reports (`HEX_BUILD_VERSION`): the crate version, which
|
|
/// the Release workflow stamps (scripts/set-crate-version.sh), else, for any
|
|
/// other build of the unstamped `0.0.0`, `0.0.0-dev-local-<commit>` with
|
|
/// `-dirty` for uncommitted changes (`0.0.0-dev-local` without git, as in Nix).
|
|
/// It counts as a dev build, so it follows the dev channel's current release.
|
|
/// Fails every OS's build when Cargo.lock puts gpu-allocator and wgpu-hal on
|
|
/// different `windows` crates. wgpu-hal passes D3D12 types into
|
|
/// gpu-allocator, so the split only breaks the Windows build, and
|
|
/// `cargo update -p rune` has re-resolved gpu-allocator onto an older
|
|
/// `windows` twice (#997, #1085). Fix it by setting gpu-allocator's `windows`
|
|
/// (and iana-time-zone's `windows-core`) back to wgpu-hal's version.
|
|
fn check_windows_split() {
|
|
println!("cargo:rerun-if-changed=Cargo.lock");
|
|
let Ok(lock) = std::fs::read_to_string("Cargo.lock") else {
|
|
return;
|
|
};
|
|
let windows = |name: &str| {
|
|
lock.split("[[package]]")
|
|
.find(|block| block.contains(&format!("\nname = \"{name}\"\n")))
|
|
.and_then(|block| {
|
|
block
|
|
.lines()
|
|
.map(|line| line.trim().trim_end_matches(',').trim_matches('"'))
|
|
.find(|dependency| {
|
|
*dependency == "windows" || dependency.starts_with("windows ")
|
|
})
|
|
.map(str::to_owned)
|
|
})
|
|
};
|
|
let (allocator, hal) = (windows("gpu-allocator"), windows("wgpu-hal"));
|
|
assert_eq!(
|
|
allocator, hal,
|
|
"Cargo.lock: gpu-allocator must use wgpu-hal's `windows` crate, or the Windows build breaks"
|
|
);
|
|
}
|
|
|
|
/// `HEX_X86_BASELINE=ivybridge` builds ggml for Ivy Bridge (2012: SSE4.2, AVX,
|
|
/// F16C) instead of the releases' x86-64-v3, for source builds below the release
|
|
/// floor (docs/linux.md, docs/windows.md). Unset, empty, and `v3` keep the
|
|
/// release baseline exactly as CI builds it; any other target ignores the switch.
|
|
fn x86_baseline() {
|
|
println!("cargo::rustc-check-cfg=cfg(hex_x86_ivybridge)");
|
|
println!("cargo:rerun-if-env-changed=HEX_X86_BASELINE");
|
|
println!("cargo:rerun-if-env-changed=TRANSCRIBE_CMAKE_ARGS");
|
|
const RECOMMENDED: &str = "-DGGML_NATIVE=OFF -DGGML_SSE42=ON -DGGML_AVX=ON -DGGML_F16C=ON -DGGML_AVX2=OFF -DGGML_BMI2=OFF -DGGML_FMA=OFF";
|
|
let baseline = std::env::var("HEX_X86_BASELINE").ok();
|
|
match baseline.as_deref() {
|
|
None | Some("" | "v3") => return,
|
|
Some("ivybridge") => {}
|
|
Some(other) => panic!(
|
|
"HEX_X86_BASELINE={other} is not a baseline; use `v3` (the release baseline), `ivybridge`, or leave it unset"
|
|
),
|
|
}
|
|
if !matches!(
|
|
std::env::var("CARGO_CFG_TARGET_OS").as_deref(),
|
|
Ok("linux" | "windows")
|
|
) || std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() != Ok("x86_64")
|
|
{
|
|
return;
|
|
}
|
|
let cmake = std::env::var("TRANSCRIBE_CMAKE_ARGS").unwrap_or_default();
|
|
let arguments = cmake.split_whitespace().collect::<Vec<_>>();
|
|
// Exactly this build's baseline: no AVX2, BMI2, or FMA (the OFF flags), and
|
|
// no stale CMake cache leaving AVX or F16C off (the ON flags).
|
|
for flag in [
|
|
"-DGGML_NATIVE=OFF",
|
|
"-DGGML_SSE42=ON",
|
|
"-DGGML_AVX=ON",
|
|
"-DGGML_F16C=ON",
|
|
"-DGGML_AVX2=OFF",
|
|
"-DGGML_BMI2=OFF",
|
|
"-DGGML_FMA=OFF",
|
|
] {
|
|
assert!(
|
|
arguments.contains(&flag),
|
|
"HEX_X86_BASELINE=ivybridge needs `{flag}` in TRANSCRIBE_CMAKE_ARGS, or ggml keeps \
|
|
its previous CPU baseline: Hex would crash on the processor this build is for, or \
|
|
crawl on it.\n\
|
|
Set TRANSCRIBE_CMAKE_ARGS=\"{RECOMMENDED}\""
|
|
);
|
|
}
|
|
println!("cargo::rustc-cfg=hex_x86_ivybridge");
|
|
}
|
|
|
|
fn build_version() {
|
|
println!("cargo:rerun-if-env-changed=HEX_VERSION");
|
|
let version = std::env::var("CARGO_PKG_VERSION").unwrap();
|
|
// CI builds name their version in HEX_VERSION and check `hex --version`
|
|
// against it, test builds included (they name the crate version).
|
|
if let Some(named) = std::env::var("HEX_VERSION")
|
|
.ok()
|
|
.filter(|named| !named.is_empty())
|
|
{
|
|
println!("cargo:rustc-env=HEX_BUILD_VERSION={named}");
|
|
return;
|
|
}
|
|
if version != "0.0.0" {
|
|
println!("cargo:rustc-env=HEX_BUILD_VERSION={version}");
|
|
return;
|
|
}
|
|
let git = |args: &[&str]| {
|
|
Command::new("git")
|
|
.args(args)
|
|
.output()
|
|
.ok()
|
|
.filter(|output| output.status.success())
|
|
.map(|output| String::from_utf8_lossy(&output.stdout).trim().to_owned())
|
|
};
|
|
let mut version = "0.0.0-dev-local".to_owned();
|
|
if let Some(commit) =
|
|
git(&["rev-parse", "--short=7", "HEAD"]).filter(|commit| !commit.is_empty())
|
|
{
|
|
version = format!("{version}-{commit}");
|
|
if git(&["status", "--porcelain", "--untracked-files=no"])
|
|
.is_some_and(|status| !status.is_empty())
|
|
{
|
|
version.push_str("-dirty");
|
|
}
|
|
let reference = git(&["symbolic-ref", "-q", "HEAD"]);
|
|
for name in ["HEAD", "packed-refs", "index"]
|
|
.into_iter()
|
|
.chain(reference.as_deref())
|
|
{
|
|
if let Some(path) = git(&["rev-parse", "--path-format=absolute", "--git-path", name])
|
|
.filter(|path| std::path::Path::new(path).exists())
|
|
{
|
|
println!("cargo:rerun-if-changed={path}");
|
|
}
|
|
}
|
|
}
|
|
println!("cargo:rustc-env=HEX_BUILD_VERSION={version}");
|
|
}
|
|
|
|
/// A test or local build carries its commit (`HEX_COMMIT`), which the sidebar shows
|
|
/// beside the version.
|
|
fn test_build_commit() {
|
|
println!("cargo:rerun-if-env-changed=HEX_BUILD_CHANNEL");
|
|
println!("cargo:rerun-if-env-changed=HEX_TEST_BUILD");
|
|
println!("cargo:rerun-if-env-changed=HEX_LOCAL_BUILD");
|
|
if std::env::var("HEX_TEST_BUILD").as_deref() != Ok("1")
|
|
&& std::env::var("HEX_LOCAL_BUILD").as_deref() != Ok("1")
|
|
{
|
|
return;
|
|
}
|
|
let git = |args: &[&str]| {
|
|
Command::new("git")
|
|
.args(args)
|
|
.output()
|
|
.ok()
|
|
.filter(|output| output.status.success())
|
|
.map(|output| String::from_utf8_lossy(&output.stdout).trim().to_owned())
|
|
.filter(|value| !value.is_empty())
|
|
};
|
|
let Some(commit) = git(&["rev-parse", "--short=7", "HEAD"]) else {
|
|
return;
|
|
};
|
|
println!("cargo:rustc-env=HEX_COMMIT={commit}");
|
|
let reference = git(&["symbolic-ref", "-q", "HEAD"]);
|
|
for name in ["HEAD", "packed-refs"]
|
|
.into_iter()
|
|
.chain(reference.as_deref())
|
|
{
|
|
if let Some(path) = git(&["rev-parse", "--path-format=absolute", "--git-path", name])
|
|
.filter(|path| std::path::Path::new(path).exists())
|
|
{
|
|
println!("cargo:rerun-if-changed={path}");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Gives the executable its icon and the "Hex" name Explorer and Task
|
|
/// Manager show, whatever the file is called.
|
|
#[cfg(windows)]
|
|
fn embed_windows_resources() {
|
|
let manifest_dir = PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap());
|
|
let output_dir = PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
|
|
let icon = manifest_dir.join("resources/windows/hex.ico");
|
|
println!("cargo:rerun-if-changed={}", icon.display());
|
|
let version = std::env::var("CARGO_PKG_VERSION").unwrap();
|
|
let numeric = version
|
|
.split(['.', '-'])
|
|
.take(3)
|
|
.map(|part| part.parse::<u16>().unwrap_or(0).to_string())
|
|
.chain(std::iter::repeat("0".to_string()))
|
|
.take(4)
|
|
.collect::<Vec<_>>()
|
|
.join(",");
|
|
let script = format!(
|
|
r#"#include <winver.h>
|
|
1 ICON "{icon}"
|
|
1 VERSIONINFO
|
|
FILEVERSION {numeric}
|
|
PRODUCTVERSION {numeric}
|
|
FILEOS VOS_NT_WINDOWS32
|
|
FILETYPE VFT_APP
|
|
BEGIN
|
|
BLOCK "StringFileInfo"
|
|
BEGIN
|
|
BLOCK "040904B0"
|
|
BEGIN
|
|
VALUE "FileDescription", "Hex"
|
|
VALUE "ProductName", "Hex"
|
|
VALUE "FileVersion", "{version}"
|
|
VALUE "ProductVersion", "{version}"
|
|
VALUE "OriginalFilename", "hex.exe"
|
|
VALUE "InternalName", "hex"
|
|
END
|
|
END
|
|
BLOCK "VarFileInfo"
|
|
BEGIN
|
|
VALUE "Translation", 0x409, 1200
|
|
END
|
|
END
|
|
"#,
|
|
icon = icon.display().to_string().replace('\\', "/"),
|
|
);
|
|
let resource = output_dir.join("hex.rc");
|
|
std::fs::write(&resource, script).expect("write the Windows resource script");
|
|
embed_resource::compile(&resource, embed_resource::NONE)
|
|
.manifest_optional()
|
|
.expect("compile the Windows resources");
|
|
}
|
|
|
|
fn compile_permission_guide() {
|
|
println!("cargo:rerun-if-changed=native/permission_guide.m");
|
|
println!("cargo:rustc-link-lib=framework=AppKit");
|
|
println!("cargo:rustc-link-lib=framework=ApplicationServices");
|
|
println!("cargo:rustc-link-lib=framework=AVFoundation");
|
|
println!("cargo:rustc-link-lib=framework=CoreGraphics");
|
|
println!("cargo:rustc-link-lib=framework=CoreImage");
|
|
println!("cargo:rustc-link-lib=framework=IOKit");
|
|
println!("cargo:rustc-link-lib=framework=QuartzCore");
|
|
|
|
cc::Build::new()
|
|
.file("native/permission_guide.m")
|
|
.flag("-fobjc-arc")
|
|
.compile("hex_permission_guide");
|
|
}
|
|
|
|
fn compile_swift_bridge(name: &str, module: &str, without_autolink: &[&str]) {
|
|
let manifest_dir = PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap());
|
|
let output_dir = PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
|
|
let source = manifest_dir.join(format!("src/{name}.swift"));
|
|
let object = output_dir.join(format!("{name}.o"));
|
|
let sdk = Command::new("xcrun")
|
|
.args(["--sdk", "macosx", "--show-sdk-path"])
|
|
.output()
|
|
.expect("xcrun is required to compile Swift bridges");
|
|
assert!(sdk.status.success(), "could not locate the macOS SDK");
|
|
let target = match std::env::var("TARGET").as_deref() {
|
|
Ok("aarch64-apple-darwin") => "arm64-apple-macosx15.0",
|
|
Ok("x86_64-apple-darwin") => "x86_64-apple-macosx15.0",
|
|
Ok(target) => panic!("unsupported macOS target for {module}: {target}"),
|
|
Err(error) => panic!("TARGET is unavailable: {error}"),
|
|
};
|
|
println!("cargo:rerun-if-changed={}", source.display());
|
|
let mut swift = Command::new("xcrun");
|
|
swift.args([
|
|
"swiftc",
|
|
"-parse-as-library",
|
|
"-emit-object",
|
|
"-module-name",
|
|
module,
|
|
"-sdk",
|
|
]);
|
|
swift
|
|
.arg(String::from_utf8_lossy(&sdk.stdout).trim())
|
|
.args(["-target", target]);
|
|
for framework in without_autolink {
|
|
swift.args([
|
|
"-Xfrontend",
|
|
"-disable-autolink-framework",
|
|
"-Xfrontend",
|
|
framework,
|
|
]);
|
|
}
|
|
let status = swift
|
|
.arg(&source)
|
|
.arg("-o")
|
|
.arg(&object)
|
|
.status()
|
|
.expect("xcrun swiftc is required to compile Swift bridges");
|
|
assert!(status.success(), "{module} compilation failed");
|
|
println!("cargo:rustc-link-arg={}", object.display());
|
|
}
|