diff --git a/intern/mantaflow/extern/manta_fluid_API.h b/intern/mantaflow/extern/manta_fluid_API.h
index 6827ac35050..e4ad4c66d8a 100644
--- a/intern/mantaflow/extern/manta_fluid_API.h
+++ b/intern/mantaflow/extern/manta_fluid_API.h
@@ -33,44 +33,44 @@ struct MANTA;
 /* Fluid functions */
 struct MANTA *manta_init(int *res, struct FluidModifierData *fmd);
 void manta_free(struct MANTA *fluid);
-int manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *fmd);
-int manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *fmd);
-int manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *fmd);
-int manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *fmd);
-int manta_write_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_write_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_write_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_read_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_read_data(struct MANTA *fluid,
-                    struct FluidModifierData *fmd,
-                    int framenr,
-                    bool resumable);
-int manta_read_noise(struct MANTA *fluid,
+bool manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *fmd);
+bool manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *fmd);
+bool manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *fmd);
+bool manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *fmd);
+bool manta_write_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_write_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_write_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_read_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_read_data(struct MANTA *fluid,
                      struct FluidModifierData *fmd,
                      int framenr,
                      bool resumable);
-int manta_read_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_read_particles(struct MANTA *fluid,
-                         struct FluidModifierData *fmd,
-                         int framenr,
-                         bool resumable);
-int manta_read_guiding(struct MANTA *fluid,
-                       struct FluidModifierData *fmd,
-                       int framenr,
-                       bool sourceDomain);
-int manta_bake_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_bake_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_bake_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_bake_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_bake_guiding(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_has_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_has_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_has_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_has_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
-int manta_has_guiding(struct MANTA *fluid,
+bool manta_read_noise(struct MANTA *fluid,
                       struct FluidModifierData *fmd,
                       int framenr,
-                      bool domain);
+                      bool resumable);
+bool manta_read_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_read_particles(struct MANTA *fluid,
+                          struct FluidModifierData *fmd,
+                          int framenr,
+                          bool resumable);
+bool manta_read_guiding(struct MANTA *fluid,
+                        struct FluidModifierData *fmd,
+                        int framenr,
+                        bool sourceDomain);
+bool manta_bake_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_bake_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_bake_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_bake_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_bake_guiding(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_has_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_has_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_has_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_has_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+bool manta_has_guiding(struct MANTA *fluid,
+                       struct FluidModifierData *fmd,
+                       int framenr,
+                       bool domain);
 
 void manta_update_variables(struct MANTA *fluid, struct FluidModifierData *fmd);
 int manta_get_frame(struct MANTA *fluid);
@@ -113,7 +113,7 @@ float *manta_get_phi(struct MANTA *fluid);
 float *manta_get_pressure(struct MANTA *fluid);
 
 /* Smoke functions */
-void manta_smoke_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
+bool manta_smoke_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
 void manta_smoke_get_rgba(struct MANTA *smoke, float *data, int sequential);
 void manta_noise_get_rgba(struct MANTA *smoke, float *data, int sequential);
 void manta_smoke_get_rgba_fixed_color(struct MANTA *smoke,
@@ -124,9 +124,9 @@ void manta_noise_get_rgba_fixed_color(struct MANTA *smoke,
                                       float color[3],
                                       float *data,
                                       int sequential);
-int manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *fmd);
-int manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *fmd);
-int manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *fmd);
+bool manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *fmd);
+bool manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *fmd);
+bool manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *fmd);
 
 /* Smoke accessors */
 float *manta_smoke_get_density(struct MANTA *smoke);
@@ -147,9 +147,9 @@ float *manta_smoke_get_color_b_in(struct MANTA *smoke);
 float *manta_smoke_get_fuel_in(struct MANTA *smoke);
 float *manta_smoke_get_react_in(struct MANTA *smoke);
 float *manta_smoke_get_emission_in(struct MANTA *smoke);
-int manta_smoke_has_heat(struct MANTA *smoke);
-int manta_smoke_has_fuel(struct MANTA *smoke);
-int manta_smoke_has_colors(struct MANTA *smoke);
+bool manta_smoke_has_heat(struct MANTA *smoke);
+bool manta_smoke_has_fuel(struct MANTA *smoke);
+bool manta_smoke_has_colors(struct MANTA *smoke);
 float *manta_noise_get_density(struct MANTA *smoke);
 float *manta_noise_get_fuel(struct MANTA *smoke);
 float *manta_noise_get_react(struct MANTA *smoke);
