Change:
Windows executables should contain embedded application manifests [1]. This is especially important for 32-bit executables, because in the absence of a manifest they are subject to UAC installer detection heuristics [2], which may cause unexpected UAC prompts or even complete failure to execute (in unattended contexts) depending on presence of certain keywords in executable's file name.
You beat me by a few hours :) Here is the description I had in : The UAC issue in is caused by a missing in the binaries. We should include the following in all binaries: In an ideal world, we would allow the user to provide a custom manifest should they wish to require UAC elevation, for example. As another example, a user might want to provide entries in order to fully support Windows 8.1 (where the / functions unless is present in the manifest). The VC++ linker has the option for the UAC part. In a traditional MinGW build, this would be implemented something like this: Where would contain something like this (application.manifest would contain the XML stuff above):
I wonder if it would be easier to skip windres altogether and write resource directly into linked executable using .
I use to add manifest but I always felt this is a hack.
As of MSVC 2008, passing to should add the necessary manifest bits for UAC.
In case anyone finds this issue, you can use in a script to solve this:
Hello. It is over 1 year later now since this comment was posted. Is this nasty work around still necessary? Or does the Rust Compiler finally supports embedding Windows Manifest Files and Resources etc. (in anyway whatsoever)? Thanks!

Discussion:
use back::archive::{Archive, METADATA_FILENAME}; use back::rpath; <ins> use back::manifest; </ins> use driver::driver::CrateTranslation; use driver::session::Session; use driver::session;

} session::OutputExecutable => { link_natively(sess, false, obj_filename, &out_filename); <ins> // Windows linker will add an ".exe" extension if there was none let out_filename = match out_filename.extension() { Some(_) => out_filename.clone(), None => out_filename.with_extension(win32::EXE_EXTENSION) }; manifest::postprocess_executable(sess, &out_filename); </ins> } session::OutputDylib => { link_natively(sess, true, obj_filename, &out_filename);

<ins> // Copyright 2013 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // To avoid problems with Windows UAC installer detection heuristics, // Rust-produced executables need an application manifest. // For details, see issue #10512. // No-op on other platforms. use driver::session::Session; use std::path::Path; #[cfg(not(windows))] pub fn postprocess_executable(_sess: Session, _filename: &Path) {} #[cfg(windows)] pub fn postprocess_executable(sess: Session, filename: &Path) { let default_manifest = concat!( "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>", "<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>", "  <trustInfo xmlns='urn:schemas-microsoft-com:asm.v3'>", "    <security>", "      <requestedPrivileges>", "        <requestedExecutionLevel level='asInvoker' uiAccess='false' />", "      </requestedPrivileges>", "    </security>", "  </trustInfo>", "</assembly>"); match windows::embed_manifest(filename, default_manifest) { Ok(_) => (), Err(msg) => sess.err(format!("Could not embed application manifest: {}", msg)) } } #[cfg(windows)] mod windows { use std::libc::types::os::arch::extra::{BOOL,WORD,DWORD,HANDLE,LPCWSTR,LPCVOID}; use std::libc::consts::os::extra::FALSE; use std::cast::transmute; use std::os; // FIXME #9053: should import as_utf16_p from std rather than re-defining here //use std::os::win32::as_utf16_p; fn as_utf16_p<T>(s: &str, f: |*u16| -> T) -> T { let mut t = s.to_utf16(); // Null terminate before passing on. t.push(0u16); t.as_imm_buf(|buf, _len| f(buf)) } #[link_name = "kernel32"] extern "system" { pub fn BeginUpdateResourceW(pFileName: LPCWSTR, bDeleteExistingResources: BOOL) -> HANDLE; pub fn UpdateResourceW(hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPCVOID, cbData: DWORD) -> BOOL; pub fn EndUpdateResourceW(hUpdate: HANDLE, fDiscard: BOOL) -> BOOL; } fn MAKEINTRESOURCEW(id: int) -> LPCWSTR { unsafe{ transmute(id) } } pub fn embed_manifest(filename: &Path, manifest: &str) -> Result<(),~str> { unsafe { let hUpdate = as_utf16_p(filename.as_str().unwrap(), |path| { BeginUpdateResourceW(path, FALSE) }); if hUpdate.is_null() { return Err(format!("failure in BeginUpdateResourceW: {}", os::last_os_error())); } let ok = manifest.as_imm_buf(|p, len| { UpdateResourceW(hUpdate, MAKEINTRESOURCEW(24), // RT_MANIFEST MAKEINTRESOURCEW(1),  // CREATEPROCESS_MANIFEST_RESOURCE_ID 0,                    // LANG_NEUTRAL, SUBLANG_NEUTRAL p as LPCVOID, len as u32) }); if ok == FALSE { return Err(format!("failure in UpdateResourceW: {}", os::last_os_error())); } let ok = EndUpdateResourceW(hUpdate, FALSE); if ok == FALSE { return Err(format!("failure in EndUpdateResourceW: {}", os::last_os_error())); } Ok(()) } } } </ins>

pub mod back { pub mod archive; pub mod link; <ins> pub mod manifest; </ins> pub mod abi; pub mod upcall; pub mod arm;

<ins> // Copyright 2013 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // On Windows this test checks that Rust binaries have an embedded // application manifest and don't trip UAC installer detection // heuristics ("setup" is one of the "installer" keywords). // For details, see issue #10512. // On other platforms this is a no-op. pub fn main() { } </ins>