diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
new file mode 100644
index 0000000000..0e825c5712
--- /dev/null
+++ b/cmake/CMakeLists.txt
@@ -0,0 +1,484 @@
+cmake_minimum_required(VERSION 3.18)
+
+#[==============================================================================[
+#                         Basic project definition                              #
+#]==============================================================================]
+project(MOM6
+             DESCRIPTION "Modular Ocean Model6"
+             HOMEPAGE_URL https://github.com/ACCESS-NRI/MOM6
+             LANGUAGES C Fortran)
+
+#[==============================================================================[
+#                           Project configuration                               #
+#]==============================================================================]
+# Configurations to build
+option(ACCESS3_MOM6  "Building MOM6 library with Access3share" ON)
+
+message(STATUS "Configuration")
+message(STATUS " Building MOM6 library with Access3share " ${ACCESS3_MOM6})
+
+# build options
+option(ENABLE_MOM_SYMMETRIC              "Use MOM symmetric memory" ON )
+option(CESMCOUPLED                       "Use CESMCOUPLED"          OFF)
+
+if (CESMCOUPLED AND NOT ACCESS3_MOM6)
+  message(FATAL_ERROR "ENABLE_CESMCOUPLED can only be set if ACCESS3_MOM6 is ON.")
+endif()
+
+message(STATUS "Build options")
+message(STATUS "MOM_SYMMETRIC               ${ENABLE_MOM_SYMMETRIC}"             )
+message(STATUS "CESMCOUPLED                 ${CESMCOUPLED}"               )
+
+#[==============================================================================[
+#                           Project configuration                               #
+#]==============================================================================]
+# include libraries
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR})
+include(GNUInstallDirs)
+include(FortranLib)
+include(CompilerFlags)
+include(CMakePackageConfigHelpers)
+
+# Precessor (macro) definitions
+add_compile_definitions(_USE_GENERIC_TRACER _USE_MOM6_DIAG)
+
+if (CESMCOUPLED)
+  add_compile_definitions(CESMCOUPLED)
+endif()
+
+## Fortran modules path; currently this is simply set to be the include dir
+set(CMAKE_INSTALL_MODULEDIR ${CMAKE_INSTALL_INCLUDEDIR}
+  CACHE STRING
+  "Fortran module installation path (Not a cmake native variable)"
+)
+
+#[==============================================================================[
+#                              External packages                                #
+#]==============================================================================]
+find_package(NetCDF REQUIRED Fortran)
+
+if (NOT NetCDF_PARALLEL)
+    message(FATAL_ERROR "NetCDF does not have parallel I/O support!")
+endif()
+
+find_package(fms COMPONENTS R8 REQUIRED)
+
+if (ACCESS3_MOM6)
+  find_package(ESMF 8.3.0 MODULE REQUIRED)
+  find_package(Access3Share REQUIRED cdeps timing share nuopc_cap_share)
+endif()
+
+
+### Targets
+
+## MOM6 library
+
+# set paths for the source code and config source
+set(SRC "${CMAKE_SOURCE_DIR}/../src")
+set(CONFIG_SRC "${CMAKE_SOURCE_DIR}/../config_src")
+
+add_fortran_library(mom6lib mod STATIC)
+
+target_include_directories(mom6lib PRIVATE $<BUILD_INTERFACE:${SRC}/framework>)
+
+if(ENABLE_MOM_SYMMETRIC)
+  set(MOM_MEMORY_DIR $<BUILD_INTERFACE:${CONFIG_SRC}/memory/dynamic_symmetric>)
+else()
+  set(MOM_MEMORY_DIR $<BUILD_INTERFACE:${CONFIG_SRC}/memory/dynamic_nonsymmetric>)
+endif()
+target_include_directories(mom6lib PRIVATE ${MOM_MEMORY_DIR})
+
+target_compile_options(mom6lib PRIVATE "$<$<COMPILE_LANGUAGE:Fortran>:${fortran_compile_flags}>")
+
+# link libraries
+target_link_libraries(mom6lib PRIVATE FMS::fms_r8)
+
+if(ACCESS3_MOM6)
+target_link_libraries(mom6lib
+  PUBLIC esmf
+  PRIVATE Access3::nuopc_cap_share Access3::share Access3::timing Access3::cdeps-common
+)
+endif()
+
+target_sources(mom6lib PRIVATE
+  ${SRC}/ALE/coord_adapt.F90
+  ${SRC}/ALE/coord_hycom.F90
+  ${SRC}/ALE/coord_rho.F90
+  ${SRC}/ALE/coord_sigma.F90
+  ${SRC}/ALE/coord_zlike.F90
+  ${SRC}/ALE/MOM_ALE.F90
+  ${SRC}/ALE/MOM_hybgen_regrid.F90
+  ${SRC}/ALE/MOM_hybgen_remap.F90
+  ${SRC}/ALE/MOM_hybgen_unmix.F90
+  ${SRC}/ALE/MOM_regridding.F90
+  ${SRC}/ALE/MOM_remapping.F90
+  ${SRC}/ALE/P1M_functions.F90
+  ${SRC}/ALE/P3M_functions.F90
+  ${SRC}/ALE/PCM_functions.F90
+  ${SRC}/ALE/PLM_functions.F90
+  ${SRC}/ALE/polynomial_functions.F90
+  ${SRC}/ALE/PPM_functions.F90
+  ${SRC}/ALE/PQM_functions.F90
+  ${SRC}/ALE/regrid_consts.F90
+  ${SRC}/ALE/regrid_edge_values.F90
+  ${SRC}/ALE/regrid_interp.F90
+  ${SRC}/ALE/regrid_solvers.F90
+  ${SRC}/ALE/remapping_attic.F90
+
+  ${SRC}/core/MOM_barotropic.F90
+  ${SRC}/core/MOM_boundary_update.F90
+  ${SRC}/core/MOM_check_scaling.F90
+  ${SRC}/core/MOM_checksum_packages.F90
+  ${SRC}/core/MOM_continuity.F90
+  ${SRC}/core/MOM_continuity_PPM.F90
+  ${SRC}/core/MOM_CoriolisAdv.F90
+  ${SRC}/core/MOM_density_integrals.F90
+  ${SRC}/core/MOM_dynamics_split_RK2.F90
+  ${SRC}/core/MOM_dynamics_split_RK2b.F90
+  ${SRC}/core/MOM_dynamics_unsplit.F90
+  ${SRC}/core/MOM_dynamics_unsplit_RK2.F90
+  ${SRC}/core/MOM.F90
+  ${SRC}/core/MOM_grid.F90
+  ${SRC}/core/MOM_interface_heights.F90
+  ${SRC}/core/MOM_isopycnal_slopes.F90
+  ${SRC}/core/MOM_open_boundary.F90
+  ${SRC}/core/MOM_porous_barriers.F90
+  ${SRC}/core/MOM_PressureForce.F90
+  ${SRC}/core/MOM_PressureForce_FV.F90
+  ${SRC}/core/MOM_PressureForce_Montgomery.F90
+  ${SRC}/core/MOM_stoch_eos.F90
+  ${SRC}/core/MOM_transcribe_grid.F90
+  ${SRC}/core/MOM_unit_tests.F90
+  ${SRC}/core/MOM_variables.F90
+  ${SRC}/core/MOM_verticalGrid.F90
+  ${SRC}/core/MOM_forcing_type.F90
+
+  ${SRC}/diagnostics/MOM_debugging.F90
+  ${SRC}/diagnostics/MOM_diagnostics.F90
+  ${SRC}/diagnostics/MOM_obsolete_diagnostics.F90
+  ${SRC}/diagnostics/MOM_obsolete_params.F90
+  ${SRC}/diagnostics/MOM_PointAccel.F90
+  ${SRC}/diagnostics/MOM_spatial_means.F90
+  ${SRC}/diagnostics/MOM_sum_output.F90
+  ${SRC}/diagnostics/MOM_wave_speed.F90
+
+  ${SRC}/equation_of_state/MOM_EOS.F90
+  ${SRC}/equation_of_state/MOM_EOS_base_type.F90
+  ${SRC}/equation_of_state/MOM_EOS_Jackett06.F90
+  ${SRC}/equation_of_state/MOM_EOS_linear.F90
+  ${SRC}/equation_of_state/MOM_EOS_Roquet_rho.F90
+  ${SRC}/equation_of_state/MOM_EOS_Roquet_SpV.F90
+  ${SRC}/equation_of_state/MOM_EOS_TEOS10.F90
+  ${SRC}/equation_of_state/MOM_EOS_UNESCO.F90
+  ${SRC}/equation_of_state/MOM_EOS_Wright.F90
+  ${SRC}/equation_of_state/MOM_EOS_Wright_full.F90
+  ${SRC}/equation_of_state/MOM_EOS_Wright_red.F90
+  ${SRC}/equation_of_state/MOM_temperature_convert.F90
+  ${SRC}/equation_of_state/MOM_TFreeze.F90
+
+  ${SRC}/equation_of_state/TEOS10/gsw_chem_potential_water_t_exact.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_ct_freezing_exact.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_ct_freezing_poly.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_ct_from_pt.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_ct_from_t.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_entropy_part.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_entropy_part_zerop.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_gibbs.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_gibbs_ice.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_gibbs_pt0_pt0.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_mod_error_functions.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_mod_freezing_poly_coefficients.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_mod_gibbs_ice_coefficients.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_mod_kinds.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_mod_specvol_coefficients.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_mod_teos10_constants.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_mod_toolbox.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_pt0_from_t.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_pt_from_ct.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_pt_from_t.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_rho.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_rho_first_derivatives.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_rho_second_derivatives.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_sp_from_sr.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_sr_from_sp.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_specvol.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_specvol_first_derivatives.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_specvol_second_derivatives.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_t_deriv_chem_potential_water_t_exact.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_t_freezing_exact.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_t_freezing_poly.f90
+  ${SRC}/equation_of_state/TEOS10/gsw_t_from_ct.f90
+
+  ${SRC}/framework/MOM_array_transform.F90
+  ${SRC}/framework/MOM_checksums.F90
+  ${SRC}/framework/MOM_coms.F90
+  ${SRC}/framework/MOM_cpu_clock.F90
+  ${SRC}/framework/MOM_data_override.F90
+  ${SRC}/framework/MOM_diag_mediator.F90
+  ${SRC}/framework/MOM_diag_remap.F90
+  ${SRC}/framework/MOM_document.F90
+  ${SRC}/framework/MOM_domains.F90
+  ${SRC}/framework/MOM_dyn_horgrid.F90
+  ${SRC}/framework/MOM_ensemble_manager.F90
+  ${SRC}/framework/MOM_error_handler.F90
+  ${SRC}/framework/MOM_file_parser.F90
+  ${SRC}/framework/MOM_get_input.F90
+  ${SRC}/framework/MOM_hor_index.F90
+  ${SRC}/framework/MOM_horizontal_regridding.F90
+  ${SRC}/framework/MOM_interpolate.F90
+  ${SRC}/framework/MOM_intrinsic_functions.F90
+  ${SRC}/framework/MOM_io.F90
+  ${SRC}/framework/MOM_io_file.F90
+  ${SRC}/framework/MOM_memory_macros.h
+  ${SRC}/framework/MOM_netcdf.F90
+  ${SRC}/framework/MOM_random.F90
+  ${SRC}/framework/MOM_restart.F90
+  ${SRC}/framework/MOM_safe_alloc.F90
+  ${SRC}/framework/MOM_string_functions.F90
+  ${SRC}/framework/MOM_unique_scales.F90
+  ${SRC}/framework/MOM_unit_scaling.F90
+  ${SRC}/framework/MOM_write_cputime.F90
+  ${SRC}/framework/posix.F90
+  ${SRC}/framework/MOM_coupler_types.F90
+
+  ${SRC}/ice_shelf/MOM_ice_shelf_diag_mediator.F90
+  ${SRC}/ice_shelf/MOM_ice_shelf_dynamics.F90
+  ${SRC}/ice_shelf/MOM_ice_shelf.F90
+  ${SRC}/ice_shelf/MOM_ice_shelf_initialize.F90
+  ${SRC}/ice_shelf/MOM_ice_shelf_state.F90
+  ${SRC}/ice_shelf/MOM_marine_ice.F90
+  ${SRC}/ice_shelf/user_shelf_init.F90
+
+  ${SRC}/initialization/MOM_coord_initialization.F90
+  ${SRC}/initialization/MOM_fixed_initialization.F90
+  ${SRC}/initialization/MOM_grid_initialize.F90
+  ${SRC}/initialization/MOM_shared_initialization.F90
+  ${SRC}/initialization/MOM_state_initialization.F90
+  ${SRC}/initialization/MOM_tracer_initialization_from_Z.F90
+
+  ${SRC}/ocean_data_assim/MOM_oda_driver.F90
+  ${SRC}/ocean_data_assim/MOM_oda_incupd.F90
+
+  ${SRC}/parameterizations/CVmix/cvmix_background.F90
+  ${SRC}/parameterizations/CVmix/cvmix_convection.F90
+  ${SRC}/parameterizations/CVmix/cvmix_ddiff.F90
+  ${SRC}/parameterizations/CVmix/cvmix_kinds_and_types.F90
+  ${SRC}/parameterizations/CVmix/cvmix_kpp.F90
+  ${SRC}/parameterizations/CVmix/cvmix_math.F90
+  ${SRC}/parameterizations/CVmix/cvmix_put_get.F90
+  ${SRC}/parameterizations/CVmix/cvmix_shear.F90
+  ${SRC}/parameterizations/CVmix/cvmix_tidal.F90
+  ${SRC}/parameterizations/CVmix/cvmix_utils.F90
+
+  ${SRC}/parameterizations/lateral/MOM_hor_visc.F90
+  ${SRC}/parameterizations/lateral/MOM_interface_filter.F90
+  ${SRC}/parameterizations/lateral/MOM_internal_tides.F90
+  ${SRC}/parameterizations/lateral/MOM_lateral_mixing_coeffs.F90
+  ${SRC}/parameterizations/lateral/MOM_load_love_numbers.F90
+  ${SRC}/parameterizations/lateral/MOM_MEKE.F90
+  ${SRC}/parameterizations/lateral/MOM_MEKE_types.F90
+  ${SRC}/parameterizations/lateral/MOM_mixed_layer_restrat.F90
+  ${SRC}/parameterizations/lateral/MOM_spherical_harmonics.F90
+  ${SRC}/parameterizations/lateral/MOM_self_attr_load.F90
+  ${SRC}/parameterizations/lateral/MOM_thickness_diffuse.F90
+  ${SRC}/parameterizations/lateral/MOM_tidal_forcing.F90
+  ${SRC}/parameterizations/lateral/MOM_Zanna_Bolton.F90
+
+  ${SRC}/parameterizations/stochastic/MOM_stochastics.F90
+
+  ${SRC}/parameterizations/vertical/MOM_ALE_sponge.F90
+  ${SRC}/parameterizations/vertical/MOM_bkgnd_mixing.F90
+  ${SRC}/parameterizations/vertical/MOM_bulk_mixed_layer.F90
+  ${SRC}/parameterizations/vertical/MOM_CVMix_conv.F90
+  ${SRC}/parameterizations/vertical/MOM_CVMix_ddiff.F90
+  ${SRC}/parameterizations/vertical/MOM_CVMix_KPP.F90
+  ${SRC}/parameterizations/vertical/MOM_CVMix_shear.F90
+  ${SRC}/parameterizations/vertical/MOM_diabatic_aux.F90
+  ${SRC}/parameterizations/vertical/MOM_diabatic_driver.F90
+  ${SRC}/parameterizations/vertical/MOM_diapyc_energy_req.F90
+  ${SRC}/parameterizations/vertical/MOM_energetic_PBL.F90
+  ${SRC}/parameterizations/vertical/MOM_entrain_diffusive.F90
+  ${SRC}/parameterizations/vertical/MOM_full_convection.F90
+  ${SRC}/parameterizations/vertical/MOM_geothermal.F90
+  ${SRC}/parameterizations/vertical/MOM_internal_tide_input.F90
+  ${SRC}/parameterizations/vertical/MOM_kappa_shear.F90
+  ${SRC}/parameterizations/vertical/MOM_opacity.F90
+  ${SRC}/parameterizations/vertical/MOM_regularize_layers.F90
+  ${SRC}/parameterizations/vertical/MOM_set_diffusivity.F90
+  ${SRC}/parameterizations/vertical/MOM_set_viscosity.F90
+  ${SRC}/parameterizations/vertical/MOM_sponge.F90
+  ${SRC}/parameterizations/vertical/MOM_tidal_mixing.F90
+  ${SRC}/parameterizations/vertical/MOM_vert_friction.F90
+
+  ${SRC}/tracer/advection_test_tracer.F90
+  ${SRC}/tracer/boundary_impulse_tracer.F90
+  ${SRC}/tracer/DOME_tracer.F90
+  ${SRC}/tracer/dyed_obc_tracer.F90
+  ${SRC}/tracer/dye_example.F90
+  ${SRC}/tracer/ideal_age_example.F90
+  ${SRC}/tracer/ISOMIP_tracer.F90
+  ${SRC}/tracer/MOM_CFC_cap.F90
+  ${SRC}/tracer/MOM_hor_bnd_diffusion.F90
+  ${SRC}/tracer/MOM_neutral_diffusion.F90
+  ${SRC}/tracer/MOM_OCMIP2_CFC.F90
+  ${SRC}/tracer/MOM_offline_aux.F90
+  ${SRC}/tracer/MOM_offline_main.F90
+  ${SRC}/tracer/MOM_tracer_advect.F90
+  ${SRC}/tracer/MOM_tracer_diabatic.F90
+  ${SRC}/tracer/MOM_tracer_flow_control.F90
+  ${SRC}/tracer/MOM_tracer_hor_diff.F90
+  ${SRC}/tracer/MOM_tracer_registry.F90
+  ${SRC}/tracer/MOM_tracer_types.F90
+  ${SRC}/tracer/MOM_tracer_Z_init.F90
+  ${SRC}/tracer/nw2_tracers.F90
+  ${SRC}/tracer/oil_tracer.F90
+  ${SRC}/tracer/pseudo_salt_tracer.F90
+  ${SRC}/tracer/RGC_tracer.F90
+  ${SRC}/tracer/tracer_example.F90
+
+  ${SRC}/user/adjustment_initialization.F90
+  ${SRC}/user/baroclinic_zone_initialization.F90
+  ${SRC}/user/basin_builder.F90
+  ${SRC}/user/benchmark_initialization.F90
+  ${SRC}/user/BFB_initialization.F90
+  ${SRC}/user/BFB_surface_forcing.F90
+  ${SRC}/user/circle_obcs_initialization.F90
+  ${SRC}/user/dense_water_initialization.F90
+  ${SRC}/user/DOME2d_initialization.F90
+  ${SRC}/user/DOME_initialization.F90
+  ${SRC}/user/dumbbell_initialization.F90
+  ${SRC}/user/dumbbell_surface_forcing.F90
+  ${SRC}/user/dyed_channel_initialization.F90
+  ${SRC}/user/dyed_obcs_initialization.F90
+  ${SRC}/user/external_gwave_initialization.F90
+  ${SRC}/user/Idealized_Hurricane.F90
+  ${SRC}/user/ISOMIP_initialization.F90
+  ${SRC}/user/Kelvin_initialization.F90
+  ${SRC}/user/lock_exchange_initialization.F90
+  ${SRC}/user/MOM_controlled_forcing.F90
+  ${SRC}/user/MOM_wave_interface.F90
+  ${SRC}/user/Neverworld_initialization.F90
+  ${SRC}/user/Phillips_initialization.F90
+  ${SRC}/user/RGC_initialization.F90
+  ${SRC}/user/Rossby_front_2d_initialization.F90
+  ${SRC}/user/SCM_CVMix_tests.F90
+  ${SRC}/user/seamount_initialization.F90
+  ${SRC}/user/shelfwave_initialization.F90
+  ${SRC}/user/sloshing_initialization.F90
+  ${SRC}/user/soliton_initialization.F90
+  ${SRC}/user/supercritical_initialization.F90
+  ${SRC}/user/tidal_bay_initialization.F90
+  ${SRC}/user/user_change_diffusivity.F90
+  ${SRC}/user/user_initialization.F90
+  ${SRC}/user/user_revise_forcing.F90
+
+  ${CONFIG_SRC}/external/database_comms/MOM_database_comms.F90
+  ${CONFIG_SRC}/external/database_comms/database_client_interface.F90
+
+  ${CONFIG_SRC}/external/drifters/MOM_particles.F90
+  ${CONFIG_SRC}/external/drifters/MOM_particles_types.F90
+
+  ${CONFIG_SRC}/external/ODA_hooks/kdtree.f90
+  ${CONFIG_SRC}/external/ODA_hooks/ocean_da_core.F90
+  ${CONFIG_SRC}/external/ODA_hooks/ocean_da_types.F90
+  ${CONFIG_SRC}/external/ODA_hooks/write_ocean_obs.F90
+
+  ${CONFIG_SRC}/external/stochastic_physics/get_stochy_pattern.F90
+  ${CONFIG_SRC}/external/stochastic_physics/stochastic_physics.F90
+
+  ${CONFIG_SRC}/external/GFDL_ocean_BGC/generic_tracer_utils.F90
+  ${CONFIG_SRC}/external/GFDL_ocean_BGC/generic_tracer.F90
+
+  ${CONFIG_SRC}/infra/FMS2/MOM_coms_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_constants.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_cpu_clock_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_data_override_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_diag_manager_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_domain_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_ensemble_manager_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_error_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_interp_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_io_infra.F90
+  ${CONFIG_SRC}/infra/FMS2/MOM_time_manager.F90
+
+  ${CONFIG_SRC}/infra/FMS2/MOM_couplertype_infra.F90
+
+  ${SRC}/tracer/MOM_generic_tracer.F90
+)
+
+if (ACCESS3_MOM6)
+  target_sources(mom6lib PRIVATE
+  ${CONFIG_SRC}/drivers/nuopc_cap/mom_cap_time.F90
+  ${CONFIG_SRC}/drivers/nuopc_cap/mom_surface_forcing_nuopc.F90
+  ${CONFIG_SRC}/drivers/nuopc_cap/ocn_comp_NUOPC.F90
+  ${CONFIG_SRC}/drivers/nuopc_cap/time_utils.F90
+  ${CONFIG_SRC}/drivers/nuopc_cap/mom_cap.F90
+  ${CONFIG_SRC}/drivers/nuopc_cap/mom_cap_methods.F90
+  ${CONFIG_SRC}/drivers/nuopc_cap/mom_ocean_model_nuopc.F90
+  )
+else()
+  target_sources(mom6lib PRIVATE
+  ${CONFIG_SRC}/drivers/solo_driver/MOM_surface_forcing.F90
+  ${CONFIG_SRC}/drivers/solo_driver/MESO_surface_forcing.F90
+  ${CONFIG_SRC}/drivers/solo_driver/user_surface_forcing.F90
+  )
+endif()
+### Install and Export
+
+## Library
+if(ACCESS3_MOM6)
+  set_target_properties(mom6lib PROPERTIES
+    OUTPUT_NAME access-mom6lib
+    EXPORT_NAME mom6lib
+  )
+  install(TARGETS mom6lib
+    EXPORT MOM6libTargets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT AccessMOM6Cmeps_runtime NAMELINK_COMPONENT AccessMOM6Cmeps_Development
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT AccessMOM6Cmeps_Development
+  )
+  # Fortran module files are a special case, as currently there is no standard
+  # way of handling them in CMake
+  target_include_directories(mom6lib PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_MODULEDIR}/MOM6lib>")
+  get_target_property(mom_moddir mom6lib Fortran_MODULE_DIRECTORY)
+  install(FILES ${mom_moddir}/ocn_comp_nuopc.mod ${mom_moddir}/mom_cap_mod.mod
+    DESTINATION ${CMAKE_INSTALL_MODULEDIR}/MOM6lib
+    COMPONENT AccessMOM6Cmeps_Development
+  )
+  install(EXPORT MOM6libTargets
+    FILE MOM6libTargets.cmake
+    NAMESPACE Access3::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MOM6lib
+  )
+
+  configure_package_config_file(
+    MOM6libConfig.cmake.in
+    "${CMAKE_CURRENT_BINARY_DIR}/MOM6libConfig.cmake"
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MOM6lib
+  )
+
+  install(FILES ${CMAKE_SOURCE_DIR}/FindNetCDF.cmake ${CMAKE_CURRENT_BINARY_DIR}/MOM6libConfig.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MOM6lib
+    COMPONENT AccessMOM6Cmeps_Development
+  )
+
+else()
+
+# executable
+  add_executable(MOM6 ${CONFIG_SRC}/drivers/solo_driver/MOM_driver.F90)
+  target_link_libraries(MOM6 PRIVATE mom6lib)
+
+  target_include_directories(MOM6 PRIVATE 
+    ${SRC}/framework 
+    ${MOM_MEMORY_DIR}
+    ${CONFIG_SRC}/drivers/solo_driver
+    )
+
+  set_target_properties(MOM6 PROPERTIES
+    LINKER_LANGUAGE Fortran
+    OUTPUT_NAME mom6
+  )
+
+  install(TARGETS MOM6
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  )
+endif()
diff --git a/cmake/CompilerFlags.cmake b/cmake/CompilerFlags.cmake
new file mode 100644
index 0000000000..1200cf5baf
--- /dev/null
+++ b/cmake/CompilerFlags.cmake
@@ -0,0 +1,32 @@
+# Common compiler flags and definitions
+
+# Fortran compiler flags
+if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU")
+  set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fbacktrace -fconvert=big-endian -ffree-line-length-none -ffixed-line-length-none")
+  if(${CMAKE_Fortran_COMPILER_VERSION} VERSION_GREATER_EQUAL 10)
+    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fallow-argument-mismatch")
+  endif()
+  set(CMAKE_Fortran_FLAGS "-fdefault-real-8 -fdefault-double-8")
+  set(CMAKE_Fortran_FLAGS_RELEASE "-O")
+  set(CMAKE_Fortran_FLAGS_DEBUG "-g -Wall -Og -ffpe-trap=zero,overflow -fcheck=bounds")
+elseif(CMAKE_Fortran_COMPILER_ID MATCHES "Intel")
+  set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -qno-opt-dynamic-align  -convert big_endian -assume byterecl -ftz -traceback -assume realloc_lhs -fp-model source")
+  set(CMAKE_Fortran_FLAGS_RELEASE "-O2 -debug minimal")
+  set(CMAKE_Fortran_FLAGS_DEBUG "-O0 -g -check uninit -check bounds -check pointers -fpe0 -check noarg_temp_created")
+  set(CMAKE_Fortran_FLAGS "-r8")
+else()
+  message(WARNING "Fortran compiler with ID ${CMAKE_Fortran_COMPILER_ID} will be used with CMake default options")
+endif()
+
+# C compiler flags
+if(CMAKE_C_COMPILER_ID MATCHES "GNU")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99")
+  set(CMAKE_C_FLAGS_RELEASE "-O")
+  set(CMAKE_C_FLAGS_DEBUG "-g -Wall -Og -fbacktrace -ffpe-trap=invalid,zero,overflow -fcheck=bounds")
+elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -traceback -qno-opt-dynamic-align -fp-model precise -std=gnu99")
+  set(CMAKE_C_FLAGS_RELEASE "-O2 -debug minimal")
+  set(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+else()
+  message(WARNING "C compiler with ID ${CMAKE_C_COMPILER_ID} will be used with CMake default options")
+endif()
\ No newline at end of file
diff --git a/cmake/FindESMF.cmake b/cmake/FindESMF.cmake
new file mode 100644
index 0000000000..c79c5d3a1e
--- /dev/null
+++ b/cmake/FindESMF.cmake
@@ -0,0 +1,135 @@
+# - Try to find ESMF
+#
+# Requires setting ESMFMKFILE to the filepath of esmf.mk. If this is NOT set,
+# then ESMF_FOUND will always be FALSE. If ESMFMKFILE exists, then ESMF_FOUND=TRUE
+# and all ESMF makefile variables will be set in the global scope. Optionally,
+# set ESMF_MKGLOBALS to a string list to filter makefile variables. For example,
+# to globally scope only ESMF_LIBSDIR and ESMF_APPSDIR variables, use this CMake
+# command in CMakeLists.txt:
+#
+#   set(ESMF_MKGLOBALS "LIBSDIR" "APPSDIR")
+
+
+# Add the ESMFMKFILE path to the cache if defined as system env variable
+if(DEFINED ENV{ESMFMKFILE} AND NOT DEFINED ESMFMKFILE)
+  set(ESMFMKFILE $ENV{ESMFMKFILE} CACHE FILEPATH "Path to ESMF mk file")
+endif()
+
+# If it's not explicitly set try to find esmf.mk file in default locations (ESMF_ROOT, CMAKE_PREFIX_PATH, etc)
+if(NOT DEFINED ESMFMKFILE)
+  find_path(ESMFMKFILE_PATH esmf.mk PATH_SUFFIXES lib lib64)
+  if(ESMFMKFILE_PATH)
+    set(ESMFMKFILE ${ESMFMKFILE_PATH}/esmf.mk)
+    message(STATUS "Found esmf.mk file ${ESMFMKFILE}")
+  else()
+    message(STATUS "ESMFMKFILE not defined. This is the path to esmf.mk file. \
+Without this filepath, ESMF_FOUND will always be FALSE.")
+  endif()
+endif()
+
+# Only parse the mk file if it is found
+if(EXISTS ${ESMFMKFILE})
+  # Read the mk file
+  file(STRINGS "${ESMFMKFILE}" esmfmkfile_contents)
+  # Parse each line in the mk file
+  foreach(str ${esmfmkfile_contents})
+    # Only consider uncommented lines
+    string(REGEX MATCH "^[^#]" def ${str})
+    # Line is not commented
+    if(def)
+      # Extract the variable name
+      string(REGEX MATCH "^[^=]+" esmf_varname ${str})
+      # Extract the variable's value
+      string(REGEX MATCH "=.+$" esmf_vardef ${str})
+      # Only for variables with a defined value
+      if(esmf_vardef)
+        # Get rid of the assignment string
+        string(SUBSTRING ${esmf_vardef} 1 -1 esmf_vardef)
+        # Remove whitespace
+        string(STRIP ${esmf_vardef} esmf_vardef)
+        # A string or single-valued list
+        if(NOT DEFINED ESMF_MKGLOBALS)
+          # Set in global scope
+          set(${esmf_varname} ${esmf_vardef})
+          # Don't display by default in GUI
+          mark_as_advanced(esmf_varname)
+        else() # Need to filter global promotion
+          foreach(m ${ESMF_MKGLOBALS})
+            string(FIND ${esmf_varname} ${m} match)
+            # Found the string
+            if(NOT ${match} EQUAL -1)
+              # Promote to global scope
+              set(${esmf_varname} ${esmf_vardef})
+              # Don't display by default in the GUI
+              mark_as_advanced(esmf_varname)
+              # No need to search for the current string filter
+              break()
+            endif()
+          endforeach()
+        endif()
+      endif()
+    endif()
+  endforeach()
+
+  # Construct ESMF_VERSION from ESMF_VERSION_STRING_GIT
+  # ESMF_VERSION_MAJOR and ESMF_VERSION_MINOR are defined in ESMFMKFILE
+  set(ESMF_VERSION 0)
+  set(ESMF_VERSION_PATCH ${ESMF_VERSION_REVISION})
+  set(ESMF_BETA_RELEASE FALSE)
+  if(ESMF_VERSION_BETASNAPSHOT MATCHES "^('T')$")
+    set(ESMF_BETA_RELEASE TRUE)
+    string(REGEX REPLACE ".*beta_snapshot_*\([0-9]*\).*" "\\1" ESMF_BETA_SNAPSHOT "${ESMF_VERSION_STRING_GIT}")
+    message(STATUS "Detected ESMF Beta snapshot ${ESMF_BETA_SNAPSHOT}")
+  endif()
+  set(ESMF_VERSION "${ESMF_VERSION_MAJOR}.${ESMF_VERSION_MINOR}.${ESMF_VERSION_PATCH}")
+
+  separate_arguments(ESMF_F90COMPILEPATHS NATIVE_COMMAND ${ESMF_F90COMPILEPATHS})
+  foreach(ITEM ${ESMF_F90COMPILEPATHS})
+     string(REGEX REPLACE "^-I" "" ITEM "${ITEM}")
+     list(APPEND tmp ${ITEM})
+  endforeach()
+  set(ESMF_F90COMPILEPATHS ${tmp})
+
+  # Look for static library, if not found try dynamic library
+  find_library(esmf_lib NAMES libesmf.a PATHS ${ESMF_LIBSDIR})
+  if(esmf_lib MATCHES "esmf_lib-NOTFOUND")
+    unset(esmf_lib)
+    message(STATUS "Static ESMF library not found, searching for dynamic library instead")
+    find_library(esmf_lib NAMES esmf_fullylinked libesmf.so PATHS ${ESMF_LIBSDIR})
+    if(esmf_lib MATCHES "esmf_lib-NOTFOUND")
+      unset(esmf_lib)
+      message(STATUS "Neither the dynamic nor the static ESMF library was found")
+    else()
+      set(_library_type SHARED)
+    endif()
+  else()
+    set(_library_type STATIC)
+  endif()
+
+  string(STRIP "${ESMF_F90ESMFLINKRPATHS} ${ESMF_F90ESMFLINKPATHS} ${ESMF_F90LINKPATHS} ${ESMF_F90LINKLIBS} ${ESMF_F90LINKOPTS}" ESMF_INTERFACE_LINK_LIBRARIES)
+  set(ESMF_LIBRARY_LOCATION ${esmf_lib})
+
+else()
+
+  message(WARNING "ESMFMKFILE ${ESMFMKFILE} does not exist")
+
+endif()
+
+## Finalize find_package
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(
+    ${CMAKE_FIND_PACKAGE_NAME}
+    REQUIRED_VARS ESMF_LIBRARY_LOCATION
+                  ESMF_INTERFACE_LINK_LIBRARIES
+                  ESMF_F90COMPILEPATHS
+    VERSION_VAR ESMF_VERSION)
+
+## If ESMF is found create imported library target
+if(ESMF_FOUND)
+  add_library(esmf ${_library_type} IMPORTED)
+  set_target_properties(esmf PROPERTIES
+    IMPORTED_LOCATION "${ESMF_LIBRARY_LOCATION}"
+    INTERFACE_INCLUDE_DIRECTORIES "${ESMF_F90COMPILEPATHS}"
+    INTERFACE_LINK_LIBRARIES "${ESMF_INTERFACE_LINK_LIBRARIES}")
+endif()
\ No newline at end of file
diff --git a/cmake/FindNetCDF.cmake b/cmake/FindNetCDF.cmake
new file mode 100644
index 0000000000..1439ae8486
--- /dev/null
+++ b/cmake/FindNetCDF.cmake
@@ -0,0 +1,337 @@
+# (C) Copyright 2011- ECMWF.
+#
+# This software is licensed under the terms of the Apache Licence Version 2.0
+# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+# In applying this licence, ECMWF does not waive the privileges and immunities
+# granted to it by virtue of its status as an intergovernmental organisation nor
+# does it submit to any jurisdiction.
+
+# Try to find NetCDF includes and library.
+# Supports static and shared libaries and allows each component to be found in sepearte prefixes.
+#
+# This module defines
+#
+#   - NetCDF_FOUND                - System has NetCDF
+#   - NetCDF_INCLUDE_DIRS         - the NetCDF include directories
+#   - NetCDF_VERSION              - the version of NetCDF
+#   - NetCDF_CONFIG_EXECUTABLE    - the netcdf-config executable if found
+#   - NetCDF_PARALLEL             - Boolean True if NetCDF4 has parallel IO support via hdf5 and/or pnetcdf
+#   - NetCDF_HAS_PNETCDF          - Boolean True if NetCDF4 has pnetcdf support
+#
+# Deprecated Defines
+#   - NetCDF_LIBRARIES            - [Deprecated] Use NetCDF::NetCDF_<LANG> targets instead.
+#
+#
+# Following components are available:
+#
+#   - C                           - C interface to NetCDF          (netcdf)
+#   - CXX                         - CXX4 interface to NetCDF       (netcdf_c++4)
+#   - Fortran                     - Fortran interface to NetCDF    (netcdff)
+#
+# For each component the following are defined:
+#
+#   - NetCDF_<comp>_FOUND         - whether the component is found
+#   - NetCDF_<comp>_LIBRARIES     - the libraries for the component
+#   - NetCDF_<comp>_LIBRARY_SHARED - Boolean is true if libraries for component are shared
+#   - NetCDF_<comp>_INCLUDE_DIRS  - the include directories for specified component
+#   - NetCDF::NetCDF_<comp>       - target of component to be used with target_link_libraries()
+#
+# The following paths will be searched in order if set in CMake (first priority) or environment (second priority)
+#
+#   - NetCDF_ROOT                 - root of NetCDF installation
+#   - NetCDF_PATH                 - root of NetCDF installation
+#
+# The search process begins with locating NetCDF Include headers.  If these are in a non-standard location,
+# set one of the following CMake or environment variables to point to the location:
+#
+#  - NetCDF_INCLUDE_DIR or NetCDF_${comp}_INCLUDE_DIR
+#  - NetCDF_INCLUDE_DIRS or NetCDF_${comp}_INCLUDE_DIR
+#
+# Notes:
+#
+#   - Use "NetCDF::NetCDF_<LANG>" targets only.  NetCDF_LIBRARIES exists for backwards compatibility and should not be used.
+#     - These targets have all the knowledge of include directories and library search directories, and a single
+#       call to target_link_libraries will provide all these transitive properties to your target.  Normally all that is
+#       needed to build and link against NetCDF is, e.g.:
+#           target_link_libraries(my_c_tgt PUBLIC NetCDF::NetCDF_C)
+#   - "NetCDF" is always the preferred naming for this package, its targets, variables, and environment variables
+#     - For compatibility, some variables are also set/checked using alternate names NetCDF4, NETCDF, or NETCDF4
+#     - Environments relying on these older environment variable names should move to using a "NetCDF_ROOT" environment variable
+#   - Preferred component capitalization follows the CMake LANGUAGES variables: i.e., C, Fortran, CXX
+#     - For compatibility, alternate capitalizations are supported but should not be used.
+#   - If no components are defined, all components will be searched
+#
+
+list( APPEND _possible_components C CXX Fortran )
+
+## Include names for each component
+set( NetCDF_C_INCLUDE_NAME          netcdf.h )
+set( NetCDF_CXX_INCLUDE_NAME        netcdf )
+set( NetCDF_Fortran_INCLUDE_NAME    netcdf.mod )
+
+## Library names for each component
+set( NetCDF_C_LIBRARY_NAME          netcdf )
+set( NetCDF_CXX_LIBRARY_NAME        netcdf_c++4 )
+set( NetCDF_Fortran_LIBRARY_NAME    netcdff )
+
+## Enumerate search components
+foreach( _comp ${_possible_components} )
+  string( TOUPPER "${_comp}" _COMP )
+  set( _arg_${_COMP} ${_comp} )
+  set( _name_${_COMP} ${_comp} )
+endforeach()
+
+set( _search_components C)
+foreach( _comp ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS} )
+  string( TOUPPER "${_comp}" _COMP )
+  set( _arg_${_COMP} ${_comp} )
+  list( APPEND _search_components ${_name_${_COMP}} )
+  if( NOT _name_${_COMP} )
+    message(SEND_ERROR "Find${CMAKE_FIND_PACKAGE_NAME}: COMPONENT ${_comp} is not a valid component. Valid components: ${_possible_components}" )
+  endif()
+endforeach()
+list( REMOVE_DUPLICATES _search_components )
+
+## Search hints for finding include directories and libraries
+foreach( _comp IN ITEMS "_" "_C_" "_Fortran_" "_CXX_" )
+  foreach( _name IN ITEMS NetCDF4 NetCDF NETCDF4 NETCDF )
+    foreach( _var IN ITEMS ROOT PATH )
+      list(APPEND _search_hints ${${_name}${_comp}${_var}} $ENV{${_name}${_comp}${_var}} )
+      list(APPEND _include_search_hints
+                ${${_name}${_comp}INCLUDE_DIR} $ENV{${_name}${_comp}INCLUDE_DIR}
+                ${${_name}${_comp}INCLUDE_DIRS} $ENV{${_name}${_comp}INCLUDE_DIRS} )
+    endforeach()
+  endforeach()
+endforeach()
+#Old-school HPC module env variable names
+foreach( _name IN ITEMS NetCDF4 NetCDF NETCDF4 NETCDF )
+  foreach( _comp IN ITEMS "_C" "_Fortran" "_CXX" )
+    list(APPEND _search_hints ${${_name}}         $ENV{${_name}})
+    list(APPEND _search_hints ${${_name}${_comp}} $ENV{${_name}${_comp}})
+  endforeach()
+endforeach()
+
+## Find headers for each component
+set(NetCDF_INCLUDE_DIRS)
+set(_new_search_components)
+foreach( _comp IN LISTS _search_components )
+  if(NOT ${PROJECT_NAME}_NetCDF_${_comp}_FOUND)
+      list(APPEND _new_search_components ${_comp})
+  endif()
+  find_file(NetCDF_${_comp}_INCLUDE_FILE
+    NAMES ${NetCDF_${_comp}_INCLUDE_NAME}
+    DOC "NetCDF ${_comp} include directory"
+    HINTS ${_include_search_hints} ${_search_hints}
+    PATH_SUFFIXES include include/netcdf
+  )
+  mark_as_advanced(NetCDF_${_comp}_INCLUDE_FILE)
+  message(DEBUG "NetCDF_${_comp}_INCLUDE_FILE: ${NetCDF_${_comp}_INCLUDE_FILE}")
+  if( NetCDF_${_comp}_INCLUDE_FILE )
+    get_filename_component(NetCDF_${_comp}_INCLUDE_FILE ${NetCDF_${_comp}_INCLUDE_FILE} ABSOLUTE)
+    get_filename_component(NetCDF_${_comp}_INCLUDE_DIR ${NetCDF_${_comp}_INCLUDE_FILE} DIRECTORY)
+    list(APPEND NetCDF_INCLUDE_DIRS ${NetCDF_${_comp}_INCLUDE_DIR})
+  endif()
+endforeach()
+if(NetCDF_INCLUDE_DIRS)
+    list(REMOVE_DUPLICATES NetCDF_INCLUDE_DIRS)
+endif()
+set(NetCDF_INCLUDE_DIRS "${NetCDF_INCLUDE_DIRS}" CACHE STRING "NetCDF Include directory paths" FORCE)
+
+## Find n*-config executables for search components
+foreach( _comp IN LISTS _search_components )
+  if( _comp MATCHES "^(C)$" )
+    set(_conf "c")
+  elseif( _comp MATCHES "^(Fortran)$" )
+    set(_conf "f")
+  elseif( _comp MATCHES "^(CXX)$" )
+    set(_conf "cxx4")
+  endif()
+  find_program( NetCDF_${_comp}_CONFIG_EXECUTABLE
+      NAMES n${_conf}-config
+    HINTS ${NetCDF_INCLUDE_DIRS} ${_include_search_hints} ${_search_hints}
+    PATH_SUFFIXES bin Bin ../bin ../../bin
+      DOC "NetCDF n${_conf}-config helper" )
+    message(DEBUG "NetCDF_${_comp}_CONFIG_EXECUTABLE: ${NetCDF_${_comp}_CONFIG_EXECUTABLE}")
+endforeach()
+
+set(_C_libs_flag --libs)
+set(_Fortran_libs_flag --flibs)
+set(_CXX_libs_flag --libs)
+set(_C_includes_flag --includedir)
+set(_Fortran_includes_flag --includedir)
+set(_CXX_includes_flag --includedir)
+function(netcdf_config exec flag output_var)
+  set(${output_var} False PARENT_SCOPE)
+  if( exec )
+    execute_process( COMMAND ${exec} ${flag} RESULT_VARIABLE _ret OUTPUT_VARIABLE _val)
+    if( _ret EQUAL 0 )
+      string( STRIP ${_val} _val )
+      set( ${output_var} ${_val} PARENT_SCOPE )
+    endif()
+  endif()
+endfunction()
+
+## Find libraries for each component
+set( NetCDF_LIBRARIES )
+foreach( _comp IN LISTS _search_components )
+  string( TOUPPER "${_comp}" _COMP )
+
+  find_library( NetCDF_${_comp}_LIBRARY
+    NAMES ${NetCDF_${_comp}_LIBRARY_NAME}
+    DOC "NetCDF ${_comp} library"
+    HINTS ${NetCDF_${_comp}_INCLUDE_DIRS} ${_search_hints}
+    PATH_SUFFIXES lib64 lib ../lib64 ../lib ../../lib64 ../../lib )
+  mark_as_advanced( NetCDF_${_comp}_LIBRARY )
+  get_filename_component(NetCDF_${_comp}_LIBRARY ${NetCDF_${_comp}_LIBRARY} ABSOLUTE)
+  set(NetCDF_${_comp}_LIBRARY ${NetCDF_${_comp}_LIBRARY} CACHE STRING "NetCDF ${_comp} library" FORCE)
+  message(DEBUG "NetCDF_${_comp}_LIBRARY: ${NetCDF_${_comp}_LIBRARY}")
+
+  if( NetCDF_${_comp}_LIBRARY )
+    if( NetCDF_${_comp}_LIBRARY MATCHES ".a$" )
+      set( NetCDF_${_comp}_LIBRARY_SHARED FALSE )
+      set( _library_type STATIC)
+    else()
+      list( APPEND NetCDF_LIBRARIES ${NetCDF_${_comp}_LIBRARY} )
+      set( NetCDF_${_comp}_LIBRARY_SHARED TRUE )
+      set( _library_type SHARED)
+    endif()
+  endif()
+
+  #Use nc-config to set per-component LIBRARIES variable if possible
+  netcdf_config( ${NetCDF_${_comp}_CONFIG_EXECUTABLE} ${_${_comp}_libs_flag} _val )
+  if( _val )
+    set( NetCDF_${_comp}_LIBRARIES ${_val} )
+    if(NOT NetCDF_${_comp}_LIBRARY_SHARED AND NOT NetCDF_${_comp}_FOUND) #Static targets should use nc_config to get a proper link line with all necessary static targets.
+      list( APPEND NetCDF_LIBRARIES ${NetCDF_${_comp}_LIBRARIES} )
+    endif()
+  else()
+    set( NetCDF_${_comp}_LIBRARIES ${NetCDF_${_comp}_LIBRARY} )
+    if(NOT NetCDF_${_comp}_LIBRARY_SHARED)
+      message(SEND_ERROR "Unable to properly find NetCDF.  Found static libraries at: ${NetCDF_${_comp}_LIBRARY} but could not run nc-config: ${NetCDF_CONFIG_EXECUTABLE}")
+    endif()
+  endif()
+
+  #Use nc-config to set per-component INCLUDE_DIRS variable if possible
+  netcdf_config( ${NetCDF_${_comp}_CONFIG_EXECUTABLE} ${_${_comp}_includes_flag} _val )
+  if( _val )
+    string( REPLACE " " ";" _val ${_val} )
+    set( NetCDF_${_comp}_INCLUDE_DIRS ${_val} )
+  else()
+    set( NetCDF_${_comp}_INCLUDE_DIRS ${NetCDF_${_comp}_INCLUDE_DIR} )
+  endif()
+
+  if( NetCDF_${_comp}_LIBRARIES AND NetCDF_${_comp}_INCLUDE_DIRS )
+    set( ${CMAKE_FIND_PACKAGE_NAME}_${_arg_${_COMP}}_FOUND TRUE )
+    if (NOT TARGET NetCDF::NetCDF_${_comp})
+      add_library(NetCDF::NetCDF_${_comp} ${_library_type} IMPORTED)
+      set_target_properties(NetCDF::NetCDF_${_comp} PROPERTIES
+        IMPORTED_LOCATION ${NetCDF_${_comp}_LIBRARY}
+        INTERFACE_INCLUDE_DIRECTORIES "${NetCDF_${_comp}_INCLUDE_DIRS}"
+        INTERFACE_LINK_LIBRARIES ${NetCDF_${_comp}_LIBRARIES} )
+    endif()
+  endif()
+endforeach()
+if(NetCDF_LIBRARIES AND NetCDF_${_comp}_LIBRARY_SHARED)
+    list(REMOVE_DUPLICATES NetCDF_LIBRARIES)
+endif()
+set(NetCDF_LIBRARIES "${NetCDF_LIBRARIES}" CACHE STRING "NetCDF library targets" FORCE)
+
+## Find version via netcdf-config if possible
+if (NetCDF_INCLUDE_DIRS)
+  if( NetCDF_C_CONFIG_EXECUTABLE )
+    netcdf_config( ${NetCDF_C_CONFIG_EXECUTABLE} --version _vers )
+    if( _vers )
+      string(REGEX REPLACE ".* ((([0-9]+)\\.)+([0-9]+)).*" "\\1" NetCDF_VERSION "${_vers}" )
+    endif()
+  else()
+    foreach( _dir IN LISTS NetCDF_INCLUDE_DIRS)
+      if( EXISTS "${_dir}/netcdf_meta.h" )
+        file(STRINGS "${_dir}/netcdf_meta.h" _netcdf_version_lines
+        REGEX "#define[ \t]+NC_VERSION_(MAJOR|MINOR|PATCH|NOTE)")
+        string(REGEX REPLACE ".*NC_VERSION_MAJOR *\([0-9]*\).*" "\\1" _netcdf_version_major "${_netcdf_version_lines}")
+        string(REGEX REPLACE ".*NC_VERSION_MINOR *\([0-9]*\).*" "\\1" _netcdf_version_minor "${_netcdf_version_lines}")
+        string(REGEX REPLACE ".*NC_VERSION_PATCH *\([0-9]*\).*" "\\1" _netcdf_version_patch "${_netcdf_version_lines}")
+        string(REGEX REPLACE ".*NC_VERSION_NOTE *\"\([^\"]*\)\".*" "\\1" _netcdf_version_note "${_netcdf_version_lines}")
+        set(NetCDF_VERSION "${_netcdf_version_major}.${_netcdf_version_minor}.${_netcdf_version_patch}${_netcdf_version_note}")
+        unset(_netcdf_version_major)
+        unset(_netcdf_version_minor)
+        unset(_netcdf_version_patch)
+        unset(_netcdf_version_note)
+        unset(_netcdf_version_lines)
+      endif()
+    endforeach()
+  endif()
+endif ()
+
+## Detect additional package properties
+netcdf_config(${NetCDF_C_CONFIG_EXECUTABLE} --has-parallel4 _val)
+if( NOT _val MATCHES "^(yes|no)$" )
+  netcdf_config(${NetCDF_C_CONFIG_EXECUTABLE} --has-parallel _val)
+endif()
+if( _val MATCHES "^(yes)$" )
+  set(NetCDF_PARALLEL TRUE CACHE STRING "NetCDF has parallel IO capability via pnetcdf or hdf5." FORCE)
+else()
+  set(NetCDF_PARALLEL FALSE CACHE STRING "NetCDF has no parallel IO capability." FORCE)
+endif()
+
+## Finalize find_package
+include(FindPackageHandleStandardArgs)
+
+if(NOT NetCDF_FOUND OR _new_search_components)
+    find_package_handle_standard_args( ${CMAKE_FIND_PACKAGE_NAME}
+        REQUIRED_VARS NetCDF_INCLUDE_DIRS NetCDF_LIBRARIES
+        VERSION_VAR NetCDF_VERSION
+        HANDLE_COMPONENTS )
+endif()
+
+foreach( _comp IN LISTS _search_components )
+    if( NetCDF_${_comp}_FOUND )
+        #Record found components to avoid duplication in NetCDF_LIBRARIES for static libraries
+        set(NetCDF_${_comp}_FOUND ${NetCDF_${_comp}_FOUND} CACHE BOOL "NetCDF ${_comp} Found" FORCE)
+        #Set a per-package, per-component found variable to communicate between multiple calls to find_package()
+        set(${PROJECT_NAME}_NetCDF_${_comp}_FOUND True)
+    endif()
+endforeach()
+
+if( ${CMAKE_FIND_PACKAGE_NAME}_FOUND AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY AND _new_search_components)
+  message( STATUS "Find${CMAKE_FIND_PACKAGE_NAME} defines targets:" )
+  message( STATUS "  - NetCDF_VERSION [${NetCDF_VERSION}]")
+  message( STATUS "  - NetCDF_PARALLEL [${NetCDF_PARALLEL}]")
+  foreach( _comp IN LISTS _new_search_components )
+    string( TOUPPER "${_comp}" _COMP )
+    message( STATUS "  - NetCDF_${_comp}_CONFIG_EXECUTABLE [${NetCDF_${_comp}_CONFIG_EXECUTABLE}]")
+    if( ${CMAKE_FIND_PACKAGE_NAME}_${_arg_${_COMP}}_FOUND )
+      get_filename_component(_root ${NetCDF_${_comp}_INCLUDE_DIR}/.. ABSOLUTE)
+      if( NetCDF_${_comp}_LIBRARY_SHARED )
+        message( STATUS "  - NetCDF::NetCDF_${_comp} [SHARED] [Root: ${_root}] Lib: ${NetCDF_${_comp}_LIBRARY} ")
+      else()
+        message( STATUS "  - NetCDF::NetCDF_${_comp} [STATIC] [Root: ${_root}] Lib: ${NetCDF_${_comp}_LIBRARY} ")
+      endif()
+    endif()
+  endforeach()
+endif()
+
+foreach( _prefix NetCDF NetCDF4 NETCDF NETCDF4 ${CMAKE_FIND_PACKAGE_NAME} )
+  set( ${_prefix}_INCLUDE_DIRS ${NetCDF_INCLUDE_DIRS} )
+  set( ${_prefix}_LIBRARIES    ${NetCDF_LIBRARIES})
+  set( ${_prefix}_VERSION      ${NetCDF_VERSION} )
+  set( ${_prefix}_FOUND        ${${CMAKE_FIND_PACKAGE_NAME}_FOUND} )
+  set( ${_prefix}_CONFIG_EXECUTABLE ${NetCDF_CONFIG_EXECUTABLE} )
+  set( ${_prefix}_PARALLEL ${NetCDF_PARALLEL} )
+
+  foreach( _comp ${_search_components} )
+    string( TOUPPER "${_comp}" _COMP )
+    set( _arg_comp ${_arg_${_COMP}} )
+    set( ${_prefix}_${_comp}_FOUND     ${${CMAKE_FIND_PACKAGE_NAME}_${_arg_comp}_FOUND} )
+    set( ${_prefix}_${_COMP}_FOUND     ${${CMAKE_FIND_PACKAGE_NAME}_${_arg_comp}_FOUND} )
+    set( ${_prefix}_${_arg_comp}_FOUND ${${CMAKE_FIND_PACKAGE_NAME}_${_arg_comp}_FOUND} )
+
+    set( ${_prefix}_${_comp}_LIBRARIES     ${NetCDF_${_comp}_LIBRARIES} )
+    set( ${_prefix}_${_COMP}_LIBRARIES     ${NetCDF_${_comp}_LIBRARIES} )
+    set( ${_prefix}_${_arg_comp}_LIBRARIES ${NetCDF_${_comp}_LIBRARIES} )
+
+    set( ${_prefix}_${_comp}_INCLUDE_DIRS     ${NetCDF_${_comp}_INCLUDE_DIRS} )
+    set( ${_prefix}_${_COMP}_INCLUDE_DIRS     ${NetCDF_${_comp}_INCLUDE_DIRS} )
+    set( ${_prefix}_${_arg_comp}_INCLUDE_DIRS ${NetCDF_${_comp}_INCLUDE_DIRS} )
+  endforeach()
+endforeach()
diff --git a/cmake/FindPIO.cmake b/cmake/FindPIO.cmake
new file mode 100644
index 0000000000..cbbd89f793
--- /dev/null
+++ b/cmake/FindPIO.cmake
@@ -0,0 +1,210 @@
+
+# FindPIO.cmake
+#
+# Copyright UCAR 2020
+# Copyright NOAA/NWS/NCEP/EMC 2020
+#
+# Find PIO: A high-level Parallel I/O Library for structured grid applications
+# https://github.com/NCAR/ParallelIO
+#
+# Components available for query:
+#  C - Has C support
+#  Fortran - Has Fortran support
+#  SHARED - Has shared targets
+#  STATIC - Has static targets
+#
+# Variables provided:
+#  PIO_FOUND - True if PIO was found
+#  PIO_C_FOUND - True if PIO C support was found
+#  PIO_Fortran_FOUND - True if PIO Fortran support was found
+#  PIO_VERSION - Version of installed PIO
+#
+# Targets provided:
+#  PIO::PIO_C - C interface target aliased to SHARED|STATIC as requested or to shared libraries if available else static libraries
+#  PIO::PIO_Fortran - Fortran interface target aliases to SHARED|STATIC as requested or to shared libraries if available else static libraries
+#
+# To control finding of this package, set PIO_ROOT environment variable to the full path to the prefix
+# under which PIO was installed (e.g., /usr/local)
+
+set( _search_components )
+set( _search_library_type )
+foreach( _comp ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS} )
+    if( _comp MATCHES "^(STATIC|SHARED)$" )
+        list( APPEND _search_library_type ${_comp} )
+    else()
+        list( APPEND _search_components ${_comp} )
+    endif()
+endforeach()
+set( ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS ${_search_components} )
+
+# If no COMPONENTS are requested, seach both C and Fortran
+if( NOT _search_components )
+    list( APPEND _search_components C Fortran )
+endif()
+
+# Ensure there is only one type of library being requested
+if( _search_library_type )
+    list( LENGTH _search_library_type _len)
+    if( _len GREATER 1 )
+        message(FATAL_ERROR "User requesting both STATIC and SHARED is not permissible")
+    endif()
+    unset(_len)
+endif()
+
+## Find libraries and paths, and determine found components
+find_path(PIO_INCLUDE_DIR NAMES pio.h HINTS "${PIO_PREFIX}" PATH_SUFFIXES include include/pio)
+if(PIO_INCLUDE_DIR)
+    string(REGEX REPLACE "/include(/.+)?" "" PIO_PREFIX ${PIO_INCLUDE_DIR})
+    set(PIO_PREFIX ${PIO_PREFIX} CACHE STRING "")
+    find_path(PIO_MODULE_DIR NAMES pio.mod PATHS "${PIO_PREFIX}"
+              PATH_SUFFIXES include include/pio lib/pio/module module module/pio NO_DEFAULT_PATH)
+    if(APPLE)
+      set(_SHARED_LIB_EXT dylib)
+    else()
+      set(_SHARED_LIB_EXT so)
+    endif()
+    find_library(PIO_C_STATIC_LIB libpioc.a PATHS "${PIO_PREFIX}" PATH_SUFFIXES lib lib64 NO_DEFAULT_PATH)
+    find_library(PIO_C_SHARED_LIB libpioc.${_SHARED_LIB_EXT} PATHS "${PIO_PREFIX}" PATH_SUFFIXES lib lib64 NO_DEFAULT_PATH)
+    find_library(PIO_Fortran_STATIC_LIB libpiof.a PATHS "${PIO_PREFIX}" PATH_SUFFIXES lib lib64 NO_DEFAULT_PATH)
+    find_library(PIO_Fortran_SHARED_LIB libpiof.${_SHARED_LIB_EXT} PATHS "${PIO_PREFIX}" PATH_SUFFIXES lib lib64 NO_DEFAULT_PATH)
+    unset(_SHARED_LIB_EXT)
+    #Check for Fortran components
+    if(PIO_MODULE_DIR)
+        if(PIO_Fortran_STATIC_LIB)
+            set(PIO_Fortran_STATIC_FOUND 1)
+        endif()
+        if(PIO_Fortran_SHARED_LIB)
+            set(PIO_Fortran_SHARED_FOUND 1)
+        endif()
+    endif()
+    #Check for C components
+    if(PIO_C_STATIC_LIB)
+        set(PIO_C_STATIC_FOUND 1)
+    endif()
+    if(PIO_C_SHARED_LIB)
+        set(PIO_C_SHARED_FOUND 1)
+    endif()
+endif()
+## Debugging output
+message(DEBUG "[FindPIO] PIO_INCLUDE_DIR: ${PIO_INCLUDE_DIR}")
+message(DEBUG "[FindPIO] PIO_PREFIX: ${PIO_PREFIX}")
+message(DEBUG "[FindPIO] PIO_MODULE_DIR: ${PIO_MODULE_DIR}")
+message(DEBUG "[FindPIO] PIO_C_STATIC_LIB: ${PIO_C_STATIC_LIB}")
+message(DEBUG "[FindPIO] PIO_C_SHARED_LIB: ${PIO_C_SHARED_LIB}")
+message(DEBUG "[FindPIO] PIO_C_SHARED_FOUND: ${PIO_C_SHARED_FOUND}")
+message(DEBUG "[FindPIO] PIO_C_STATIC_FOUND: ${PIO_C_STATIC_FOUND}")
+message(DEBUG "[FindPIO] PIO_Fortran_STATIC_LIB: ${PIO_Fortran_STATIC_LIB}")
+message(DEBUG "[FindPIO] PIO_Fortran_SHARED_LIB: ${PIO_Fortran_SHARED_LIB}")
+message(DEBUG "[FindPIO] PIO_Fortran_SHARED_FOUND: ${PIO_Fortran_SHARED_FOUND}")
+message(DEBUG "[FindPIO] PIO_Fortran_STATIC_FOUND: ${PIO_Fortran_STATIC_FOUND}")
+
+## Create targets
+set(_new_components)
+# PIO_C_STATIC imported interface target
+if(PIO_C_STATIC_FOUND AND NOT TARGET PIO_C_STATIC)
+    add_library(PIO_C_STATIC INTERFACE IMPORTED)
+    set_target_properties(PIO_C_STATIC PROPERTIES
+                          INTERFACE_INCLUDE_DIRECTORIES ${PIO_INCLUDE_DIR}
+                          INTERFACE_LINK_LIBRARIES ${PIO_C_STATIC_LIB}
+                          IMPORTED_GLOBAL True )
+    set(_new_components 1)
+endif()
+# PIO_C_SHARED imported interface target
+if(PIO_C_SHARED_FOUND AND NOT TARGET PIO_C_SHARED)
+    add_library(PIO_C_SHARED INTERFACE IMPORTED)
+    set_target_properties(PIO_C_SHARED PROPERTIES
+                          INTERFACE_INCLUDE_DIRECTORIES ${PIO_INCLUDE_DIR}
+                          INTERFACE_LINK_LIBRARIES ${PIO_C_SHARED_LIB}
+                          IMPORTED_GLOBAL True )
+    set(_new_components 1)
+endif()
+# PIO_Fortran_STATIC imported interface target
+if(PIO_Fortran_STATIC_FOUND AND NOT TARGET PIO_Fortran_STATIC)
+    add_library(PIO_Fortran_STATIC INTERFACE IMPORTED)
+    set_target_properties(PIO_Fortran_STATIC PROPERTIES
+                          INTERFACE_INCLUDE_DIRECTORIES ${PIO_INCLUDE_DIR}
+                          INTERFACE_LINK_LIBRARIES ${PIO_Fortran_STATIC_LIB}
+                          IMPORTED_GLOBAL True )
+    if(PIO_MODULE_DIR AND NOT PIO_MODULE_DIR STREQUAL PIO_INCLUDE_DIR )
+        set_property(TARGET PIO_Fortran_STATIC APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PIO_MODULE_DIR})
+    endif()
+    set(_new_components 1)
+    target_link_libraries(PIO_Fortran_STATIC INTERFACE PIO_C_STATIC)
+endif()
+# PIO_Fortran_SHARED imported interface target
+if(PIO_Fortran_SHARED_FOUND AND NOT TARGET PIO_Fortran_SHARED)
+    add_library(PIO_Fortran_SHARED INTERFACE IMPORTED)
+    set_target_properties(PIO_Fortran_SHARED PROPERTIES
+                          INTERFACE_INCLUDE_DIRECTORIES ${PIO_INCLUDE_DIR}
+                          INTERFACE_LINK_LIBRARIES ${PIO_Fortran_SHARED_LIB}
+                          IMPORTED_GLOBAL True )
+    if(PIO_MODULE_DIR AND NOT PIO_MODULE_DIR STREQUAL PIO_INCLUDE_DIR )
+        set_property(TARGET PIO_Fortran_SHARED APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PIO_MODULE_DIR})
+    endif()
+    target_link_libraries(PIO_Fortran_SHARED INTERFACE PIO_C_SHARED)
+    set(_new_components 1)
+endif()
+
+if( _search_library_type MATCHES "^(SHARED)$" )
+  if( TARGET PIO_C_SHARED )
+      add_library(PIO::PIO_C ALIAS PIO_C_SHARED)
+      set(PIO_C_FOUND 1)
+  endif()
+  if( TARGET PIO_Fortran_SHARED )
+      add_library(PIO::PIO_Fortran ALIAS PIO_Fortran_SHARED)
+      set(PIO_Fortran_FOUND 1)
+  endif()
+elseif( _search_library_type MATCHES "^(STATIC)$" )
+  if( TARGET PIO_C_STATIC )
+      add_library(PIO::PIO_C ALIAS PIO_C_STATIC)
+      set(PIO_C_FOUND 1)
+  endif()
+  if( TARGET PIO_Fortran_STATIC )
+      add_library(PIO::PIO_Fortran ALIAS PIO_Fortran_STATIC)
+      set(PIO_Fortran_FOUND 1)
+  endif()
+else()
+  if( TARGET PIO_C_SHARED )
+        add_library(PIO::PIO_C ALIAS PIO_C_SHARED)
+        set(PIO_C_FOUND 1)
+  elseif( TARGET PIO_C_STATIC )
+        add_library(PIO::PIO_C ALIAS PIO_C_STATIC)
+        set(PIO_C_FOUND 1)
+  endif()
+  if( TARGET PIO_Fortran_SHARED )
+      add_library(PIO::PIO_Fortran ALIAS PIO_Fortran_SHARED)
+      set(PIO_Fortran_FOUND 1)
+  elseif( TARGET PIO_Fortran_STATIC )
+      add_library(PIO::PIO_Fortran ALIAS PIO_Fortran_STATIC)
+      set(PIO_Fortran_FOUND 1)
+  endif()
+endif()
+
+## Check package has been found correctly
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+  PIO
+  REQUIRED_VARS
+    PIO_PREFIX
+    PIO_INCLUDE_DIR
+  HANDLE_COMPONENTS
+)
+message(DEBUG "[FindPIO] PIO_FOUND: ${PIO_FOUND}")
+
+## Print status
+if(${CMAKE_FIND_PACKAGE_NAME}_FOUND AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY AND _new_components)
+    message( STATUS "Find${CMAKE_FIND_PACKAGE_NAME}:" )
+    message( STATUS "  - ${CMAKE_FIND_PACKAGE_NAME}_PREFIX [${${CMAKE_FIND_PACKAGE_NAME}_PREFIX}]")
+    set(_found_comps)
+    foreach( _comp ${_search_components} )
+        if( ${CMAKE_FIND_PACKAGE_NAME}_${_comp}_FOUND )
+            list(APPEND _found_comps ${_comp})
+        endif()
+    endforeach()
+    message( STATUS "  - ${CMAKE_FIND_PACKAGE_NAME} Components Found: ${_found_comps}")
+    unset(_found_comps)
+endif()
+unset(_new_components)
+unset(_search_components)
+unset(_search_library_type)
+unset(_library_type)
diff --git a/cmake/FortranLib.cmake b/cmake/FortranLib.cmake
new file mode 100644
index 0000000000..08bcccbf8c
--- /dev/null
+++ b/cmake/FortranLib.cmake
@@ -0,0 +1,8 @@
+function(add_fortran_library LIB MOD_DIR)
+    add_library(${LIB} ${ARGN})
+
+    get_target_property(LIB_DIR ${LIB} BINARY_DIR)
+    set_target_properties(${LIB} PROPERTIES Fortran_MODULE_DIRECTORY ${LIB_DIR}/${MOD_DIR})
+
+    target_include_directories(${LIB} INTERFACE "$<BUILD_INTERFACE:${LIB_DIR}/${MOD_DIR}>")
+  endfunction(add_fortran_library)
diff --git a/cmake/MOM6libConfig.cmake.in b/cmake/MOM6libConfig.cmake.in
new file mode 100644
index 0000000000..531a90cb4c
--- /dev/null
+++ b/cmake/MOM6libConfig.cmake.in
@@ -0,0 +1,24 @@
+@PACKAGE_INIT@
+
+if(NOT MOM6lib_FIND_QUIETLY)
+  message(STATUS "Found MOM6lib: ${PACKAGE_PREFIX_DIR}")
+endif()
+
+include(CMakeFindDependencyMacro)
+
+# Request components
+set(_required_components ${MOM6lib_FIND_COMPONENTS})
+
+find_dependency(fms COMPONENTS R8 REQUIRED)
+find_dependency(NetCDF REQUIRED Fortran)
+if (NOT NetCDF_PARALLEL)
+    message(FATAL_ERROR "NetCDF does not have parallel I/O support!")
+endif()
+
+# Run the normal Targets.cmake
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
+include("${CMAKE_CURRENT_LIST_DIR}/MOM6libTargets.cmake")
+list(REMOVE_ITEM CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
+
+# Check the requested components are valid
+check_required_components(_required_components)
\ No newline at end of file