@@ -163,14 +163,14 @@ float *manta_noise_get_texture_u2(struct MANTA *smoke);
 float *manta_noise_get_texture_v2(struct MANTA *smoke);
 float *manta_noise_get_texture_w2(struct MANTA *smoke);
 float *manta_noise_get_flame(struct MANTA *smoke);
-int manta_noise_has_fuel(struct MANTA *smoke);
-int manta_noise_has_colors(struct MANTA *smoke);
+bool manta_noise_has_fuel(struct MANTA *smoke);
+bool manta_noise_has_colors(struct MANTA *smoke);
 void manta_noise_get_res(struct MANTA *smoke, int *res);
 int manta_noise_get_cells(struct MANTA *smoke);
 
 /* Liquid functions */
-void manta_liquid_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
-int manta_liquid_ensure_sndparts(struct MANTA *fluid, struct FluidModifierData *fmd);
+bool manta_liquid_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
+bool manta_liquid_ensure_sndparts(struct MANTA *fluid, struct FluidModifierData *fmd);
 
 /* Liquid accessors */
 int manta_liquid_get_particle_res_x(struct MANTA *liquid);
@@ -212,9 +212,6 @@ float manta_liquid_get_snd_particle_position_z_at(struct MANTA *liquid, int i);
 float manta_liquid_get_snd_particle_velocity_x_at(struct MANTA *liquid, int i);
 float manta_liquid_get_snd_particle_velocity_y_at(struct MANTA *liquid, int i);
 float manta_liquid_get_snd_particle_velocity_z_at(struct MANTA *liquid, int i);
-bool manta_liquid_flip_from_file(struct MANTA *liquid);
-bool manta_liquid_mesh_from_file(struct MANTA *liquid);
-bool manta_liquid_particle_from_file(struct MANTA *liquid);
 
 #ifdef __cplusplus
 }
diff --git a/intern/mantaflow/intern/MANTA_main.cpp b/intern/mantaflow/intern/MANTA_main.cpp
index 0dbbd1ee9d0..fef6399ab23 100644
--- a/intern/mantaflow/intern/MANTA_main.cpp
+++ b/intern/mantaflow/intern/MANTA_main.cpp
@@ -458,8 +458,7 @@ bool MANTA::initObstacle(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    mUsingObstacle = true;
-    return runPythonString(pythonCommands);
+    return (mUsingObstacle = runPythonString(pythonCommands));
   }
   return false;
 }
@@ -473,8 +472,7 @@ bool MANTA::initGuiding(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    mUsingGuiding = true;
-    return runPythonString(pythonCommands);
+    return (mUsingGuiding = runPythonString(pythonCommands));
   }
   return false;
 }
@@ -486,8 +484,7 @@ bool MANTA::initFractions(FluidModifierData *fmd)
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
-  mUsingFractions = true;
-  return runPythonString(pythonCommands);
+  return (mUsingFractions = runPythonString(pythonCommands));
 }
 
 bool MANTA::initInVelocity(FluidModifierData *fmd)
@@ -498,8 +495,7 @@ bool MANTA::initInVelocity(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    mUsingInvel = true;
-    return runPythonString(pythonCommands);
+    return (mUsingInvel = runPythonString(pythonCommands));
   }
   return false;
 }
@@ -512,8 +508,7 @@ bool MANTA::initOutflow(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    mUsingOutflow = true;
-    return runPythonString(pythonCommands);
+    return (mUsingOutflow = runPythonString(pythonCommands));
   }
   return false;
 }
@@ -565,7 +560,7 @@ MANTA::~MANTA()
   pythonCommands.push_back(finalString);
   result = runPythonString(pythonCommands);
 
-  assert(result);
+  BLI_assert(result);
   UNUSED_VARS(result);
 }
 
@@ -610,7 +605,7 @@ bool MANTA::runPythonString(vector<string> commands)
   }
   PyGILState_Release(gilstate);
 
-  assert(success);
+  BLI_assert(success);
   return success;
 }
 
@@ -1590,7 +1585,7 @@ bool MANTA::updateVariables(FluidModifierData *fmd)
   return runPythonString(pythonCommands);
 }
 
