# Alternatives to `objc2`
`objc2` is quite strict in its approach to interfacing with Objective-C, and encourages writing everything in Rust. This is, however, not always ideal, as our support for Objective-C will always be worse than that of the Objective-C compiler itself.
But there is another way: If you are willing to write a bit of Objective-C glue-code yourself, you can write a C wrapper, and interface with that instead of directly interoperating with Objective-C bindings.
## Example
Let's say you would like to know the user's current locale. This could be done using a C binding like the following:
```objective-c
// src/helper.m
#import <Foundation/Foundation.h>
#import <string.h>
const char* copy_current_locale_identifier(void) {
NSString* identifier = [[NSLocale currentLocale] localeIdentifier];
const char* s = [identifier UTF8String];
return strdup(s);
}
```
Which is compiled in your `build.rs` (uses the `cc` crate).
```rust, ignore
// build.rs
fn main() {
println!("cargo::rerun-if-changed=build.rs");
let mut builder = cc::Build::new();
builder.flag("-xobjective-c");
builder.flag("-fobjc-arc");
builder.flag("-fmodules");
builder.file("src/helper.m");
println!("cargo::rerun-if-changed=src/helper.m");
builder.compile("libhelper.a");
}
```
And then exposed to Rust like this:
```rust, ignore
// src/lib.rs
use libc::free;
use std::ffi::{c_char, c_void, CStr, CString};
extern "C-unwind" {
fn copy_current_locale_identifier() -> *const c_char;
}
pub fn current_locale() -> CString {
let ptr = unsafe { copy_current_locale_identifier() };
let ret = unsafe { CStr::from_ptr(ptr).to_owned() };
unsafe { free(ptr as *mut c_void) };
ret
}
```