diff --git a/crates/solidity/src/process/worker_process.rs b/crates/solidity/src/process/worker_process.rs
index 8745ab69..81c65298 100644
--- a/crates/solidity/src/process/worker_process.rs
+++ b/crates/solidity/src/process/worker_process.rs
@@ -9,6 +9,7 @@ use super::Input;
 use super::Output;
 use super::Process;
 
+use anyhow::Context;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -87,8 +88,14 @@ impl Process for WorkerProcess {
             unsafe { resolc_compile(input_cstring.as_ptr(), input_cstring.as_bytes().len()) };
 
         // Convert the output pointer back to a Rust string
-        let output_str = unsafe { CStr::from_ptr(output_ptr).to_string_lossy().into_owned() };
+        let output_str = unsafe {
+            CStr::from_ptr(output_ptr)
+                .to_str()
+                .with_context(|| "Failed to convert C string to Rust string")
+                .map(str::to_owned)
+        };
         unsafe { libc::free(output_ptr as *mut c_void) };
+        let output_str = output_str?;
         let response: Response = serde_json::from_str(&output_str)
             .map_err(|error| anyhow::anyhow!("Worker output parsing error: {}", error,))?;
         match response {
diff --git a/crates/solidity/src/solc/soljson.rs b/crates/solidity/src/solc/soljson.rs
index deb5f5c4..5858a897 100644
--- a/crates/solidity/src/solc/soljson.rs
+++ b/crates/solidity/src/solc/soljson.rs
@@ -8,6 +8,7 @@ use crate::compiler::pipeline::Pipeline;
 use crate::compiler::standard_json::input::Input as StandardJsonInput;
 use crate::compiler::standard_json::output::Output as StandardJsonOutput;
 use crate::compiler::version::Version;
+use anyhow::Context;
 use std::ffi::{c_char, c_void, CStr, CString};
 
 use super::Compiler;
@@ -17,24 +18,30 @@ extern "C" {
     fn soljson_compile(inputPtr: *const c_char, inputLen: usize) -> *const c_char;
 }
 
-fn get_soljson_version() -> String {
+fn get_soljson_version() -> anyhow::Result<String> {
     unsafe {
         let version_ptr = soljson_version();
-        let version = CStr::from_ptr(version_ptr).to_string_lossy().into_owned();
+        let version = CStr::from_ptr(version_ptr)
+            .to_str()
+            .with_context(|| "Failed to convert C string to Rust string")
+            .map(str::to_owned);
         libc::free(version_ptr as *mut c_void);
-        version
+        Ok(version?)
     }
 }
 
-pub fn compile_standard_json(input: String) -> String {
+pub fn compile_standard_json(input: String) -> anyhow::Result<String> {
     let c_input = CString::new(input).unwrap();
     let c_input_len = c_input.as_bytes().len();
 
     unsafe {
         let output_ptr = soljson_compile(c_input.as_ptr(), c_input_len);
-        let output_json = CStr::from_ptr(output_ptr).to_string_lossy().into_owned();
+        let output_json = CStr::from_ptr(output_ptr)
+            .to_str()
+            .with_context(|| "Failed to convert C string to Rust string")
+            .map(str::to_owned);
         libc::free(output_ptr as *mut c_void);
-        output_json
+        Ok(output_json?)
     }
 }
 
@@ -58,7 +65,7 @@ impl Compiler for SoljsonCompiler {
         let suppressed_warnings = input.suppressed_warnings.take().unwrap_or_default();
 
         let input_json = serde_json::to_string(&input).expect("Always valid");
-        let out = compile_standard_json(input_json);
+        let out = compile_standard_json(input_json)?;
         let mut output: StandardJsonOutput = revive_common::deserialize_from_slice(out.as_bytes())
             .map_err(|error| {
                 anyhow::anyhow!(
@@ -88,7 +95,7 @@ impl Compiler for SoljsonCompiler {
     }
 
     fn version(&mut self) -> anyhow::Result<Version> {
-        let version = get_soljson_version();
+        let version = get_soljson_version()?;
         let long = version.clone();
         let default: semver::Version = version
             .split('+')