-void MANTA::exportSmokeScript(FluidModifierData *fmd)
+bool MANTA::exportSmokeScript(FluidModifierData *fmd)
 {
   if (with_debug)
     cout << "MANTA::exportSmokeScript()" << endl;
@@ -1696,9 +1691,14 @@ void MANTA::exportSmokeScript(FluidModifierData *fmd)
   myfile.open(cacheDirScript);
   myfile << final_script;
   myfile.close();
+  if (!myfile) {
+    cerr << "Fluid Error -- Could not export standalone Mantaflow smoke domain script";
+    return false;
+  }
+  return true;
 }
 
-void MANTA::exportLiquidScript(FluidModifierData *fmd)
+bool MANTA::exportLiquidScript(FluidModifierData *fmd)
 {
   if (with_debug)
     cout << "MANTA::exportLiquidScript()" << endl;
@@ -1804,6 +1804,11 @@ void MANTA::exportLiquidScript(FluidModifierData *fmd)
   myfile.open(cacheDirScript);
   myfile << final_script;
   myfile.close();
+  if (!myfile) {
+    cerr << "Fluid Error -- Could not export standalone Mantaflow liquid domain script";
+    return false;
+  }
+  return true;
 }
 
 /* Call Mantaflow Python functions through this function. Use isAttribute for object attributes,
diff --git a/intern/mantaflow/intern/MANTA_main.h b/intern/mantaflow/intern/MANTA_main.h
index 6425614cf4b..163b168e43d 100644
--- a/intern/mantaflow/intern/MANTA_main.h
+++ b/intern/mantaflow/intern/MANTA_main.h
@@ -104,8 +104,8 @@ struct MANTA {
   bool bakeGuiding(FluidModifierData *fmd, int framenr);
 
   /* IO for Mantaflow scene script. */
-  void exportSmokeScript(struct FluidModifierData *fmd);
-  void exportLiquidScript(struct FluidModifierData *fmd);
+  bool exportSmokeScript(struct FluidModifierData *fmd);
+  bool exportLiquidScript(struct FluidModifierData *fmd);
 
   /* Check cache status by frame. */
   bool hasConfig(FluidModifierData *fmd, int framenr);
diff --git a/intern/mantaflow/intern/manta_fluid_API.cpp b/intern/mantaflow/intern/manta_fluid_API.cpp
index e4754131f34..c04180c8c46 100644
--- a/intern/mantaflow/intern/manta_fluid_API.cpp
+++ b/intern/mantaflow/intern/manta_fluid_API.cpp
@@ -37,203 +37,145 @@ void manta_free(MANTA *fluid)
   fluid = nullptr;
 }
 
-int manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *fmd)
+bool manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *fmd)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->initObstacle(fmd);
 }
-int manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *fmd)
+bool manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *fmd)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->initGuiding(fmd);
 }
-int manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *fmd)
+bool manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *fmd)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->initInVelocity(fmd);
 }
-int manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *fmd)
+bool manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *fmd)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->initOutflow(fmd);
 }
 
-int manta_write_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_write_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->writeConfiguration(fmd, framenr);
 }
 
-int manta_write_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_write_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->writeData(fmd, framenr);
 }
 
-int manta_write_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_write_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->writeNoise(fmd, framenr);
 }
 
-int manta_read_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_read_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->readConfiguration(fmd, framenr);
 }
 
-int manta_read_data(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
+bool manta_read_data(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->readData(fmd, framenr, resumable);
 }
 
-int manta_read_noise(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
+bool manta_read_noise(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->readNoise(fmd, framenr, resumable);
 }
 
-int manta_read_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_read_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->readMesh(fmd, framenr);
 }
 
-int manta_read_particles(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
+bool manta_read_particles(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->readParticles(fmd, framenr, resumable);
 }
 
-int manta_read_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool sourceDomain)
+bool manta_read_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool sourceDomain)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->readGuiding(fmd, framenr, sourceDomain);
 }
 
-int manta_bake_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_bake_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->bakeData(fmd, framenr);
 }
 
-int manta_bake_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_bake_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->bakeNoise(fmd, framenr);
 }
 
-int manta_bake_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_bake_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->bakeMesh(fmd, framenr);
 }
 
-int manta_bake_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_bake_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->bakeParticles(fmd, framenr);
 }
 
