Building efficient Rust executables with minimal size requires strategic optimization techniques. I’ll share my experience implementing these methods in production environments.

Rust’s dead code elimination excels at removing unused functions during compilation. In my projects, I frequently employ the #[cfg] attribute to control code inclusion:

#[cfg(not(feature = "extended"))]
fn specialized_calculation() {
    // This function gets removed if "extended" feature is disabled
    perform_complex_math();
}

#[cfg(feature = "minimal")]
fn basic_operation() {
    // Simple implementation for minimal builds
}

Custom allocators provide significant size reductions in resource-constrained systems. I’ve implemented several minimal allocators:

use core::alloc::{GlobalAlloc, Layout};

struct CompactAllocator;

unsafe impl GlobalAlloc for CompactAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        let size = layout.size();
        let align = layout.align();
        // Basic allocation logic
        system_allocate(size, align)
    }
    
    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
        system_free(ptr)
    }
}

#[global_allocator]
static ALLOCATOR: CompactAllocator = CompactAllocator;

Feature flags enable flexible compilation configurations. I manage them in Cargo.toml:

[features]
default = ["std"]
std = []
minimal = []

The corresponding code adapts based on these features:

#[cfg(feature = "std")]
use std::vec::Vec;

#[cfg(not(feature = "std"))]
use custom_vec::Vec;

pub fn process_data(input: &[u8]) -> Vec<u8> {
    // Implementation varies based on features
}

Link Time Optimization (LTO) significantly reduces binary size. My release profile typically includes:

[profile.release]
lto = true
codegen-units = 1
opt-level = 'z'
panic = "abort"
strip = true

Symbol stripping removes debug information. I implement this through compilation flags and code structure:

#[cfg(not(debug_assertions))]
#[inline(always)]
fn debug_trace() {}

#[cfg(debug_assertions)]
fn debug_trace() {
    println!("Debug info: {}", get_detailed_state());
}

Dependency management proves crucial for size optimization. I carefully select dependencies and disable unnecessary features:

[dependencies]
tiny-vec = { version = "1.0", default-features = false }
serde = { version = "1.0", optional = true, features = ["derive"] }
log = { version = "0.4", default-features = false }

Additional optimization strategies I’ve found effective include using const generics:

pub struct Buffer<const N: usize> {
    data: [u8; N],
    position: usize,
}

impl<const N: usize> Buffer<N> {
    pub const fn new() -> Self {
        Self {
            data: [0; N],
            position: 0,
        }
    }
}

Inlining critical functions helps reduce function call overhead:

#[inline(always)]
pub fn critical_operation(value: u32) -> u32 {
    value.wrapping_mul(7)
}

Using platform-specific optimizations when appropriate:

#[cfg(target_arch = "x86_64")]
pub fn optimize_for_platform(data: &[u8]) -> u64 {
    // x86_64 specific implementation
}

#[cfg(target_arch = "arm")]
pub fn optimize_for_platform(data: &[u8]) -> u64 {
    // ARM specific implementation
}

The shared memory approach reduces duplicate data:

use std::sync::Arc;

struct SharedConfig {
    settings: Arc<Settings>,
    cache: Arc<Cache>,
}

Implementing custom serialization for better control:

impl Serialize for CompactStructure {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Custom compact serialization logic
        let mut state = serializer.serialize_struct("CompactStructure", 2)?;
        state.serialize_field("d", &self.data)?;
        state.end()
    }
}

Using static storage where possible:

static LOOKUP_TABLE: [u8; 256] = {
    let mut table = [0u8; 256];
    // Initialize table at compile time
    table
};

Implementing zero-copy operations:

pub fn process_in_place(buffer: &mut [u8]) {
    for byte in buffer.iter_mut() {
        *byte = byte.wrapping_add(1);
    }
}

These techniques combined have helped me achieve significant size reductions in Rust executables. The key lies in applying them strategically based on specific project requirements and constraints.

For optimal results, I regularly measure binary size impact using tools like cargo-bloat and tweak optimization strategies accordingly. This iterative process helps maintain a balance between functionality and size efficiency.

Remember that some optimizations might increase compilation time or complexity. I always benchmark and profile to ensure the trade-offs align with project goals.

When implementing these techniques, consider the maintenance impact and document optimization decisions for future reference. This helps team members understand the reasoning behind specific optimization choices.