-int manta_bake_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_bake_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->bakeGuiding(fmd, framenr);
 }
 
-int manta_has_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_has_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->hasData(fmd, framenr);
 }
 
-int manta_has_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_has_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->hasNoise(fmd, framenr);
 }
 
-int manta_has_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_has_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->hasMesh(fmd, framenr);
 }
 
-int manta_has_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
+bool manta_has_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->hasParticles(fmd, framenr);
 }
 
-int manta_has_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool domain)
+bool manta_has_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool domain)
 {
-  if (!fluid || !fmd)
-    return 0;
   return fluid->hasGuiding(fmd, framenr, domain);
 }
 
 void manta_update_variables(MANTA *fluid, FluidModifierData *fmd)
 {
-  if (!fluid)
-    return;
   fluid->updateVariables(fmd);
 }
 
 int manta_get_frame(MANTA *fluid)
 {
-  if (!fluid)
-    return 0;
   return fluid->getFrame();
 }
 
 float manta_get_timestep(MANTA *fluid)
 {
-  if (!fluid)
-    return 0;
   return fluid->getTimestep();
 }
 
 void manta_adapt_timestep(MANTA *fluid)
 {
-  if (!fluid)
-    return;
   fluid->adaptTimestep();
 }
 
 bool manta_needs_realloc(MANTA *fluid, FluidModifierData *fmd)
 {
-  if (!fluid || !fmd)
-    return false;
   return fluid->needsRealloc(fmd);
 }
 
 void manta_update_pointers(struct MANTA *fluid, struct FluidModifierData *fmd, bool flush)
 {
-  if (!fluid || !fmd)
-    return;
   fluid->updatePointers(fmd, flush);
 }
 
@@ -372,11 +314,9 @@ float *manta_get_pressure(MANTA *fluid)
 }
 
 /* Smoke functions */
-void manta_smoke_export_script(MANTA *smoke, FluidModifierData *fmd)
+bool manta_smoke_export_script(MANTA *smoke, FluidModifierData *fmd)
 {
-  if (!smoke || !fmd)
-    return;
-  smoke->exportSmokeScript(fmd);
+  return smoke->exportSmokeScript(fmd);
 }
 
 static void get_rgba(
@@ -452,18 +392,13 @@ void manta_noise_get_rgba_fixed_color(MANTA *smoke, float color[3], float *data,
   get_rgba_fixed_color(color, smoke->getTotalCellsHigh(), data, sequential);
 }
 
-int manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *fmd)
+bool manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *fmd)
 {
-  if (!smoke || !fmd)
-    return 0;
   return smoke->initHeat(fmd);
 }
 
-int manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *fmd)
+bool manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *fmd)
 {
-  if (!smoke || !fmd)
-    return 0;
-
   bool result = smoke->initFire(fmd);
   if (smoke->usingNoise()) {
     result &= smoke->initFireHigh(fmd);
@@ -471,11 +406,8 @@ int manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *fmd)
   return result;
 }
 
-int manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *fmd)
+bool manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *fmd)
 {
-  if (!smoke || !fmd)
-    return 0;
-
   bool result = smoke->initColors(fmd);
   if (smoke->usingNoise()) {
     result &= smoke->initColorsHigh(fmd);
@@ -560,107 +492,104 @@ float *manta_smoke_get_emission_in(MANTA *smoke)
   return smoke->getEmissionIn();
 }
 
-int manta_smoke_has_heat(MANTA *smoke)
+bool manta_smoke_has_heat(MANTA *smoke)
 {
-  return (smoke->getHeat()) ? 1 : 0;
+  return smoke->getHeat() != nullptr;
+  ;
 }
-int manta_smoke_has_fuel(MANTA *smoke)
+bool manta_smoke_has_fuel(MANTA *smoke)
 {
-  return (smoke->getFuel()) ? 1 : 0;
+  return smoke->getFuel() != nullptr;
 }
-int manta_smoke_has_colors(MANTA *smoke)
+bool manta_smoke_has_colors(MANTA *smoke)
 {
-  return (smoke->getColorR() && smoke->getColorG() && smoke->getColorB()) ? 1 : 0;
+  return smoke->getColorR() != nullptr && smoke->getColorG() != nullptr &&
+         smoke->getColorB() != nullptr;
 }
 
 float *manta_noise_get_density(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getDensityHigh() : nullptr;
+  return smoke->getDensityHigh();
 }
 float *manta_noise_get_fuel(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getFuelHigh() : nullptr;
+  return smoke->getFuelHigh();
 }
 float *manta_noise_get_react(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getReactHigh() : nullptr;
+  return smoke->getReactHigh();
 }
 float *manta_noise_get_color_r(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getColorRHigh() : nullptr;
+  return smoke->getColorRHigh();
 }
 float *manta_noise_get_color_g(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getColorGHigh() : nullptr;
+  return smoke->getColorGHigh();
 }
 float *manta_noise_get_color_b(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getColorBHigh() : nullptr;
+  return smoke->getColorBHigh();
 }
 float *manta_noise_get_flame(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getFlameHigh() : nullptr;
+  return smoke->getFlameHigh();
 }
 float *manta_noise_get_texture_u(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getTextureU() : nullptr;
+  return smoke->getTextureU();
 }
 float *manta_noise_get_texture_v(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getTextureV() : nullptr;
+  return smoke->getTextureV();
 }
 float *manta_noise_get_texture_w(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getTextureW() : nullptr;
+  return smoke->getTextureW();
 }
 float *manta_noise_get_texture_u2(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getTextureU2() : nullptr;
+  return smoke->getTextureU2();
 }
 float *manta_noise_get_texture_v2(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getTextureV2() : nullptr;
+  return smoke->getTextureV2();
 }
 float *manta_noise_get_texture_w2(MANTA *smoke)
 {
-  return (smoke && smoke->usingNoise()) ? smoke->getTextureW2() : nullptr;
+  return smoke->getTextureW2();
 }
 
-int manta_noise_has_fuel(MANTA *smoke)
+bool manta_noise_has_fuel(MANTA *smoke)
 {
-  return (smoke->getFuelHigh()) ? 1 : 0;
+  return smoke->getFuelHigh() != nullptr;
 }
-int manta_noise_has_colors(MANTA *smoke)
+bool manta_noise_has_colors(MANTA *smoke)
 {
-  return (smoke->getColorRHigh() && smoke->getColorGHigh() && smoke->getColorBHigh()) ? 1 : 0;
+  return smoke->getColorRHigh() != nullptr && smoke->getColorGHigh() != nullptr &&
+         smoke->getColorBHigh() != nullptr;
+  ;
 }
 
 void manta_noise_get_res(MANTA *smoke, int *res)
 {
-  if (smoke && smoke->usingNoise()) {
-    res[0] = smoke->getResXHigh();
-    res[1] = smoke->getResYHigh();
-    res[2] = smoke->getResZHigh();
-  }
+  res[0] = smoke->getResXHigh();
+  res[1] = smoke->getResYHigh();
+  res[2] = smoke->getResZHigh();
 }
 int manta_noise_get_cells(MANTA *smoke)
 {
-  int total_cells_high = smoke->getResXHigh() * smoke->getResYHigh() * smoke->getResZHigh();
-  return (smoke && smoke->usingNoise()) ? total_cells_high : 0;
+  return smoke->getResXHigh() * smoke->getResYHigh() * smoke->getResZHigh();
 }
 
 /* Liquid functions */
-void manta_liquid_export_script(MANTA *liquid, FluidModifierData *fmd)
+bool manta_liquid_export_script(MANTA *liquid, FluidModifierData *fmd)
 {
-  if (!liquid || !fmd)
-    return;
-  liquid->exportLiquidScript(fmd);
+  return liquid->exportLiquidScript(fmd);
 }
 
-int manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *fmd)
+bool manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *fmd)
 {
-  if (!liquid || !fmd)
-    return 0;
   return liquid->initLiquidSndParts(fmd);
 }
 
@@ -834,16 +763,3 @@ float manta_liquid_get_snd_particle_velocity_z_at(MANTA *liquid, int i)
 {
   return liquid->getSndParticleVelocityZAt(i);
 }
-
-bool manta_liquid_flip_from_file(MANTA *liquid)
-{
-  return liquid->usingFlipFromFile();
-}
-bool manta_liquid_mesh_from_file(MANTA *liquid)
-{
-  return liquid->usingMeshFromFile();
-}
-bool manta_liquid_particle_from_file(MANTA *liquid)
-{
-  return liquid->usingParticleFromFile();
-}