diff --git a/.docs/conf.py b/.docs/conf.py
index 8cec71a8d..2f9b38f78 100644
--- a/.docs/conf.py
+++ b/.docs/conf.py
@@ -249,3 +249,13 @@
 
 # Output file base name for HTML help builder.
 htmlhelp_basename = "flopydoc"
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3/", None),
+    "numpy": ("https://docs.scipy.org/doc/numpy/", None),
+    "scipy": ("https://docs.scipy.org/doc/scipy/reference/", None),
+    "pandas": ("https://pandas.pydata.org/pandas-docs/stable", None),
+    "matplotlib": ("https://matplotlib.org", None),
+    "pyproj": ("https://pyproj4.github.io/pyproj/stable/", None),
+}
diff --git a/autotest/test_epsgreference.py b/autotest/test_epsgreference.py
deleted file mode 100644
index 715c3b17c..000000000
--- a/autotest/test_epsgreference.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from flaky import flaky
-
-from flopy.export.shapefile_utils import CRS, EpsgReference
-
-
-@flaky
-def test_epsgreference():
-    ep = EpsgReference()
-    ep.reset()
-    ep.show()
-
-    prjtxt = CRS.getprj(32614)  # WGS 84 / UTM zone 14N
-    if prjtxt is None:
-        print("unable to retrieve CRS prj txt")
-        return
-    assert isinstance(prjtxt, str), type(prjtxt)
-    prj = ep.to_dict()
-    assert 32614 in prj
-    ep.show()
-
-    ep.add(9999, "junk")
-    prj = ep.to_dict()
-    assert 9999 in prj
-    assert ep.get(9999) == "junk"
-    ep.show()
-
-    ep.remove(9999)
-    prj = ep.to_dict()
-    assert 9999 not in prj
-    ep.show()
-
-    assert ep.get(9999) is None
-
-    ep.reset()
-    prj = ep.to_dict()
-    assert len(prj) == 0
-    ep.show()
diff --git a/autotest/test_export.py b/autotest/test_export.py
index e81549af8..9faa91182 100644
--- a/autotest/test_export.py
+++ b/autotest/test_export.py
@@ -13,18 +13,13 @@
     excludes_platform,
     requires_exe,
     requires_pkg,
-    requires_spatial_reference,
 )
 from modflow_devtools.misc import has_pkg
 
 import flopy
 from flopy.discretization import StructuredGrid, UnstructuredGrid
 from flopy.export import NetCdf
-from flopy.export.shapefile_utils import (
-    EpsgReference,
-    recarray2shp,
-    shp2recarray,
-)
+from flopy.export.shapefile_utils import recarray2shp, shp2recarray
 from flopy.export.utils import (
     export_array,
     export_array_contours,
@@ -53,6 +48,7 @@
     import_optional_dependency,
 )
 from flopy.utils import postprocessing as pp
+from flopy.utils.crs import get_authority_crs
 from flopy.utils.geometry import Polygon
 
 
@@ -62,14 +58,23 @@ def namfiles() -> List[Path]:
 
 
 @requires_pkg("shapefile")
-def test_output_helper_shapefile_export(function_tmpdir, example_data_path):
-    ws = example_data_path / "freyberg_multilayer_transient"
-    ml = Modflow.load("freyberg.nam", model_ws=ws)
-    head = HeadFile(ws / "freyberg.hds")
-    cbc = CellBudgetFile(ws / "freyberg.cbc")
+@pytest.mark.parametrize("pathlike", (True, False))
+def test_output_helper_shapefile_export(
+    pathlike, function_tmpdir, example_data_path
+):
+    ml = Modflow.load(
+        "freyberg.nam",
+        model_ws=str(example_data_path / "freyberg_multilayer_transient"),
+    )
+    head = HeadFile(os.path.join(ml.model_ws, "freyberg.hds"))
+    cbc = CellBudgetFile(os.path.join(ml.model_ws, "freyberg.cbc"))
 
+    if pathlike:
+        outpath = function_tmpdir / "test-pathlike.shp"
+    else:
+        outpath = os.path.join(function_tmpdir, "test.shp")
     flopy.export.utils.output_helper(
-        function_tmpdir / "test.shp",
+        outpath,
         ml,
         {"HDS": head, "cbc": cbc},
         mflay=1,
@@ -105,6 +110,7 @@ def test_freyberg_export(function_tmpdir, example_data_path):
         load_only=["DIS", "BAS6", "NWT", "OC", "RCH", "WEL", "DRN", "UPW"],
     )
     # test export without instantiating an sr
+    m.modelgrid.crs = None
     shape = function_tmpdir / f"{name}_drn_sparse.shp"
     m.drn.stress_period_data.export(shape, sparse=True)
     for suffix in [".dbf", ".shp", ".shx"]:
@@ -114,7 +120,7 @@ def test_freyberg_export(function_tmpdir, example_data_path):
     assert not shape.with_suffix(".prj").exists()
 
     m.modelgrid = StructuredGrid(
-        delc=m.dis.delc.array, delr=m.dis.delr.array, epsg=3070
+        delc=m.dis.delc.array, delr=m.dis.delr.array, crs=3070
     )
     # test export with an sr, regardless of whether or not wkt was found
     m.drn.stress_period_data.export(shape, sparse=True)
@@ -124,19 +130,16 @@ def test_freyberg_export(function_tmpdir, example_data_path):
         part.unlink()
 
     m.modelgrid = StructuredGrid(
-        delc=m.dis.delc.array, delr=m.dis.delr.array, epsg=3070
+        delc=m.dis.delc.array, delr=m.dis.delr.array, crs=3070
     )
     # verify that attributes have same sr as parent
-    assert m.drn.stress_period_data.mg.epsg == m.modelgrid.epsg
-    assert m.drn.stress_period_data.mg.proj4 == m.modelgrid.proj4
+    assert m.drn.stress_period_data.mg.crs == m.modelgrid.crs
     assert m.drn.stress_period_data.mg.xoffset == m.modelgrid.xoffset
     assert m.drn.stress_period_data.mg.yoffset == m.modelgrid.yoffset
     assert m.drn.stress_period_data.mg.angrot == m.modelgrid.angrot
 
     # get wkt text was fetched from spatialreference.org
-    wkt = flopy.export.shapefile_utils.CRS.get_spatialreference(
-        m.modelgrid.epsg
-    )
+    wkt = m.modelgrid.crs.to_wkt()
 
     # if wkt text was fetched from spatialreference.org
     if wkt is not None:
@@ -162,13 +165,19 @@ def test_freyberg_export(function_tmpdir, example_data_path):
                 assert part.read_text() == wkt
 
 
+# for now, test with and without a coordinate reference system
+@pytest.mark.parametrize("crs", (None, 26916))
 @requires_pkg("netCDF4", "pyproj")
-def test_export_output(function_tmpdir, example_data_path):
-    ml = Modflow.load("freyberg.nam", model_ws=example_data_path / "freyberg")
+def test_export_output(crs, function_tmpdir, example_data_path):
+    ml = Modflow.load(
+        "freyberg.nam", model_ws=str(example_data_path / "freyberg")
+    )
+    ml.modelgrid.crs = crs
     hds_pth = os.path.join(ml.model_ws, "freyberg.githds")
     hds = flopy.utils.HeadFile(hds_pth)
 
-    out_pth = os.path.join(function_tmpdir, "freyberg.out.nc")
+    function_tmpdir = Path(".")
+    out_pth = function_tmpdir / f"freyberg_{crs}.out.nc"
     nc = flopy.export.utils.output_helper(
         out_pth, ml, {"freyberg.githds": hds}
     )
@@ -181,6 +190,17 @@ def test_export_output(function_tmpdir, example_data_path):
     # close the netcdf file
     nc.nc.close()
 
+    # verify that the CRS was written correctly
+    import netCDF4
+    import pyproj
+
+    ds = netCDF4.Dataset(out_pth)
+    read_crs = pyproj.CRS.from_cf(ds["latitude_longitude"].__dict__)
+    # currently, NetCDF files are only written
+    # in the 4326 coordinate reference system
+    # (lat/lon WGS 84)
+    assert read_crs == get_authority_crs(4326)
+
 
 @requires_pkg("shapefile")
 def test_write_gridlines_shapefile(function_tmpdir):
@@ -194,7 +214,7 @@ def test_write_gridlines_shapefile(function_tmpdir):
         # cell spacing along model rows
         delc=np.ones(10) * 1.1,
         # cell spacing along model columns
-        epsg=26715,
+        crs=26715,
     )
     outshp = function_tmpdir / "gridlines.shp"
     write_gridlines_shapefile(outshp, sg)
@@ -207,56 +227,6 @@ def test_write_gridlines_shapefile(function_tmpdir):
         assert len(sf) == 22
 
 
-@flaky
-@requires_pkg("shapefile", "shapely")
-def test_write_grid_shapefile(function_tmpdir):
-    from shapefile import Reader
-
-    from flopy.discretization import StructuredGrid
-    from flopy.export.shapefile_utils import write_grid_shapefile
-
-    sg = StructuredGrid(
-        delr=np.ones(10) * 1.1,
-        # cell spacing along model rows
-        delc=np.ones(10) * 1.1,
-        # cell spacing along model columns
-        epsg=26715,
-    )
-    outshp = function_tmpdir / "junk.shp"
-    write_grid_shapefile(outshp, sg, array_dict={})
-
-    for suffix in [".dbf", ".prj", ".shp", ".shx"]:
-        assert outshp.with_suffix(suffix).exists()
-
-    # test that vertices aren't getting altered by writing shapefile
-    # check that pyshp reads integers
-    # this only check that row/column were recorded as "N"
-    # not how they will be cast by python or numpy
-    sfobj = Reader(str(outshp))
-    for f in sfobj.fields:
-        if f[0] == "row" or f[0] == "column":
-            assert f[1] == "N"
-    recs = list(sfobj.records())
-    for r in recs[0]:
-        assert isinstance(r, int)
-    sfobj.close()
-
-    # check that row and column appear as integers in recarray
-    ra = shp2recarray(outshp)
-    assert np.issubdtype(ra.dtype["row"], np.integer)
-    assert np.issubdtype(ra.dtype["column"], np.integer)
-
-    try:  # check that fiona reads integers
-        import fiona
-
-        with fiona.open(outshp) as src:
-            meta = src.meta
-            assert "int" in meta["schema"]["properties"]["row"]
-            assert "int" in meta["schema"]["properties"]["column"]
-    except ImportError:
-        pass
-
-
 @requires_pkg("shapefile")
 def test_export_shapefile_polygon_closed(function_tmpdir):
     from shapefile import Reader
@@ -270,9 +240,7 @@ def test_export_shapefile_polygon_closed(function_tmpdir):
     nrow = int((yur - yll) / spacing)
     print(nrow, ncol)
 
-    m = flopy.modflow.Modflow(
-        "test.nam", proj4_str="EPSG:32614", xll=xll, yll=yll
-    )
+    m = flopy.modflow.Modflow("test.nam", crs="EPSG:32614", xll=xll, yll=yll)
 
     flopy.modflow.ModflowDis(
         m, delr=spacing, delc=spacing, nrow=nrow, ncol=ncol
@@ -381,41 +349,6 @@ def test_netcdf_classmethods(function_tmpdir, example_data_path):
     new_f.nc.close()
 
 
-def test_wkt_parse(example_shapefiles):
-    """Test parsing of Coordinate Reference System parameters
-    from well-known-text in .prj files."""
-
-    from flopy.export.shapefile_utils import CRS
-
-    geocs_params = [
-        "wktstr",
-        "geogcs",
-        "datum",
-        "spheroid_name",
-        "semi_major_axis",
-        "inverse_flattening",
-        "primem",
-        "gcs_unit",
-    ]
-
-    for prj in example_shapefiles:
-        with open(prj) as src:
-            wkttxt = src.read()
-            wkttxt = wkttxt.replace("'", '"')
-        if len(wkttxt) > 0 and "projcs" in wkttxt.lower():
-            crsobj = CRS(esri_wkt=wkttxt)
-            assert isinstance(crsobj.crs, dict)
-            for k in geocs_params:
-                assert crsobj.__dict__[k] is not None
-            projcs_params = [
-                k for k in crsobj.__dict__ if k not in geocs_params
-            ]
-            if crsobj.projcs is not None:
-                for k in projcs_params:
-                    if k in wkttxt.lower():
-                        assert crsobj.__dict__[k] is not None
-
-
 @requires_pkg("shapefile")
 def test_shapefile_ibound(function_tmpdir, example_data_path):
     from shapefile import Reader
@@ -481,8 +414,7 @@ def test_shapefile_export_modelgrid_override(function_tmpdir, namfile):
         grid.botm,
         grid.idomain,
         grid.lenuni,
-        grid.epsg,
-        grid.proj4,
+        grid.crs,
         xoff=grid.xoffset,
         yoff=grid.yoffset,
         angrot=grid.angrot,
@@ -536,7 +468,7 @@ def test_export_netcdf(function_tmpdir, namfile):
 def test_export_array2(function_tmpdir):
     nrow = 7
     ncol = 11
-    epsg = 4111
+    crs = 4431
 
     # no epsg code
     modelgrid = StructuredGrid(
@@ -549,7 +481,7 @@ def test_export_array2(function_tmpdir):
 
     # with modelgrid epsg code
     modelgrid = StructuredGrid(
-        delr=np.ones(ncol) * 1.1, delc=np.ones(nrow) * 1.1, epsg=epsg
+        delr=np.ones(ncol) * 1.1, delc=np.ones(nrow) * 1.1, crs=crs
     )
     filename = os.path.join(function_tmpdir, "myarray2.shp")
     a = np.arange(nrow * ncol).reshape((nrow, ncol))
@@ -562,7 +494,7 @@ def test_export_array2(function_tmpdir):
     )
     filename = os.path.join(function_tmpdir, "myarray3.shp")
     a = np.arange(nrow * ncol).reshape((nrow, ncol))
-    export_array(modelgrid, filename, a, epsg=epsg)
+    export_array(modelgrid, filename, a, crs=crs)
     assert os.path.isfile(filename), "did not create array shapefile"
 
 
@@ -570,7 +502,7 @@ def test_export_array2(function_tmpdir):
 def test_export_array_contours(function_tmpdir):
     nrow = 7
     ncol = 11
-    epsg = 4111
+    crs = 4431
 
     # no epsg code
     modelgrid = StructuredGrid(
@@ -581,22 +513,24 @@ def test_export_array_contours(function_tmpdir):
     export_array_contours(modelgrid, filename, a)
     assert os.path.isfile(filename), "did not create contour shapefile"
 
-    # with modelgrid epsg code
+    # with modelgrid coordinate reference
     modelgrid = StructuredGrid(
-        delr=np.ones(ncol) * 1.1, delc=np.ones(nrow) * 1.1, epsg=epsg
+        delr=np.ones(ncol) * 1.1,
+        delc=np.ones(nrow) * 1.1,
+        crs=crs,
     )
     filename = function_tmpdir / "myarraycontours2.shp"
     a = np.arange(nrow * ncol).reshape((nrow, ncol))
     export_array_contours(modelgrid, filename, a)
     assert os.path.isfile(filename), "did not create contour shapefile"
 
-    # with passing in epsg code
+    # with passing in coordinate reference
     modelgrid = StructuredGrid(
         delr=np.ones(ncol) * 1.1, delc=np.ones(nrow) * 1.1
     )
     filename = function_tmpdir / "myarraycontours3.shp"
     a = np.arange(nrow * ncol).reshape((nrow, ncol))
-    export_array_contours(modelgrid, filename, a, epsg=epsg)
+    export_array_contours(modelgrid, filename, a, crs=crs)
     assert os.path.isfile(filename), "did not create contour shapefile"
 
 
@@ -858,7 +792,7 @@ def test_polygon_from_ij(function_tmpdir):
         xoff=mg._xul_to_xll(600000.0, -45.0),
         yoff=mg._yul_to_yll(5170000, -45.0),
         angrot=-45.0,
-        proj4="EPSG:26715",
+        crs="EPSG:26715",
     )
 
     recarray = np.array(
@@ -889,7 +823,6 @@ def test_polygon_from_ij(function_tmpdir):
 
 @flaky
 @requires_pkg("netCDF4", "pyproj")
-@requires_spatial_reference
 def test_polygon_from_ij_with_epsg(function_tmpdir):
     ws = function_tmpdir
     m = Modflow("toy_model", model_ws=ws)
@@ -917,7 +850,7 @@ def test_polygon_from_ij_with_epsg(function_tmpdir):
         xoff=mg._xul_to_xll(600000.0, -45.0),
         yoff=mg._yul_to_yll(5170000, -45.0),
         angrot=-45.0,
-        proj4="EPSG:26715",
+        crs="EPSG:26715",
     )
 
     recarray = np.array(
@@ -943,16 +876,7 @@ def test_polygon_from_ij_with_epsg(function_tmpdir):
     ]
 
     fpth = os.path.join(ws, "test.shp")
-    recarray2shp(recarray, geoms, fpth, epsg=26715)
-
-    # tries to connect to https://spatialreference.org,
-    # might fail with CERTIFICATE_VERIFY_FAILED (on Mac,
-    # run Python Install Certificates) but intermittent
-    # 502s are also possible and possibly unavoidable)
-    ep = EpsgReference()
-    prj = ep.to_dict()
-
-    assert 26715 in prj
+    recarray2shp(recarray, geoms, fpth, crs=26715)
 
     fpth = os.path.join(ws, "test.prj")
     fpth2 = os.path.join(ws, "26715.prj")
diff --git a/autotest/test_grid.py b/autotest/test_grid.py
index 2698e05c4..fa8011a5c 100644
--- a/autotest/test_grid.py
+++ b/autotest/test_grid.py
@@ -9,16 +9,57 @@
 from flaky import flaky
 from matplotlib import pyplot as plt
 from modflow_devtools.markers import requires_exe, requires_pkg
+from packaging import version
 from pytest_cases import parametrize_with_cases
 
+import flopy
 from flopy.discretization import StructuredGrid, UnstructuredGrid, VertexGrid
 from flopy.mf6 import MFSimulation
 from flopy.modflow import Modflow, ModflowDis
+from flopy.utils.crs import get_authority_crs
 from flopy.utils.cvfdutil import gridlist_to_disv_gridprops, to_cvfd
 from flopy.utils.triangle import Triangle
 from flopy.utils.voronoi import VoronoiGrid
 
 
+@pytest.fixture
+def minimal_unstructured_grid_info():
+    d = {
+        # pass in simple 2 cell minimal grid to make grid valid
+        "vertices": [
+            [0, 0.0, 1.0],
+            [1, 1.0, 1.0],
+            [2, 2.0, 1.0],
+            [3, 0.0, 0.0],
+            [4, 1.0, 0.0],
+            [5, 2.0, 0.0],
+        ],
+        "iverts": [[0, 1, 4, 3], [1, 2, 5, 4]],
+        "xcenters": [0.5, 1.5],
+        "ycenters": [0.5, 0.5],
+    }
+    return d
+
+
+@pytest.fixture
+def minimal_vertex_grid_info(minimal_unstructured_grid_info):
+    usg_info = minimal_unstructured_grid_info
+    d = {}
+    d["vertices"] = minimal_unstructured_grid_info["vertices"]
+    cell2d = []
+    for n in range(len(usg_info["iverts"])):
+        cell2d_n = [
+            n,
+            usg_info["xcenters"][n],
+            usg_info["ycenters"][n],
+        ] + usg_info["iverts"][n]
+        cell2d.append(cell2d_n)
+    d["cell2d"] = cell2d
+    d["ncpl"] = len(cell2d)
+    d["nlay"] = 1
+    return d
+
+
 def test_rotation():
     m = Modflow(rotation=20.0)
     dis = ModflowDis(
@@ -556,38 +597,149 @@ def test_unstructured_from_gridspec(example_data_path):
         assert min(grid.botm) == min([xyz[2] for xyz in expected_verts])
 
 
-def test_epsgs():
-    import flopy.export.shapefile_utils as shp
+@requires_pkg("pyproj")
+@pytest.mark.parametrize(
+    "crs,expected_srs",
+    (
+        (None, None),
+        (26916, "EPSG:26916"),
+        ("epsg:5070", "EPSG:5070"),
+        (
+            "+proj=tmerc +lat_0=0 +lon_0=-90 +k=0.9996 +x_0=520000 +y_0=-4480000 +datum=NAD83 +units=m +no_defs ",
+            "EPSG:3070",
+        ),
+        pytest.param(4269, None, marks=pytest.mark.xfail),
+    ),
+)
+def test_grid_crs(
+    minimal_unstructured_grid_info, crs, expected_srs, function_tmpdir
+):
+    import pyproj
 
-    # test setting a geographic (lat/lon) coordinate reference
-    # (also tests shapefile_utils.CRS parsing of geographic crs info)
+    d = minimal_unstructured_grid_info
     delr = np.ones(10)
     delc = np.ones(10)
-    mg = StructuredGrid(delr=delr, delc=delc)
-
-    mg.epsg = 102733
-    assert mg.epsg == 102733, f"mg.epsg is not 102733 ({mg.epsg})"
-
-    t_value = mg.__repr__()
-    if not "proj4_str:epsg:102733" in t_value:
-        raise AssertionError(
-            f"proj4_str:epsg:102733 not in mg.__repr__(): ({t_value})"
-        )
+    sg = StructuredGrid(delr=delr, delc=delc, crs=crs)
+    if crs is not None:
+        assert isinstance(sg.crs, pyproj.CRS)
+        assert sg.crs.srs == expected_srs
+
+    usg = UnstructuredGrid(**d, crs=crs)
+    assert getattr(sg.crs, "srs", None) == expected_srs
+
+    vg = VertexGrid(vertices=d["vertices"], crs=crs)
+    assert getattr(sg.crs, "srs", None) == expected_srs
+
+    # test input of pyproj.CRS object
+    if crs == 26916:
+        sg2 = StructuredGrid(delr=delr, delc=delc, crs=sg.crs)
+
+        if crs is not None:
+            assert isinstance(sg2.crs, pyproj.CRS)
+        assert getattr(sg2.crs, "srs", None) == expected_srs
+
+        # test input of projection file
+        prjfile = function_tmpdir / "grid_crs.prj"
+        with open(prjfile, "w", encoding="utf-8") as dest:
+            write_text = sg.crs.to_wkt()
+            dest.write(write_text)
+
+        sg3 = StructuredGrid(delr=delr, delc=delc, prjfile=prjfile)
+        if crs is not None:
+            assert isinstance(sg3.crs, pyproj.CRS)
+        assert getattr(sg3.crs, "srs", None) == expected_srs
+
+
+@requires_pkg("pyproj")
+@pytest.mark.parametrize(
+    "crs,expected_srs",
+    (
+        (None, None),
+        (26916, "EPSG:26916"),
+        ("epsg:5070", "EPSG:5070"),
+        (
+            "+proj=tmerc +lat_0=0 +lon_0=-90 +k=0.9996 +x_0=520000 +y_0=-4480000 +datum=NAD83 +units=m +no_defs ",
+            "EPSG:3070",
+        ),
+        ("ESRI:102733", "ESRI:102733"),
+        pytest.param(4269, None, marks=pytest.mark.xfail),
+    ),
+)
+def test_grid_set_crs(crs, expected_srs, function_tmpdir):
+    import pyproj
 
-    mg.epsg = 4326  # WGS 84
-    crs = shp.CRS(epsg=4326)
-    if crs.grid_mapping_attribs is not None:
-        assert crs.crs["proj"] == "longlat"
-        t_value = crs.grid_mapping_attribs["grid_mapping_name"]
-        assert (
-            t_value == "latitude_longitude"
-        ), f"grid_mapping_name is not latitude_longitude: {t_value}"
-
-    t_value = mg.__repr__()
-    if not "proj4_str:epsg:4326" in t_value:
-        raise AssertionError(
-            f"proj4_str:epsg:4326 not in sr.__repr__(): ({t_value})"
-        )
+    delr = np.ones(10)
+    delc = np.ones(10)
+    sg = StructuredGrid(delr=delr, delc=delc)
+    sg.crs = crs
+    if crs is not None:
+        assert isinstance(sg.crs, pyproj.CRS)
+    assert getattr(sg.crs, "srs", None) == expected_srs
+
+    # test setting the crs via set_coord_info
+    sg.set_coord_info()
+    if crs is not None:
+        assert isinstance(sg.crs, pyproj.CRS)
+    assert getattr(sg.crs, "srs", None) == expected_srs
+    sg.set_coord_info(crs=crs)
+    if crs is not None:
+        assert isinstance(sg.crs, pyproj.CRS)
+    assert getattr(sg.crs, "srs", None) == expected_srs
+    sg.set_coord_info(crs=26915, merge_coord_info=False)
+    assert getattr(sg.crs, "srs", None) == "EPSG:26915"
+    # reset back to test case crs
+    sg = StructuredGrid(delr=delr, delc=delc, crs=crs)
+
+    # test input of projection file
+    if crs is not None:
+        prjfile = function_tmpdir / "grid_crs.prj"
+        with open(prjfile, "w", encoding="utf-8") as dest:
+            write_text = sg.crs.to_wkt()
+            dest.write(write_text)
+        sg = StructuredGrid(delr=delr, delc=delc)
+        sg.prjfile = prjfile
+        if crs is not None:
+            assert isinstance(sg.crs, pyproj.CRS)
+        assert getattr(sg.crs, "srs", None) == expected_srs
+        assert sg.prjfile == prjfile
+        sg.set_coord_info(prjfile=prjfile)
+        if crs is not None:
+            assert isinstance(sg.crs, pyproj.CRS)
+            assert getattr(sg.crs, "srs", None) == expected_srs
+        assert sg.prjfile == prjfile
+
+    # test setting another crs
+    sg.crs = 26915
+    assert sg.crs == get_authority_crs(26915)
+
+    if (
+        version.parse(flopy.__version__) < version.parse("3.4")
+        and crs is not None
+    ):
+        pyproj_crs = get_authority_crs(crs)
+        epsg = pyproj_crs.to_epsg()
+        if epsg is not None:
+            sg = StructuredGrid(delr=delr, delc=delc, crs=crs)
+            sg.epsg = epsg
+            if crs is not None:
+                assert isinstance(sg.crs, pyproj.CRS)
+            assert getattr(sg.crs, "srs", None) == expected_srs
+            assert sg.epsg == epsg
+
+        sg = StructuredGrid(delr=delr, delc=delc)
+        sg.proj4 = pyproj_crs.to_proj4()
+        if crs is not None:
+            assert isinstance(sg.crs, pyproj.CRS)
+        assert getattr(sg.crs, "srs", None) == expected_srs
+        assert sg.proj4 == pyproj_crs.to_proj4()
+
+        if crs is not None:
+            sg = StructuredGrid(delr=delr, delc=delc)
+            sg.prj = prjfile
+            if crs is not None:
+                assert isinstance(sg.crs, pyproj.CRS)
+            assert getattr(sg.crs, "srs", None) == expected_srs
+            assert sg.prj == prjfile
 
 
 def test_tocvfd1():
@@ -682,32 +834,20 @@ def test_unstructured_grid_dimensions():
     assert not g.grid_varies_by_layer
 
 
-def test_unstructured_minimal_grid_ctor():
+def test_unstructured_minimal_grid_ctor(minimal_unstructured_grid_info):
     # pass in simple 2 cell minimal grid to make grid valid
-    vertices = [
-        [0, 0.0, 1.0],
-        [1, 1.0, 1.0],
-        [2, 2.0, 1.0],
-        [3, 0.0, 0.0],
-        [4, 1.0, 0.0],
-        [5, 2.0, 0.0],
-    ]
-    iverts = [[0, 1, 4, 3], [1, 2, 5, 4]]
-    xcenters = [0.5, 1.5]
-    ycenters = [0.5, 0.5]
-    g = UnstructuredGrid(
-        vertices=vertices, iverts=iverts, xcenters=xcenters, ycenters=ycenters
-    )
+    d = minimal_unstructured_grid_info
+    g = UnstructuredGrid(**d)
     assert np.allclose(g.ncpl, np.array([2], dtype=int))
     assert g.nlay == 1
     assert g.nnodes == 2
     assert g.is_valid
     assert not g.is_complete
     assert not g.grid_varies_by_layer
-    assert g._vertices == vertices
-    assert g._iverts == iverts
-    assert g._xc == xcenters
-    assert g._yc == ycenters
+    assert g._vertices == d["vertices"]
+    assert g._iverts == d["iverts"]
+    assert g._xc == d["xcenters"]
+    assert g._yc == d["ycenters"]
     grid_lines = [
         [(0.0, 0), (0.0, 1.0)],
         [(0.0, 1), (1.0, 1.0)],
@@ -728,33 +868,17 @@ def test_unstructured_minimal_grid_ctor():
     assert zv is None
 
 
-def test_unstructured_complete_grid_ctor():
+def test_unstructured_complete_grid_ctor(minimal_unstructured_grid_info):
     # pass in simple 2 cell complete grid to make grid valid, and put each
     # cell in a different layer
-    vertices = [
-        [0, 0.0, 1.0],
-        [1, 1.0, 1.0],
-        [2, 2.0, 1.0],
-        [3, 0.0, 0.0],
-        [4, 1.0, 0.0],
-        [5, 2.0, 0.0],
-    ]
-    iverts = [[0, 1, 4, 3], [1, 2, 5, 4]]
-    xcenters = [0.5, 1.5]
-    ycenters = [0.5, 0.5]
+    d = minimal_unstructured_grid_info
     ncpl = [1, 1]
     top = [1, 0]
     top = np.array(top)
     botm = [0, -1]
     botm = np.array(botm)
     g = UnstructuredGrid(
-        vertices=vertices,
-        iverts=iverts,
-        xcenters=xcenters,
-        ycenters=ycenters,
-        ncpl=ncpl,
-        top=top,
-        botm=botm,
+        ncpl=ncpl, top=top, botm=botm, **minimal_unstructured_grid_info
     )
     assert np.allclose(g.ncpl, np.array([1, 1], dtype=int))
     assert g.nlay == 2
@@ -762,10 +886,10 @@ def test_unstructured_complete_grid_ctor():
     assert g.is_valid
     assert not g.is_complete
     assert g.grid_varies_by_layer
-    assert g._vertices == vertices
-    assert g._iverts == iverts
-    assert g._xc == xcenters
-    assert g._yc == ycenters
+    assert g._vertices == d["vertices"]
+    assert g._iverts == d["iverts"]
+    assert g._xc == d["xcenters"]
+    assert g._yc == d["ycenters"]
     grid_lines = {
         0: [
             [(0.0, 0.0), (0.0, 1.0)],
diff --git a/autotest/test_modflow.py b/autotest/test_modflow.py
index d0bfec78b..514fbb3d6 100644
--- a/autotest/test_modflow.py
+++ b/autotest/test_modflow.py
@@ -110,7 +110,7 @@ def test_mt_modelgrid(function_tmpdir):
     ml = Modflow(
         modelname="test",
         xll=500.0,
-        proj4_str="epsg:2193",
+        crs="epsg:2193",
         rotation=12.5,
         start_datetime="1/1/2016",
     )
@@ -131,7 +131,7 @@ def test_mt_modelgrid(function_tmpdir):
 
     assert mt.modelgrid.xoffset == ml.modelgrid.xoffset
     assert mt.modelgrid.yoffset == ml.modelgrid.yoffset
-    assert mt.modelgrid.epsg == ml.modelgrid.epsg
+    assert mt.modelgrid.crs == ml.modelgrid.crs
     assert mt.modelgrid.angrot == ml.modelgrid.angrot
     assert np.array_equal(mt.modelgrid.idomain, ml.modelgrid.idomain)
 
@@ -160,7 +160,7 @@ def test_mt_modelgrid(function_tmpdir):
     assert (
         swt.modelgrid.yoffset == mt.modelgrid.yoffset == ml.modelgrid.yoffset
     )
-    assert mt.modelgrid.epsg == ml.modelgrid.epsg == swt.modelgrid.epsg
+    assert mt.modelgrid.crs == ml.modelgrid.crs == swt.modelgrid.crs
     assert mt.modelgrid.angrot == ml.modelgrid.angrot == swt.modelgrid.angrot
     assert np.array_equal(mt.modelgrid.idomain, ml.modelgrid.idomain)
     assert np.array_equal(swt.modelgrid.idomain, ml.modelgrid.idomain)
@@ -194,7 +194,7 @@ def test_mt_modelgrid(function_tmpdir):
     assert (
         mt.modelgrid.yoffset == ml.modelgrid.yoffset == swt.modelgrid.yoffset
     )
-    assert mt.modelgrid.epsg == ml.modelgrid.epsg == swt.modelgrid.epsg
+    assert mt.modelgrid.crs == ml.modelgrid.crs == swt.modelgrid.crs
     assert mt.modelgrid.angrot == ml.modelgrid.angrot == swt.modelgrid.angrot
     assert np.array_equal(mt.modelgrid.idomain, ml.modelgrid.idomain)
     assert np.array_equal(swt.modelgrid.idomain, ml.modelgrid.idomain)
@@ -251,7 +251,7 @@ def test_sr(function_tmpdir):
         model_ws=ws,
         xll=12345,
         yll=12345,
-        proj4_str="test test test",
+        crs=26916,
     )
     ModflowDis(m, 10, 10, 10)
     m.write_input()
@@ -261,7 +261,7 @@ def test_sr(function_tmpdir):
         raise AssertionError()
     if extents[3] != 12355:
         raise AssertionError()
-    if mm.modelgrid.proj4 != "test test test":
+    if mm.modelgrid.crs.srs != "EPSG:26916":
         raise AssertionError()
 
     mm.dis.top = 5000
@@ -511,7 +511,7 @@ def test_read_usgs_model_reference(function_tmpdir, model_reference_path):
     )
     m.write_input()
 
-    # test reading of SR information from usgs.model.reference
+    # test reading of proj4 string from usgs.model.reference
     m2 = Modflow.load("junk.nam", model_ws=ws)
     from flopy.discretization import StructuredGrid
 
@@ -527,21 +527,23 @@ def test_read_usgs_model_reference(function_tmpdir, model_reference_path):
     assert m2.modelgrid.xoffset == mg.xoffset
     assert m2.modelgrid.yoffset == mg.yoffset
     assert m2.modelgrid.angrot == mg.angrot
-    assert m2.modelgrid.epsg == mg.epsg
+    assert m2.modelgrid.crs == mg.crs
 
-    # test reading non-default units from usgs.model.reference
+    # test reading epsg code from usgs.model.reference
     shutil.copy(mrf_path, f"{mrf_path}_copy")
     with open(f"{mrf_path}_copy") as src:
         with open(mrf_path, "w") as dst:
             for line in src:
                 if "epsg" in line:
-                    line = line.replace("102733", "4326")
+                    line = "epsg 26916\n"
+                if "proj4" in line:
+                    line = "# proj4\n"
                 dst.write(line)
 
     m2 = Modflow.load("junk.nam", model_ws=ws)
     m2.modelgrid.read_usgs_model_reference_file(mrf_path)
 
-    assert m2.modelgrid.epsg == 4326
+    assert m2.modelgrid.crs.to_epsg() == 26916
     # have to delete this, otherwise it will mess up other tests
     to_del = glob.glob(f"{mrf_path}*")
     for f in to_del:
diff --git a/autotest/test_shapefile_utils.py b/autotest/test_shapefile_utils.py
new file mode 100644
index 000000000..4f227b3c7
--- /dev/null
+++ b/autotest/test_shapefile_utils.py
@@ -0,0 +1,47 @@
+"""Test functions in flopy/export/shapefile_utils.py
+"""
+import numpy as np
+from modflow_devtools.markers import requires_pkg
+
+from flopy.discretization import StructuredGrid, UnstructuredGrid, VertexGrid
+from flopy.export.shapefile_utils import shp2recarray
+from flopy.utils.crs import get_shapefile_crs
+
+from .test_grid import minimal_unstructured_grid_info, minimal_vertex_grid_info
+
+
+@requires_pkg("pyproj")
+def test_write_grid_shapefile(
+    minimal_unstructured_grid_info, minimal_vertex_grid_info, function_tmpdir
+):
+    import pyproj
+
+    d = minimal_unstructured_grid_info
+    delr = np.ones(10)
+    delc = np.ones(10)
+    crs = 26916
+    shapefilename = function_tmpdir / "grid.shp"
+    sg = StructuredGrid(delr=delr, delc=delc, nlay=1, crs=crs)
+    sg.write_shapefile(shapefilename)
+    data = shp2recarray(shapefilename)
+    # check that row and column appear as integers in recarray
+    assert np.issubdtype(data.dtype["row"], np.integer)
+    assert np.issubdtype(data.dtype["column"], np.integer)
+    assert len(data) == sg.nnodes
+    written_crs = get_shapefile_crs(shapefilename)
+    assert written_crs.to_epsg() == crs
+
+    usg = UnstructuredGrid(**d, crs=crs)
+    usg.write_shapefile(shapefilename)
+    data = shp2recarray(shapefilename)
+    assert len(data) == usg.nnodes
+    written_crs = get_shapefile_crs(shapefilename)
+    assert written_crs.to_epsg() == crs
+
+    d = minimal_vertex_grid_info
+    vg = VertexGrid(**d, crs=crs)
+    vg.write_shapefile(shapefilename)
+    data = shp2recarray(shapefilename)
+    assert len(data) == vg.nnodes
+    written_crs = get_shapefile_crs(shapefilename)
+    assert written_crs.to_epsg() == crs
diff --git a/examples/Notebooks/flopy3_demo_of_modelgrid_classes.ipynb b/examples/Notebooks/flopy3_demo_of_modelgrid_classes.ipynb
index af53bd473..823197860 100644
--- a/examples/Notebooks/flopy3_demo_of_modelgrid_classes.ipynb
+++ b/examples/Notebooks/flopy3_demo_of_modelgrid_classes.ipynb
@@ -45,6 +45,7 @@
    "source": [
     "import sys\n",
     "import os\n",
+    "from pathlib import Path\n",
     "import shutil\n",
     "from tempfile import TemporaryDirectory\n",
     "import numpy as np\n",
@@ -98,18 +99,30 @@
      "shell.execute_reply": "2023-04-06T17:02:01.684223Z"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PosixPath('/var/folders/4x/bmhyjcdn3mgfdvkk_jgz6bsrlnfk3t/T/tmpz_pr__cn')"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# set paths to each of our model types for this example notebook\n",
-    "spth = os.path.join(\"..\", \"data\", \"freyberg_multilayer_transient\")\n",
-    "spth6 = os.path.join(\"..\", \"data\", \"mf6-freyberg\")\n",
-    "vpth = os.path.join(\"..\", \"data\")\n",
-    "upth = os.path.join(\"..\", \"data\")\n",
-    "u_data_ws = os.path.join(\"..\", \"data\", \"unstructured\")\n",
+    "spth = \"../data/freyberg_multilayer_transient\"\n",
+    "spth6 = \"../data/mf6-freyberg\"\n",
+    "vpth = \"../data\"\n",
+    "upth = \"../data\"\n",
+    "u_data_ws = \"../data/unstructured\"\n",
     "\n",
     "# temporary workspace\n",
     "temp_dir = TemporaryDirectory()\n",
-    "gridgen_ws = temp_dir.name"
+    "gridgen_ws = Path(temp_dir.name)\n",
+    "gridgen_ws"
    ]
   },
   {
@@ -169,8 +182,7 @@
     "`xll` : geographic location of lower left model corner x-coordinate  \n",
     "`yll` : geographic location of lower left model corner y-coordinate  \n",
     "`rotation` : modelgrid rotation in degrees  \n",
-    "`epsg` : epsg code of modelgrid coordinate system  \n",
-    "`proj4_str` : proj4 projection information  \n",
+    "`crs` : returns the coordinate reference system that the model grid is referenced to\n",
     "\n",
     "can be automatcally read in and applied to the modelgrid. FloPy will also write this information out when the user saves their model to file. \n",
     "\n",
@@ -193,7 +205,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "xll:622241.1904510253; yll:3343617.741737109; rotation:15.0; proj4_str:+proj=utm +zone=14 +ellps=WGS84 +datum=WGS84 +units=m +no_defs; units:meters; lenuni:2\n"
+      "xll:622241.1904510253; yll:3343617.741737109; rotation:15.0; crs:EPSG:32614; units:meters; lenuni:2\n"
      ]
     }
    ],
@@ -264,8 +276,7 @@
     "   - `xoffset` : returns the x-coordinate for the modelgrid's lower left corner  \n",
     "   - `yoffset` : returns the y-coordinate for the modelgrid's lower left corner  \n",
     "   - `angrot` : returns the rotation of the modelgrid in degrees  \n",
-    "   - `epsg` : returns the modelgrid epsg code  \n",
-    "   - `proj4` : returns the modelgrid proj4_str information  "
+    "   - `crs` : returns the coordinate reference system that the model grid is referenced to\n"
    ]
   },
   {
@@ -287,8 +298,7 @@
       "xoff: 622241.1904510253\n",
       "yoff: 3343617.741737109\n",
       "angrot: 15.0\n",
-      "epsg: None\n",
-      "proj4: +proj=utm +zone=14 +ellps=WGS84 +datum=WGS84 +units=m +no_defs\n"
+      "crs: EPSG:32614\n"
      ]
     }
    ],
@@ -296,12 +306,11 @@
     "xoff = modelgrid.xoffset\n",
     "yoff = modelgrid.yoffset\n",
     "angrot = modelgrid.angrot\n",
-    "epsg = modelgrid.epsg\n",
-    "proj4 = modelgrid.proj4\n",
+    "crs = modelgrid.crs\n",
     "\n",
     "print(\n",
-    "    \"xoff: {}\\nyoff: {}\\nangrot: {}\\nepsg: {}\\nproj4: {}\".format(\n",
-    "        xoff, yoff, angrot, epsg, proj4\n",
+    "    \"xoff: {}\\nyoff: {}\\nangrot: {}\\ncrs: {}\".format(\n",
+    "        xoff, yoff, angrot, crs\n",
     "    )\n",
     ")"
    ]
@@ -333,7 +342,7 @@
      "text": [
       "Before: xll:0.0; yll:0.0; rotation:0.0; units:meters; lenuni:2\n",
       "\n",
-      "After: xll:622241.1904510253; yll:3343617.741737109; rotation:15.0; proj4_str:+proj=utm +zone=14 +ellps=WGS84 +datum=WGS84 +units=m +no_defs; units:meters; lenuni:2\n"
+      "After: xll:622241.1904510253; yll:3343617.741737109; rotation:15.0; crs:EPSG:32614; units:meters; lenuni:2\n"
      ]
     }
    ],
@@ -343,7 +352,7 @@
     "\n",
     "# set reference infromation\n",
     "modelgrid1.set_coord_info(\n",
-    "    xoff=xoff, yoff=yoff, angrot=angrot, epsg=epsg, proj4=proj4\n",
+    "    xoff=xoff, yoff=yoff, angrot=angrot, crs=crs\n",
     ")\n",
     "\n",
     "print(\"After: {}\".format(modelgrid1))"
@@ -372,7 +381,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "xll:100; yll:1000; rotation:55; proj4_str:+proj=utm +zone=14 +ellps=WGS84 +datum=WGS84 +units=m +no_defs; units:meters; lenuni:2\n"
+      "xll:100; yll:1000; rotation:55; crs:EPSG:32614; units:meters; lenuni:2\n"
      ]
     }
    ],
@@ -489,9 +498,11 @@
     "   - `botm` : Array of layer Botm elevations\n",
     "   - `idomain` : An ibound or idomain array that specifies active and inactive cells\n",
     "   - `lenuni` : Model length unit integer\n",
-    "   - `epsg` : epsg code of model coordinate system\n",
-    "   - `proj4` : proj4 str describining model coordinate system\n",
-    "   - `prj` : path to \".prj\" projection file that describes the model coordinate system\n",
+    "   - `crs` : Coordinate reference system (CRS) for the model grid\n",
+    "        (must be projected; geographic CRS are not supported). The value can be anything accepted by\n",
+    "        [pyproj.CRS.from_user_input()](https://pyproj4.github.io/pyproj/stable/api/crs/crs.html#pyproj.crs.CRS.from_user_input)\n",
+    "        such as an authority string (eg \"EPSG:26916\") or a well-known text (WKT) string.\n",
+    "   - `prjfile` : Alternatively, supply a path to an ESRI-style projection (``*.prj``) file containing WKT that describes the model coordinate system.\n",
     "   - `xoff` : x-coordinate of the lower-left corner of the modelgrid\n",
     "   - `yoff` : y-coordinate of the lower-left corner of the modelgrid\n",
     "   - `angrot` : model grid rotation\n",
@@ -519,7 +530,7 @@
     {
      "data": {
       "text/plain": [
-       "xll:3579; yll:10000; rotation:0; units:undefined; lenuni:0"
+       "xll:3579; yll:10000; rotation:0; crs:EPSG:26916; units:undefined; lenuni:0"
       ]
      },
      "execution_count": 12,
@@ -565,6 +576,7 @@
     "    xoff=xll,\n",
     "    yoff=yll,\n",
     "    angrot=rotation,\n",
+    "    crs=26916\n",
     ")\n",
     "modelgrid"
    ]
@@ -760,9 +772,11 @@
     "   - `botm` : Array of layer Botm elevations\n",
     "   - `idomain` : An ibound or idomain array that specifies active and inactive cells\n",
     "   - `lenuni` : Model length unit integer\n",
-    "   - `epsg` : epsg code of model coordinate system\n",
-    "   - `proj4` : proj4 str describining model coordinate system\n",
-    "   - `prj` : path to \".prj\" projection file that describes the model coordinate system\n",
+    "   - `crs` : Coordinate reference system (CRS) for the model grid\n",
+    "        (must be projected; geographic CRS are not supported). The value can be anything accepted by\n",
+    "        [pyproj.CRS.from_user_input()](https://pyproj4.github.io/pyproj/stable/api/crs/crs.html#pyproj.crs.CRS.from_user_input)\n",
+    "        such as an authority string (eg \"EPSG:26916\") or a well-known text (WKT) string.\n",
+    "   - `prjfile` : Alternatively, supply a path to an ESRI-style projection (``*.prj``) file containing WKT that describes the model coordinate system.\n",
     "   - `xoff` : x-coordinate of the lower-left corner of the modelgrid\n",
     "   - `yoff` : y-coordinate of the lower-left corner of the modelgrid\n",
     "   - `angrot` : model grid rotation\n",
@@ -972,9 +986,11 @@
     "   - `idomain` : An ibound or idomain array that specifies active and inactive cells\n",
     "   - `lenuni` : Model length unit integer\n",
     "   - `ncpl` : one dimensional array of number of cells per model layer\n",
-    "   - `epsg` : epsg code of model coordinate system\n",
-    "   - `proj4` : proj4 str describining model coordinate system\n",
-    "   - `prj` : path to \".prj\" projection file that describes the model coordinate system\n",
+    "   - `crs` : Coordinate reference system (CRS) for the model grid\n",
+    "        (must be projected; geographic CRS are not supported). The value can be anything accepted by\n",
+    "        [pyproj.CRS.from_user_input()](https://pyproj4.github.io/pyproj/stable/api/crs/crs.html#pyproj.crs.CRS.from_user_input)\n",
+    "        such as an authority string (eg \"EPSG:26916\") or a well-known text (WKT) string.\n",
+    "   - `prjfile` : Alternatively, supply a path to an ESRI-style projection (``*.prj``) file containing WKT that describes the model coordinate system.\n",
     "   - `xoff` : x-coordinate of the lower-left corner of the modelgrid\n",
     "   - `yoff` : y-coordinate of the lower-left corner of the modelgrid\n",
     "   - `angrot` : model grid rotation   \n",
@@ -1161,7 +1177,7 @@
     "    xoff=622241.1904510253,\n",
     "    yoff=3343617.741737109,\n",
     "    angrot=15.0,\n",
-    "    proj4=\"+proj=utm +zone=14 +ellps=WGS84 +datum=WGS84 +units=m +no_defs\",\n",
+    "    crs=\"epsg:32614\",\n",
     ")"
    ]
   },
@@ -1237,9 +1253,7 @@
     "   - `yoffset` : returns the current yoffset of the modelgrid\n",
     "   - `angrot` : returns the angle of rotation of the modelgrid in degrees\n",
     "   - `angrot_radians` : returns the angle of rotation of the modelgrid in radians\n",
-    "   - `epsg` : returns the modelgrid epsg code if it is set\n",
-    "   - `proj4` : returns the modelgrid proj4 string if it is set\n",
-    "   - `prj` : returns the path to the modelgrid projection file if it is set"
+    "   - `crs` : returns a [pyproj.CRS](https://pyproj4.github.io/pyproj/stable/api/crs/crs.html) object instance describing the coordinate reference system for the model grid."
    ]
   },
   {
@@ -1262,7 +1276,7 @@
       "\n",
       "rotation (deg): 15.0, (rad): 0.2618\n",
       "\n",
-      "proj4_str: +proj=utm +zone=14 +ellps=WGS84 +datum=WGS84 +units=m +no_defs\n"
+      "crs: EPSG:32614\n"
      ]
     }
    ],
@@ -1276,7 +1290,7 @@
     "        modelgrid.angrot, modelgrid.angrot_radians\n",
     "    )\n",
     ")\n",
-    "print(\"proj4_str: {}\".format(modelgrid.proj4))"
+    "print(\"crs: {}\".format(modelgrid.crs))"
    ]
   },
   {
@@ -1465,8 +1479,11 @@
     "   - `xoff` : lower-left corner of modelgrid x-coordinate location\n",
     "   - `yoff` : lower-left corner of modelgrid y-coordinate location\n",
     "   - `angrot` : rotation of model grid in degrees\n",
-    "   - `epsg` : epsg code for model grid projection\n",
-    "   - `proj4` : proj4 string describing the model grid projection\n",
+    "   - `crs` : Coordinate reference system (CRS) for the model grid\n",
+    "        (must be projected; geographic CRS are not supported). The value can be anything accepted by\n",
+    "        [pyproj.CRS.from_user_input()](https://pyproj4.github.io/pyproj/stable/api/crs/crs.html#pyproj.crs.CRS.from_user_input)\n",
+    "        such as an authority string (eg \"EPSG:26916\") or a well-known text (WKT) string.\n",
+    "   - `prjfile` : Alternatively, supply a path to an ESRI-style projection (``*.prj``) file containing WKT that describes the model coordinate system.\n",
     "   - `merge_coord_info` : boolean flag to either merge changes with the existing coordinate info or clear existing coordinate info before applying changes."
    ]
   },
@@ -1486,7 +1503,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "xll:50000; yll:3343617.741737109; rotation:15.0; proj4_str:+proj=utm +zone=14 +ellps=WGS84 +datum=WGS84 +units=m +no_defs; units:meters; lenuni:2\n",
+      "xll:50000; yll:3343617.741737109; rotation:15.0; crs:EPSG:32614; units:meters; lenuni:2\n",
       "xll:0.0; yll:0.0; rotation:45; units:meters; lenuni:2\n"
      ]
     },
@@ -1678,6 +1695,7 @@
     "    xoff=622241.1904510253,\n",
     "    yoff=3343617.741737109,\n",
     "    angrot=15.0,\n",
+    "    crs=32614\n",
     ")\n",
     "\n",
     "# generate some synthetic pumping data\n",
@@ -1739,9 +1757,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "WARNING: MFFileMgt's set_sim_path has been deprecated.  Please use MFSimulation's set_sim_path in the future.\n",
+      "FloPy is using the following executable to run the model: ../../../../../../Users/aleaf/Documents/software/modflow_exes/mf6\n",
       "                                   MODFLOW 6\n",
       "                U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL\n",
-      "                        VERSION 6.4.1 Release 12/09/2022\n",
+      "                            VERSION 6.3.0 03/08/2022\n",
       "\n",
       "   MODFLOW 6 compiled Dec 10 2022 05:57:01 with Intel(R) Fortran Intel(R) 64\n",
       "   Compiler Classic for applications running on Intel(R) 64, Version 2021.7.0\n",
@@ -1787,14 +1807,9 @@
    ],
    "source": [
     "# write inputs and run the mf6 simulation with the new wells we added above\n",
-    "sim.set_sim_path(gridgen_ws)\n",
+    "sim.simulation_data.mfpath.set_sim_path(gridgen_ws)\n",
     "sim.write_simulation()\n",
-    "success, buff = sim.run_simulation(silent=True, report=True)\n",
-    "if success:\n",
-    "    for line in buff:\n",
-    "        print(line)\n",
-    "else:\n",
-    "    raise ValueError(\"Failed to run.\")\n",
+    "sim.run_simulation(silent=False)\n",
     "\n",
     "# load the binary head file from the model\n",
     "ml = sim.freyberg\n",
@@ -1834,16 +1849,45 @@
    "source": [
     "#### `write_shapefile()` \n",
     "\n",
-    "Method to write a shapefile of the grid with just the cellid attributes. Input parameters include:\n",
-    "\n",
-    "   - `filename` : shapefile name\n",
-    "   - `epsg` : optional epsg code of the coordinate system projection\n",
-    "   - `prj` : optional, input projection file to be used to define the coordinate system projection"
+    "Method to write a shapefile of the grid with just the cellid attributes. If the model grid is already registered to a coordinate reference system, only a name for the shapefile is needed as input. Alternatively, ``crs`` and ``prjfile`` arguments can be supplied (same as for the model grid), and a projection (``*.prj``) file for that reference will be written. If no coordinate reference is supplied, the shapefile will be written without a projection file."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Derived Projected CRS: EPSG:32614>\n",
+       "Name: WGS 84 / UTM zone 14N\n",
+       "Axis Info [cartesian]:\n",
+       "- E[east]: Easting (metre)\n",
+       "- N[north]: Northing (metre)\n",
+       "Area of Use:\n",
+       "- name: Between 102°W and 96°W, northern hemisphere between equator and 84°N, onshore and offshore. Canada - Manitoba; Nunavut; Saskatchewan. Mexico. United States (USA).\n",
+       "- bounds: (-102.0, 0.0, -96.0, 84.0)\n",
+       "Coordinate Operation:\n",
+       "- name: UTM zone 14N\n",
+       "- method: Transverse Mercator\n",
+       "Datum: World Geodetic System 1984 ensemble\n",
+       "- Ellipsoid: WGS 84\n",
+       "- Prime Meridian: Greenwich"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ml.modelgrid.crs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-04-06T17:02:08.731255Z",
@@ -1855,15 +1899,33 @@
    "outputs": [],
    "source": [
     "# write a shapefile\n",
-    "shp_name = os.path.join(gridgen_ws, \"freyberg-6_grid.shp\")\n",
-    "epsg = \"32614\"\n",
+    "shp_name = gridgen_ws / \"freyberg-6_grid.shp\"\n",
     "\n",
-    "ml.modelgrid.write_shapefile(shp_name, epsg)"
+    "ml.modelgrid.write_shapefile(shp_name, #crs=32614\n",
+    "                            )"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PROJCRS[\"WGS 84 / UTM zone 14N\",BASEGEOGCRS[\"WGS 84\",ENSEMBLE[\"World Geodetic System 1984 ensemble\",MEMBER[\"World Geodetic System 1984 (Transit)\"],MEMBER[\"World Geodetic System 1984 (G730)\"],MEMBER[\"World Geodetic System 1984 (G873)\"],MEMBER[\"World Geodetic System 1984 (G1150)\"],MEMBER[\"World Geodetic System 1984 (G1674)\"],MEMBER[\"World Geodetic System 1984 (G1762)\"],MEMBER[\"World Geodetic System 1984 (G2139)\"],ELLIPSOID[\"WGS 84\",6378137,298.257223563,LENGTHUNIT[\"metre\",1]],ENSEMBLEACCURACY[2.0]],PRIMEM[\"Greenwich\",0,ANGLEUNIT[\"degree\",0.0174532925199433]],ID[\"EPSG\",4326]],CONVERSION[\"UTM zone 14N\",METHOD[\"Transverse Mercator\",ID[\"EPSG\",9807]],PARAMETER[\"Latitude of natural origin\",0,ANGLEUNIT[\"degree\",0.0174532925199433],ID[\"EPSG\",8801]],PARAMETER[\"Longitude of natural origin\",-99,ANGLEUNIT[\"degree\",0.0174532925199433],ID[\"EPSG\",8802]],PARAMETER[\"Scale factor at natural origin\",0.9996,SCALEUNIT[\"unity\",1],ID[\"EPSG\",8805]],PARAMETER[\"False easting\",500000,LENGTHUNIT[\"metre\",1],ID[\"EPSG\",8806]],PARAMETER[\"False northing\",0,LENGTHUNIT[\"metre\",1],ID[\"EPSG\",8807]]],CS[Cartesian,2],AXIS[\"(E)\",east,ORDER[1],LENGTHUNIT[\"metre\",1]],AXIS[\"(N)\",north,ORDER[2],LENGTHUNIT[\"metre\",1]],USAGE[SCOPE[\"Engineering survey, topographic mapping.\"],AREA[\"Between 102°W and 96°W, northern hemisphere between equator and 84°N, onshore and offshore. Canada - Manitoba; Nunavut; Saskatchewan. Mexico. United States (USA).\"],BBOX[0,-102,84,-96]],ID[\"EPSG\",32614]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(shp_name.with_suffix(\".prj\")) as src:\n",
+    "    print(src.read())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-04-06T17:02:09.174947Z",
@@ -1884,9 +1946,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "flopy",
    "language": "python",
-   "name": "python3"
+   "name": "flopy"
   },
   "language_info": {
    "codemirror_mode": {
diff --git a/examples/Notebooks/flopy3_export.ipynb b/examples/Notebooks/flopy3_export.ipynb
index a271847f5..f5cb71524 100644
--- a/examples/Notebooks/flopy3_export.ipynb
+++ b/examples/Notebooks/flopy3_export.ipynb
@@ -14,10 +14,10 @@
    "execution_count": 1,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:38.245244Z",
-     "iopub.status.busy": "2023-02-22T02:46:38.244803Z",
-     "iopub.status.idle": "2023-02-22T02:46:39.114024Z",
-     "shell.execute_reply": "2023-02-22T02:46:39.112951Z"
+     "iopub.execute_input": "2022-12-15T13:09:52.596232Z",
+     "iopub.status.busy": "2022-12-15T13:09:52.595883Z",
+     "iopub.status.idle": "2022-12-15T13:09:53.936555Z",
+     "shell.execute_reply": "2022-12-15T13:09:53.931847Z"
     }
    },
    "outputs": [
@@ -25,7 +25,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "3.10.6 (main, Nov 14 2022, 16:10:14) [GCC 11.3.0]\n",
+      "3.11.0 | packaged by conda-forge | (main, Jan 15 2023, 05:44:48) [Clang 14.0.6 ]\n",
       "flopy version: 3.3.7\n"
      ]
     }
@@ -60,10 +60,10 @@
    "execution_count": 2,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:39.162021Z",
-     "iopub.status.busy": "2023-02-22T02:46:39.161288Z",
-     "iopub.status.idle": "2023-02-22T02:46:39.811531Z",
-     "shell.execute_reply": "2023-02-22T02:46:39.810851Z"
+     "iopub.execute_input": "2022-12-15T13:09:53.993644Z",
+     "iopub.status.busy": "2022-12-15T13:09:53.992762Z",
+     "iopub.status.idle": "2022-12-15T13:09:54.960099Z",
+     "shell.execute_reply": "2022-12-15T13:09:54.959132Z"
     }
    },
    "outputs": [],
@@ -85,17 +85,17 @@
    "execution_count": 3,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:39.815407Z",
-     "iopub.status.busy": "2023-02-22T02:46:39.815111Z",
-     "iopub.status.idle": "2023-02-22T02:46:39.822437Z",
-     "shell.execute_reply": "2023-02-22T02:46:39.821733Z"
+     "iopub.execute_input": "2022-12-15T13:09:54.964270Z",
+     "iopub.status.busy": "2022-12-15T13:09:54.963842Z",
+     "iopub.status.idle": "2022-12-15T13:09:54.982100Z",
+     "shell.execute_reply": "2022-12-15T13:09:54.981041Z"
     }
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "xll:622241.1904510253; yll:3343617.741737109; rotation:15.0; proj4_str:+proj=utm +zone=14 +ellps=WGS84 +datum=WGS84 +units=m +no_defs; units:meters; lenuni:2"
+       "xll:622241.1904510253; yll:3343617.741737109; rotation:15.0; crs:EPSG:32614; units:meters; lenuni:2"
       ]
      },
      "execution_count": 3,
@@ -112,10 +112,10 @@
    "execution_count": 4,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:39.825291Z",
-     "iopub.status.busy": "2023-02-22T02:46:39.824903Z",
-     "iopub.status.idle": "2023-02-22T02:46:39.829878Z",
-     "shell.execute_reply": "2023-02-22T02:46:39.829221Z"
+     "iopub.execute_input": "2022-12-15T13:09:54.987642Z",
+     "iopub.status.busy": "2022-12-15T13:09:54.985964Z",
+     "iopub.status.idle": "2022-12-15T13:09:54.993928Z",
+     "shell.execute_reply": "2022-12-15T13:09:54.992930Z"
     }
    },
    "outputs": [
@@ -146,17 +146,16 @@
    "execution_count": 5,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:39.832641Z",
-     "iopub.status.busy": "2023-02-22T02:46:39.832370Z",
-     "iopub.status.idle": "2023-02-22T02:46:39.836346Z",
-     "shell.execute_reply": "2023-02-22T02:46:39.835575Z"
+     "iopub.execute_input": "2022-12-15T13:09:54.998159Z",
+     "iopub.status.busy": "2022-12-15T13:09:54.997632Z",
+     "iopub.status.idle": "2022-12-15T13:09:55.002333Z",
+     "shell.execute_reply": "2022-12-15T13:09:55.001413Z"
     }
    },
    "outputs": [],
    "source": [
-    "proj4_str = \"+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\"\n",
     "ml.modelgrid.set_coord_info(\n",
-    "    xoff=123456.7, yoff=765432.1, angrot=15.0, proj4=proj4_str\n",
+    "    xoff=123456.7, yoff=765432.1, angrot=15.0, crs=32614  # EPSG code for WGS84 UTM 14N\n",
     ")\n",
     "ml.dis.start_datetime = \"7/4/1776\""
    ]
@@ -166,10 +165,10 @@
    "execution_count": 6,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:39.839138Z",
-     "iopub.status.busy": "2023-02-22T02:46:39.838845Z",
-     "iopub.status.idle": "2023-02-22T02:46:39.843504Z",
-     "shell.execute_reply": "2023-02-22T02:46:39.842834Z"
+     "iopub.execute_input": "2022-12-15T13:09:55.006173Z",
+     "iopub.status.busy": "2022-12-15T13:09:55.005499Z",
+     "iopub.status.idle": "2022-12-15T13:09:55.011129Z",
+     "shell.execute_reply": "2022-12-15T13:09:55.010348Z"
     }
    },
    "outputs": [
@@ -202,10 +201,10 @@
    "execution_count": 7,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:39.846436Z",
-     "iopub.status.busy": "2023-02-22T02:46:39.846044Z",
-     "iopub.status.idle": "2023-02-22T02:46:39.849860Z",
-     "shell.execute_reply": "2023-02-22T02:46:39.849112Z"
+     "iopub.execute_input": "2022-12-15T13:09:55.016256Z",
+     "iopub.status.busy": "2022-12-15T13:09:55.015644Z",
+     "iopub.status.idle": "2022-12-15T13:09:55.019730Z",
+     "shell.execute_reply": "2022-12-15T13:09:55.018974Z"
     }
    },
    "outputs": [],
@@ -220,37 +219,17 @@
    "execution_count": 8,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:39.853831Z",
-     "iopub.status.busy": "2023-02-22T02:46:39.853492Z",
-     "iopub.status.idle": "2023-02-22T02:46:44.137011Z",
-     "shell.execute_reply": "2023-02-22T02:46:44.136432Z"
+     "iopub.execute_input": "2022-12-15T13:09:55.023257Z",
+     "iopub.status.busy": "2022-12-15T13:09:55.022809Z",
+     "iopub.status.idle": "2022-12-15T13:10:00.978846Z",
+     "shell.execute_reply": "2022-12-15T13:10:00.977156Z"
     }
    },
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "initialize_geometry::proj4_str = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\n",
-      "initialize_geometry::self.grid_crs = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +type=crs\n",
-      "initialize_geometry::nc_crs = epsg:4326\n",
-      "transforming coordinates using = proj=noop ellps=GRS80\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "initialize_geometry::proj4_str = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\n",
-      "initialize_geometry::self.grid_crs = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +type=crs\n",
-      "initialize_geometry::nc_crs = epsg:4326\n",
-      "transforming coordinates using = proj=noop ellps=GRS80\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "<flopy.export.netcdf.NetCdf at 0x7f59802e4dc0>"
+       "<flopy.export.netcdf.NetCdf at 0x116637350>"
       ]
      },
      "execution_count": 8,
@@ -278,10 +257,10 @@
    "execution_count": 9,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:44.140914Z",
-     "iopub.status.busy": "2023-02-22T02:46:44.140387Z",
-     "iopub.status.idle": "2023-02-22T02:46:44.223091Z",
-     "shell.execute_reply": "2023-02-22T02:46:44.222357Z"
+     "iopub.execute_input": "2022-12-15T13:10:00.983997Z",
+     "iopub.status.busy": "2022-12-15T13:10:00.983118Z",
+     "iopub.status.idle": "2022-12-15T13:10:01.104035Z",
+     "shell.execute_reply": "2022-12-15T13:10:01.102874Z"
     }
    },
    "outputs": [
@@ -289,11 +268,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "initialize_geometry::proj4_str = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\n",
-      "initialize_geometry::self.grid_crs = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +type=crs\n",
-      "initialize_geometry::nc_crs = epsg:4326\n",
-      "transforming coordinates using = proj=noop ellps=GRS80\n",
-      "wrote ../../../../../../tmp/tmpd5shx34h/top.shp\n"
+      "wrote ../../../../../../../var/folders/4x/bmhyjcdn3mgfdvkk_jgz6bsrlnfk3t/T/tmpx73wc2e1/top.shp\n"
      ]
     }
    ],
@@ -319,13 +294,21 @@
    "execution_count": 10,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:44.227303Z",
-     "iopub.status.busy": "2023-02-22T02:46:44.226660Z",
-     "iopub.status.idle": "2023-02-22T02:46:47.856872Z",
-     "shell.execute_reply": "2023-02-22T02:46:47.856082Z"
+     "iopub.execute_input": "2022-12-15T13:10:01.108323Z",
+     "iopub.status.busy": "2022-12-15T13:10:01.108016Z",
+     "iopub.status.idle": "2022-12-15T13:10:06.688317Z",
+     "shell.execute_reply": "2022-12-15T13:10:06.687258Z"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "wrote ../../../../../../../Users/aleaf/Documents/GitHub/flopy/examples/Notebooks\n"
+     ]
+    }
+   ],
    "source": [
     "ml.drn.stress_period_data.export(os.path.join(pth, \"drn.shp\"), sparse=True)"
    ]
@@ -342,10 +325,10 @@
    "execution_count": 11,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:47.861204Z",
-     "iopub.status.busy": "2023-02-22T02:46:47.860873Z",
-     "iopub.status.idle": "2023-02-22T02:46:47.965601Z",
-     "shell.execute_reply": "2023-02-22T02:46:47.964768Z"
+     "iopub.execute_input": "2022-12-15T13:10:06.692767Z",
+     "iopub.status.busy": "2022-12-15T13:10:06.692195Z",
+     "iopub.status.idle": "2022-12-15T13:10:06.811913Z",
+     "shell.execute_reply": "2022-12-15T13:10:06.810780Z"
     }
    },
    "outputs": [
@@ -353,11 +336,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "initialize_geometry::proj4_str = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\n",
-      "initialize_geometry::self.grid_crs = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +type=crs\n",
-      "initialize_geometry::nc_crs = epsg:4326\n",
-      "transforming coordinates using = proj=noop ellps=GRS80\n",
-      "wrote ../../../../../../tmp/tmpd5shx34h/hk.shp\n"
+      "wrote ../../../../../../../var/folders/4x/bmhyjcdn3mgfdvkk_jgz6bsrlnfk3t/T/tmpx73wc2e1/hk.shp\n"
      ]
     }
    ],
@@ -379,27 +358,17 @@
    "execution_count": 12,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:47.970059Z",
-     "iopub.status.busy": "2023-02-22T02:46:47.969701Z",
-     "iopub.status.idle": "2023-02-22T02:46:48.037508Z",
-     "shell.execute_reply": "2023-02-22T02:46:48.036908Z"
+     "iopub.execute_input": "2022-12-15T13:10:06.816869Z",
+     "iopub.status.busy": "2022-12-15T13:10:06.816525Z",
+     "iopub.status.idle": "2022-12-15T13:10:06.912220Z",
+     "shell.execute_reply": "2022-12-15T13:10:06.911075Z"
     }
    },
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "initialize_geometry::proj4_str = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\n",
-      "initialize_geometry::self.grid_crs = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +type=crs\n",
-      "initialize_geometry::nc_crs = epsg:4326\n",
-      "transforming coordinates using = proj=noop ellps=GRS80\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "<flopy.export.netcdf.NetCdf at 0x7f5936d359f0>"
+       "<flopy.export.netcdf.NetCdf at 0x1165a9210>"
       ]
      },
      "execution_count": 12,
@@ -429,27 +398,17 @@
    "execution_count": 13,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:48.040906Z",
-     "iopub.status.busy": "2023-02-22T02:46:48.040578Z",
-     "iopub.status.idle": "2023-02-22T02:46:48.554001Z",
-     "shell.execute_reply": "2023-02-22T02:46:48.553348Z"
+     "iopub.execute_input": "2022-12-15T13:10:06.917722Z",
+     "iopub.status.busy": "2022-12-15T13:10:06.917295Z",
+     "iopub.status.idle": "2022-12-15T13:10:07.652862Z",
+     "shell.execute_reply": "2022-12-15T13:10:07.651784Z"
     }
    },
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "initialize_geometry::proj4_str = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\n",
-      "initialize_geometry::self.grid_crs = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +type=crs\n",
-      "initialize_geometry::nc_crs = epsg:4326\n",
-      "transforming coordinates using = proj=noop ellps=GRS80\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "<flopy.export.netcdf.NetCdf at 0x7f5936d35390>"
+       "<flopy.export.netcdf.NetCdf at 0x116601210>"
       ]
      },
      "execution_count": 13,
@@ -475,24 +434,13 @@
    "execution_count": 14,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:48.557877Z",
-     "iopub.status.busy": "2023-02-22T02:46:48.557328Z",
-     "iopub.status.idle": "2023-02-22T02:46:52.509240Z",
-     "shell.execute_reply": "2023-02-22T02:46:52.508538Z"
+     "iopub.execute_input": "2022-12-15T13:10:07.657768Z",
+     "iopub.status.busy": "2022-12-15T13:10:07.657079Z",
+     "iopub.status.idle": "2022-12-15T13:10:12.908166Z",
+     "shell.execute_reply": "2022-12-15T13:10:12.907156Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "initialize_geometry::proj4_str = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\n",
-      "initialize_geometry::self.grid_crs = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +type=crs\n",
-      "initialize_geometry::nc_crs = epsg:4326\n",
-      "transforming coordinates using = proj=noop ellps=GRS80\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "fnc = ml.export(os.path.join(pth, \"model.nc\"))"
    ]
@@ -513,23 +461,13 @@
    "execution_count": 15,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:52.513054Z",
-     "iopub.status.busy": "2023-02-22T02:46:52.512752Z",
-     "iopub.status.idle": "2023-02-22T02:46:56.913471Z",
-     "shell.execute_reply": "2023-02-22T02:46:56.912827Z"
+     "iopub.execute_input": "2022-12-15T13:10:12.912097Z",
+     "iopub.status.busy": "2022-12-15T13:10:12.911660Z",
+     "iopub.status.idle": "2022-12-15T13:10:19.297611Z",
+     "shell.execute_reply": "2022-12-15T13:10:19.296458Z"
     }
    },
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "initialize_geometry::proj4_str = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs\n",
-      "initialize_geometry::self.grid_crs = +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +type=crs\n",
-      "initialize_geometry::nc_crs = epsg:4326\n",
-      "transforming coordinates using = proj=noop ellps=GRS80\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -560,10 +498,10 @@
    "execution_count": 16,
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2023-02-22T02:46:56.916658Z",
-     "iopub.status.busy": "2023-02-22T02:46:56.916322Z",
-     "iopub.status.idle": "2023-02-22T02:46:56.920261Z",
-     "shell.execute_reply": "2023-02-22T02:46:56.919691Z"
+     "iopub.execute_input": "2022-12-15T13:10:19.302256Z",
+     "iopub.status.busy": "2022-12-15T13:10:19.301850Z",
+     "iopub.status.idle": "2022-12-15T13:10:19.307843Z",
+     "shell.execute_reply": "2022-12-15T13:10:19.306763Z"
     }
    },
    "outputs": [],
@@ -579,9 +517,9 @@
  "metadata": {
   "anaconda-cloud": {},
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "flopy",
    "language": "python",
-   "name": "python3"
+   "name": "flopy"
   },
   "language_info": {
    "codemirror_mode": {
@@ -593,7 +531,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/Notebooks/flopy3_shapefile_export.ipynb b/examples/Notebooks/flopy3_shapefile_export.ipynb
index 141b18823..6e519bdff 100644
--- a/examples/Notebooks/flopy3_shapefile_export.ipynb
+++ b/examples/Notebooks/flopy3_shapefile_export.ipynb
@@ -136,7 +136,7 @@
    "outputs": [],
    "source": [
     "grid = m.modelgrid\n",
-    "grid.set_coord_info(xoff=273170, yoff=5088657, epsg=26916)"
+    "grid.set_coord_info(xoff=273170, yoff=5088657, crs=26916)"
    ]
   },
   {
@@ -711,7 +711,7 @@
    "outputs": [],
    "source": [
     "fname = \"{}/bcs.shp\".format(outdir)\n",
-    "recarray2shp(spd.to_records(), geoms=polygons, shpname=fname, epsg=grid.epsg)"
+    "recarray2shp(spd.to_records(), geoms=polygons, shpname=fname, crs=grid.crs)"
    ]
   },
   {
@@ -884,7 +884,7 @@
     "geoms = [Point(x, y) for x, y in zip(welldata.x_utm, welldata.y_utm)]\n",
     "\n",
     "fname = \"{}/wel_data.shp\".format(outdir)\n",
-    "recarray2shp(welldata.to_records(), geoms=geoms, shpname=fname, epsg=grid.epsg)"
+    "recarray2shp(welldata.to_records(), geoms=geoms, shpname=fname, crs=grid.crs)"
    ]
   },
   {
@@ -960,7 +960,7 @@
     "    rivdata.to_records(index=False),\n",
     "    geoms=lines,\n",
     "    shpname=lines_shapefile,\n",
-    "    epsg=grid.epsg,\n",
+    "    crs=grid.crs,\n",
     ")"
    ]
   },
@@ -1240,7 +1240,7 @@
     "    linesdata.drop(\"geometry\", axis=1).to_records(),\n",
     "    geoms=linesdata.geometry.values,\n",
     "    shpname=lines_shapefile,\n",
-    "    epsg=grid.epsg,\n",
+    "    crs=grid.crs,\n",
     ")"
    ]
   },
@@ -1425,7 +1425,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/Notebooks/flopy3_shapefile_features.ipynb b/examples/Notebooks/flopy3_shapefile_features.ipynb
index 245716407..31cccb788 100644
--- a/examples/Notebooks/flopy3_shapefile_features.ipynb
+++ b/examples/Notebooks/flopy3_shapefile_features.ipynb
@@ -9,8 +9,6 @@
     "* `recarray2shp` convience function for writing a numpy record array to a shapefile\n",
     "* `shp2recarray` convience function for quickly reading a shapefile into a numpy recarray\n",
     "* `utils.geometry` classes for writing shapefiles of model input/output. For example, quickly writing a shapefile of model cells with errors identified by the checker\n",
-    "* demonstration of how the `EpsgReference` class works for retrieving projection file information (WKT text) from spatialreference.org, and caching that information locally for when an internet connection isn't available\n",
-    "* how to reset `EpsgReference` if it becomes corrupted\n",
     "* examples of how the `Point` and `LineString` classes can be used to quickly plot pathlines and endpoints from MODPATH (these are also used by the `PathlineFile` and `EndpointFile` classes to write shapefiles of this output)"
    ]
   },
@@ -30,8 +28,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "3.10.6 (main, Nov 14 2022, 16:10:14) [GCC 11.3.0]\n",
-      "numpy version: 1.24.1\n",
+      "3.11.0 | packaged by conda-forge | (main, Jan 15 2023, 05:44:48) [Clang 14.0.6 ]\n",
+      "numpy version: 1.24.2\n",
       "matplotlib version: 3.6.3\n",
       "flopy version: 3.3.7\n"
      ]
@@ -125,7 +123,7 @@
    "outputs": [],
    "source": [
     "grid = m.modelgrid\n",
-    "grid.set_coord_info(xoff=600000, yoff=5170000, proj4=\"EPSG:26715\", angrot=45)"
+    "grid.set_coord_info(xoff=600000, yoff=5170000, crs=\"EPSG:26715\", angrot=45)"
    ]
   },
   {
@@ -309,7 +307,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -327,8 +325,8 @@
    "metadata": {},
    "source": [
     "### write the shapefile  \n",
-    "* the projection (.prj) file can be written using an epsg code  \n",
-    "* or copied from an existing .prj file"
+    "* if a coordinate reference is supplied via the ``crs`` argument, a projection (.prj) file will be written \n",
+    "* alternatively, an existing ESRI-style projection file can be specified with ``prjfile``"
    ]
   },
   {
@@ -342,12 +340,20 @@
      "shell.execute_reply": "2023-02-22T02:44:55.012542Z"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "wrote ../../../../../../../Users/aleaf/Documents/GitHub/flopy/examples/Notebooks\n"
+     ]
+    }
+   ],
    "source": [
     "from pathlib import Path\n",
     "\n",
     "recarray2shp(\n",
-    "    chk.summary_array, geoms, os.path.join(workspace, \"test.shp\"), epsg=26715\n",
+    "    chk.summary_array, geoms, os.path.join(workspace, \"test.shp\"), crs=26715\n",
     ")\n",
     "shape_path = os.path.join(workspace, \"test.prj\")\n",
     "\n",
@@ -374,7 +380,15 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "wrote ../../../../../../../Users/aleaf/Documents/GitHub/flopy/examples/Notebooks\n"
+     ]
+    }
+   ],
    "source": [
     "if not skip:\n",
     "    shutil.copy(shape_path, os.path.join(workspace, \"26715.prj\"))\n",
@@ -382,7 +396,7 @@
     "        chk.summary_array,\n",
     "        geoms,\n",
     "        os.path.join(workspace, \"test.shp\"),\n",
-    "        prj=os.path.join(workspace, \"26715.prj\"),\n",
+    "        prjfile=os.path.join(workspace, \"26715.prj\"),\n",
     "    )"
    ]
   },
@@ -432,7 +446,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -446,211 +460,6 @@
     "    ra.geometry[0].plot()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### How the epsg feature works  \n",
-    "* requires an internet connection the first time to get the prj text from [spatialreference.org](https://spatialreference.org/) using ```requests```  \n",
-    "* if it doesn't exist, ```epsgref.json``` is created in the user's data directory\n",
-    "* the prj text is then stashed in this JSON file hashed by the EPSG numeric code"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-02-22T02:44:55.165963Z",
-     "iopub.status.busy": "2023-02-22T02:44:55.165184Z",
-     "iopub.status.idle": "2023-02-22T02:44:55.170376Z",
-     "shell.execute_reply": "2023-02-22T02:44:55.169477Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from flopy.export.shapefile_utils import EpsgReference\n",
-    "\n",
-    "if not skip:\n",
-    "    ep = EpsgReference()\n",
-    "    prj = ep.to_dict()\n",
-    "    prj"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-02-22T02:44:55.174251Z",
-     "iopub.status.busy": "2023-02-22T02:44:55.173639Z",
-     "iopub.status.idle": "2023-02-22T02:44:55.177454Z",
-     "shell.execute_reply": "2023-02-22T02:44:55.176739Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from flopy.export.shapefile_utils import CRS, EpsgReference"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-02-22T02:44:55.181001Z",
-     "iopub.status.busy": "2023-02-22T02:44:55.180582Z",
-     "iopub.status.idle": "2023-02-22T02:44:55.186573Z",
-     "shell.execute_reply": "2023-02-22T02:44:55.185794Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "26715:\n",
-      "PROJCS[\"NAD_1927_UTM_Zone_15N\",GEOGCS[\"GCS_North_American_1927\",DATUM[\"D_North_American_1927\",SPHEROID[\"Clarke_1866\",6378206.4,294.9786982138982]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-93],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"Meter\",1]]\n",
-      "\n",
-      "4326:\n",
-      "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]]\n",
-      "\n",
-      "26916:\n",
-      "PROJCS[\"NAD_1983_UTM_Zone_16N\",GEOGCS[\"GCS_North_American_1983\",DATUM[\"D_North_American_1983\",SPHEROID[\"GRS_1980\",6378137,298.257222101]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-87],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"Meter\",1]]\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "if not skip:\n",
-    "    CRS.getprj(4326)\n",
-    "\n",
-    "    prj = ep.to_dict()\n",
-    "    for k, v in prj.items():\n",
-    "        print(\"{}:\\n{}\\n\".format(k, v))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### working with the ```flopy.export.shapefile_utils.EpsgReference``` handler"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-02-22T02:44:55.190359Z",
-     "iopub.status.busy": "2023-02-22T02:44:55.189761Z",
-     "iopub.status.idle": "2023-02-22T02:44:55.195162Z",
-     "shell.execute_reply": "2023-02-22T02:44:55.194322Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "26715:\n",
-      "PROJCS[\"NAD_1927_UTM_Zone_15N\",GEOGCS[\"GCS_North_American_1927\",DATUM[\"D_North_American_1927\",SPHEROID[\"Clarke_1866\",6378206.4,294.9786982138982]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-93],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"Meter\",1]]\n",
-      "\n",
-      "4326:\n",
-      "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]]\n",
-      "\n",
-      "26916:\n",
-      "PROJCS[\"NAD_1983_UTM_Zone_16N\",GEOGCS[\"GCS_North_American_1983\",DATUM[\"D_North_American_1983\",SPHEROID[\"GRS_1980\",6378137,298.257222101]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-87],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"Meter\",1]]\n",
-      "\n",
-      "9999:\n",
-      "junk\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "ep = EpsgReference()\n",
-    "\n",
-    "if not skip:\n",
-    "    ep.add(9999, \"junk\")\n",
-    "    EpsgReference.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### remove an entry"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-02-22T02:44:55.199492Z",
-     "iopub.status.busy": "2023-02-22T02:44:55.199011Z",
-     "iopub.status.idle": "2023-02-22T02:44:55.203793Z",
-     "shell.execute_reply": "2023-02-22T02:44:55.202996Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "26715:\n",
-      "PROJCS[\"NAD_1927_UTM_Zone_15N\",GEOGCS[\"GCS_North_American_1927\",DATUM[\"D_North_American_1927\",SPHEROID[\"Clarke_1866\",6378206.4,294.9786982138982]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-93],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"Meter\",1]]\n",
-      "\n",
-      "4326:\n",
-      "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]]\n",
-      "\n",
-      "26916:\n",
-      "PROJCS[\"NAD_1983_UTM_Zone_16N\",GEOGCS[\"GCS_North_American_1983\",DATUM[\"D_North_American_1983\",SPHEROID[\"GRS_1980\",6378137,298.257222101]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-87],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"Meter\",1]]\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "if not skip:\n",
-    "    ep.remove(9999)\n",
-    "    EpsgReference.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### start over with a new file"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-02-22T02:44:55.207813Z",
-     "iopub.status.busy": "2023-02-22T02:44:55.207246Z",
-     "iopub.status.idle": "2023-02-22T02:44:55.212291Z",
-     "shell.execute_reply": "2023-02-22T02:44:55.211450Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Resetting ../../../../.local/share/flopy/epsgref.json\n"
-     ]
-    }
-   ],
-   "source": [
-    "if not skip:\n",
-    "    ep.reset()\n",
-    "    prj = ep.to_dict()\n",
-    "    prj"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -664,7 +473,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 14,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.216552Z",
@@ -681,7 +490,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 15,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.233607Z",
@@ -709,7 +518,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 16,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.247030Z",
@@ -722,10 +531,10 @@
     {
      "data": {
       "text/plain": [
-       "<flopy.utils.geometry.LineString at 0x7f8c444ba4d0>"
+       "<flopy.utils.geometry.LineString at 0x1a3d7e350>"
       ]
      },
-     "execution_count": 22,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -736,7 +545,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 17,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.256945Z",
@@ -752,13 +561,13 @@
        "<AxesSubplot: >"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -773,7 +582,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 18,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.420046Z",
@@ -785,7 +594,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -811,7 +620,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 19,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.561764Z",
@@ -828,7 +637,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 20,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.574408Z",
@@ -853,7 +662,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 21,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.581030Z",
@@ -865,7 +674,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAAxCAYAAAA4J7gpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAP/klEQVR4nO3de0xTdxsH8G87rhXLRblYAWVeOlCD000CQ1yUgcaIt2TxEnVKIEaZ7hJHyIJuzDkGXrK5IWoQt+hmRKcjKmYIbCSjOmVURRFl4gWkGEVaQUGQ5/3DcF6PBQq2YGmfT0LiOb+n55yvD5cnp7RIiIjAGGOMMWZhpK/6AhhjjDHGegMPOYwxxhizSDzkMMYYY8wi8ZDDGGOMMYvEQw5jjDHGLBIPOYwxxhizSDzkMMYYY8wi8ZDDGGOMMYvEQw5jjDHGLBIPOYwxxhizSD0ecgoLCzFr1iwoFApIJBIcPXpUtE5EWL9+PYYMGQJHR0eEh4fj2rVropq6ujosXrwYcrkcLi4uiI6ORkNDg6jmwoULmDx5MhwcHODj44OUlBS9a8nKyoKXlxckEgmkUimUSiX++eefnkZijDHGmAXq8ZDT2NiIwMBA/Pjjjx2up6Sk4Pvvv0d6ejrOnDmDAQMGIDIyEk1NTULN4sWLcenSJeTm5uLYsWMoLCxEbGyssK7T6RAREYFhw4ahuLgYqamp+OKLL7Br1y6hpqioCAsWLMC9e/ewceNGxMbGoqKiAuHh4bh7925PYzHGGGPM0pARANCRI0eE7ba2NvLy8qLU1FRhX319Pdnb29Ovv/5KRESXL18mAHT27FmhJicnhyQSCVVXVxMRUVpaGrm6ulJzc7NQEx8fT0qlUth+//33ydnZmVavXi3sCwoKIplMRt98840xsRhjjDFmAWxMOTBVVlZCo9EgPDxc2Ofs7IygoCCoVCosWLAAKpUKLi4ueOutt4Sa8PBwSKVSnDlzBnPnzoVKpUJYWBjs7OyEmsjISHz77bd48OABXF1doVKpoNPpROeKjIzE1atXoVKpOrw+nU4HnU4nbLe1taGxsREDBw405X8DY4wxxvqAQqGAVNr5k1ImHXI0Gg0AwNPTU7Tf09NTWNNoNPDw8BBfhI0N3NzcRDV+fn56x2hfc3V1hUajARGJzuXp6Ynm5mbhOC+KiorCX3/9ZURCxhhjjJmL27dvw9vbu9N1kw455i47O9uq7+Q8fPgQAQEBuHz5stVkBqw3N8DZrTG7teYGrDe7teYGnt3J6YpJhxwvLy8AQG1tLYYMGSLsr62txfjx44WaF38xuLW1FXV1dcLjvby8UFtbK6pp336+pqqqSlRXW1sLe3t7oeZFcrkccrnciIT9W/uAN3ToUKv6f7DW3ABnB6wvu7XmBqw3u7Xm7g6Tvk+On58fvLy8kJeXJ+zT6XQ4c+YMgoODAQDBwcGor69HcXGxUJOfn4+2tjYEBQUJNYWFhWhpaRFqcnNzoVQq4erqKtQ4OzuLzpWbm4vm5mbhXIwxxhizXj2+k9PQ0ICKigphu7KyEmq1Gm5ubvD19cVHH32EjRs3YtSoUfDz80NiYiIUCgXmzJkDAPD398f06dMRExOD9PR0tLS0IC4uDgsWLBBuOy1atAhffvkloqOjER8fj9LSUnz33XfYtm2bcN61a9fi8OHD2LFjBxQKBaqqqoSXrC9fvtzI/xbGGGOM9Xs9fTlWQUEBAdD7WLZsGRE9exl5YmIieXp6kr29PU2bNo3Ky8tFx7h//z4tXLiQnJycSC6X0/Lly+nhw4eimvPnz1NoaCjZ29vT0KFDKTk5We9aDh48SB4eHgSAJBIJjR49mk6fPt3TSFajqamJNmzYQE1NTa/6UvqUteYm4uzWmN1acxNZb3Zrzd0dEiKiVzlkMcYYY4z1Bv7bVYwxxhizSDzkMMYYY8wi8ZDDGGOMMYvEQw5jjDHGLBIPOf1MYWEhZs2aBYVCAYlEgqNHj4rWJRJJhx+pqakAgBs3biA6Ohp+fn5wdHTEiBEjsGHDBjx58kQ4xo0bNzo8xunTp/syqoixuQFg+PDheuvJycmi41y4cAGTJ0+Gg4MDfHx8kJKS0hfxumRs9j///LPTmrNnzwIwz54DhrM3NDQgLi4O3t7ecHR0REBAANLT00U1TU1NWL16NQYNGgQnJyfMnz9f781Gb926hZkzZ0Imk8HDwwPr1q1Da2trb8frlLG56+rq8OGHH0KpVMLR0RG+vr5Ys2YNtFqt6Dgd9fzAgQN9EbFTpuj5u+++q5dr5cqVohpL63lnX8MSiQRZWVlCnTn2vDdZ1Z91sASNjY0IDAzEihUrMG/ePL31mpoa0XZOTg6io6Mxf/58AMCVK1fQ1taGnTt3YuTIkSgtLUVMTAwaGxuxefNm0WNPnTqFMWPGCNuDBg3qhUTdY2zudklJSYiJiRG2n38LdJ1Oh4iICISHhyM9PR0XL17EihUr4OLigtjYWBMn6j5js4eEhOjVJCYmIi8vT/SHcgHz6jlgOPsnn3yC/Px87Nu3D8OHD8cff/yBVatWQaFQICoqCgDw8ccf4/jx48jKyoKzszPi4uIwb948/P333wCAp0+fYubMmfDy8kJRURFqamqwdOlS2NraYtOmTX2at52xue/cuYM7d+5g8+bNCAgIwM2bN7Fy5UrcuXMHhw4dEh0rMzMT06dPF7ZdXFx6O16XTNFzAIiJiUFSUpKwLZPJhH9bYs99fHz0vs537dqF1NRUzJgxQ7Tf3Hreq171a9jZywNAR44c6bJm9uzZNHXq1C5rUlJSyM/PT9iurKwkAFRSUmKCqzS9l809bNgw2rZtW6ePSUtLI1dXV2pubhb2xcfHk1KpNOZyTcoUPX/y5Am5u7tTUlKSsM/ce07UcfYxY8aIchARTZgwgT7//HMiIqqvrydbW1vKysoS1svKyggAqVQqIiI6ceIESaVS0mg0Qs2OHTtILpeLPhdelZfJ3ZGDBw+SnZ0dtbS0dHlsc/Ky2adMmUJr167t9LjW0vPx48fTihUrDB7bkvHTVRastrYWx48fR3R0dJd1Wq0Wbm5uevujoqLg4eGB0NBQZGdn99ZlmlxXuZOTkzFo0CC8+eabSE1NFd2eVqlUCAsLg52dnbAvMjIS5eXlePDgQZ9cu7G60/Ps7Gzcv3+/w3cG7289DwkJQXZ2Nqqrq0FEKCgowNWrVxEREQEAKC4uRktLC8LDw4XHvPHGG/D19YVKpQLwrO/jxo2Dp6enUBMZGQmdTodLly71baBuMpS7I1qtFnK5HDY24hv4q1evxuDBgzFp0iTs2bMHZOZvndbd7Pv378fgwYMxduxYJCQk4NGjR8KaNfS8uLgYarW6w+8F/a3nxuCnqyzYTz/9hIEDB3Z467NdRUUFtm/fLnqqysnJCVu2bME777wDqVSKw4cPY86cOTh69KjodrC56iz3mjVrMGHCBLi5uaGoqAgJCQmoqanB1q1bAQAajQZ+fn6ix7R/E9RoNMLfTTNn3el5RkYGIiMj4e3tLezrrz3fvn07YmNj4e3tDRsbG0ilUuzevRthYWEAnvXNzs5O73a8p6cnNBqNUPP8D7v29fY1c2Qo94vu3buHr776Su9p16SkJEydOhUymUx4+qOhoQFr1qzpixgvpTvZFy1ahGHDhkGhUODChQuIj49HeXk5fvvtNwDW0fOMjAz4+/sjJCREtL8/9twor/I2EjMODNx2VCqVFBcX1+l6VVUVjRgxgqKjow2ea8mSJRQaGvoyl2lyxuZul5GRQTY2NsJbob/33nsUGxsrqrl06RIBoMuXLxt1zaZibPbbt2+TVCqlQ4cOGTyXOfWcqOPsqampNHr0aMrOzqbz58/T9u3bycnJiXJzc4mIaP/+/WRnZ6d3rLfffps+++wzIiKKiYmhiIgI0XpjYyMBoBMnTvROmB54mdzP02q1NGnSJJo+fTo9efKky3MlJiaSt7e3KS/fKMZmb5eXl0cAqKKigogsv+ePHj0iZ2dn2rx5s8FzmVvPTY2HnH6sqx94hYWFBIDUanWH69XV1TRq1ChasmQJPX361OC5fvjhB/Ly8jLmck3GmNzPKy0tJQB05coVInr2Q3327Nmimvz8fAJAdXV1xl62SRibPSkpidzd3Q3+sCMyr54T6Wd/9OgR2dra0rFjx0R10dHRFBkZSUT//+H24MEDUY2vry9t3bqViJ59kw8MDBStX79+nQDQv//+a/IcPfUyudvpdDoKDg6madOm0ePHjw2e69ixYwTAbP4GkjHZn9fQ0EAA6OTJk0Rk2T0nIvr555/J1taW7t69a/Bc5tZzU+PfybFQGRkZmDhxIgIDA/XWqqur8e6772LixInIzMyEVGr400CtVmPIkCG9cakm1VXuF6nVakilUnh4eAAAgoODUVhYiJaWFqEmNzcXSqWyXzxVZSg7ESEzM1N4FYkh5t7zlpYWtLS06H3+vvbaa2hrawMATJw4Eba2tsjLyxPWy8vLcevWLQQHBwN41veLFy/i7t27Qk1ubi7kcjkCAgL6IEnPdCc38P9XC9rZ2SE7OxsODg4Gj61Wq+Hq6gp7e3uTX7cpdDf7i9RqNQAIn8+W2vN2GRkZiIqKgru7u8Fjm3vPjfaqpyzWMw8fPqSSkhIqKSkhALR161YqKSmhmzdvCjVarZZkMhnt2LFD7/FVVVU0cuRImjZtGlVVVVFNTY3w0W7v3r30yy+/UFlZGZWVldHXX39NUqmU9uzZ0ycZO2Js7qKiItq2bRup1Wr677//aN++feTu7k5Lly4Vaurr68nT05OWLFlCpaWldODAAZLJZLRz584+ydgZY7O3O3XqFAGgsrIyvTVz7DmR4exTpkyhMWPGUEFBAV2/fp0yMzPJwcGB0tLShGOsXLmSfH19KT8/n86dO0fBwcEUHBwsrLe2ttLYsWMpIiKC1Go1nTx5ktzd3SkhIaHP87YzNrdWq6WgoCAaN24cVVRUiL7OW1tbiYgoOzubdu/eTRcvXqRr165RWloayWQyWr9+/SvLTWR89oqKCkpKSqJz585RZWUl/f777/T6669TWFiYcA5L7Hm7a9eukUQioZycHL1zmGvPexMPOf1MQUEBAdD7WLZsmVCzc+dOcnR0pPr6er3HZ2Zmdvj45+fdvXv3kr+/P8lkMpLL5TRp0iTRS3BfBWNzFxcXU1BQEDk7O5ODgwP5+/vTpk2b9G7Rnj9/nkJDQ8ne3p6GDh1KycnJvR3NIGOzt1u4cCGFhIR0uGaOPScynL2mpoY++OADUigU5ODgQEqlkrZs2UJtbW3CMR4/fkyrVq0iV1dXkslkNHfuXNFQT0R048YNmjFjBjk6OtLgwYPp008/Fb3Uuq8Zm7uzxwOgyspKIiLKycmh8ePHk5OTEw0YMIACAwMpPT29W09f9yZjs9+6dYvCwsLIzc2N7O3taeTIkbRu3TrSarWi81haz9slJCSQj49Ph3001573JgmRBb92jDHGGGNWi38nhzHGGGMWiYccxhhjjFkkHnIYY4wxZpF4yGGMMcaYReIhhzHGGGMWiYccxhhjjFkkHnIYY4wxZpF4yGGMMcaYReIhhzHGGGMWiYccxhhjjFkkHnIYY4wxZpF4yGGMMcaYRfofW0Ig48rRYJoAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -884,7 +693,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 22,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-22T02:44:55.929290Z",
@@ -909,9 +718,9 @@
  "metadata": {
   "anaconda-cloud": {},
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "flopy",
    "language": "python",
-   "name": "python3"
+   "name": "flopy"
   },
   "language_info": {
    "codemirror_mode": {
@@ -923,7 +732,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/data/mt3d_test/mfnwt_mt3dusgs/sft_crnkNic/CrnkNic.nam b/examples/data/mt3d_test/mfnwt_mt3dusgs/sft_crnkNic/CrnkNic.nam
index 562046da6..8bfb71514 100644
--- a/examples/data/mt3d_test/mfnwt_mt3dusgs/sft_crnkNic/CrnkNic.nam
+++ b/examples/data/mt3d_test/mfnwt_mt3dusgs/sft_crnkNic/CrnkNic.nam
@@ -1,5 +1,5 @@
 # Name file for MODFLOW-NWT, generated by Flopy version 3.2.6.
-#xul:0; yul:15; rotation:0; proj4_str:EPSG:4326; units:meters; lenuni:2; length_multiplier:1.0 ;start_datetime:1-1-1970
+#xul:0; yul:15; rotation:0; proj4_str:EPSG:26916; units:meters; lenuni:2; length_multiplier:1.0 ;start_datetime:1-1-1970
 LIST               2  CrnkNic.list
 OC                14  CrnkNic.oc
 NWT               32  CrnkNic.nwt
diff --git a/examples/data/options/sagehen/sagehen.nam b/examples/data/options/sagehen/sagehen.nam
index 0a3856af2..9a701c231 100644
--- a/examples/data/options/sagehen/sagehen.nam
+++ b/examples/data/options/sagehen/sagehen.nam
@@ -1,5 +1,5 @@
 #Name file for GSFLOW MODFLOW-NWT model, generated by GSFloPy
-#xul:0; yul:6570; rotation:0; proj4_str:EPSG:4326; units:meters; lenuni:2; length_multiplier:1.0 ;start_datetime:1/1/1970
+#xul:0; yul:6570; rotation:0; proj4_str:EPSG:26910; units:meters; lenuni:2; length_multiplier:1.0 ;start_datetime:1/1/1970
 LIST           26   sagehen.list
 BAS6           8    sagehen.bas
 OC             9    sagehen.oc
diff --git a/examples/data/usgs.model.reference b/examples/data/usgs.model.reference
index 9a89b9ead..ccce54a28 100644
--- a/examples/data/usgs.model.reference
+++ b/examples/data/usgs.model.reference
@@ -6,5 +6,5 @@ time_units days        # model time units (days, years, etc.)
 start_date 1/1/1900    # state date of the model
 start_time 00:00:00    # start time of the model
 model modflow-2000     # MODFLOW model type (MODFLOW-NWT, etc.)
-epsg 102733            # epsg code 
-# proj4 'proj4 string' # or proj4 string 
+#            # epsg code
+proj4 '+proj=lcc +lat_0=31.8333333333333 +lon_0=-81 +lat_1=32.5 +lat_2=34.8333333333333 +x_0=609600 +y_0=0 +datum=NAD83 +units=us-ft +no_defs +type=crs' # or proj4 string
diff --git a/flopy/discretization/grid.py b/flopy/discretization/grid.py
index e64adb7e7..f857545b3 100644
--- a/flopy/discretization/grid.py
+++ b/flopy/discretization/grid.py
@@ -5,6 +5,7 @@
 
 from ..plot.plotutil import UnstructuredPlotUtilities
 from ..utils import geometry
+from ..utils.crs import get_crs
 from ..utils.gridutil import get_lni
 
 
@@ -34,20 +35,23 @@ class Grid:
     ----------
     grid_type : enumeration
         type of model grid ('structured', 'vertex', 'unstructured')
-    top : ndarray(float)
+    top : float or ndarray
         top elevations of cells in topmost layer
-    botm : ndarray(float)
+    botm : float or ndarray
         bottom elevations of all cells
-    idomain : ndarray(int)
+    idomain : int or ndarray
         ibound/idomain value for each cell
-    lenuni : ndarray(int)
+    lenuni : int or ndarray
         model length units
-    espg : str, int
-        optional espg projection code
-    proj4 : str
-        optional proj4 projection string code
-    prj : str
-        optional projection file name path
+    crs : pyproj.CRS, optional if `prjfile` is specified
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+    prjfile : str or pathlike, optional if `crs` is specified
+        ESRI-style projection file with well-known text defining the CRS
+        for the model grid (must be projected; geographic CRS are not supported).
     xoff : float
         x coordinate of the origin point (lower left corner of model grid)
         in the spatial reference coordinate system
@@ -61,16 +65,14 @@ class Grid:
     ----------
     grid_type : enumeration
         type of model grid ('structured', 'vertex', 'unstructured')
-    top : ndarray(float)
+    top : float or ndarray
         top elevations of cells in topmost layer
-    botm : ndarray(float)
+    botm : float or ndarray
         bottom elevations of all cells
-    idomain : ndarray(int)
+    idomain : int or ndarray
         ibound/idomain value for each cell
-    proj4 : proj4 SpatialReference
-        spatial reference locates the grid in a coordinate system
-    epsg : epsg SpatialReference
-        spatial reference locates the grid in a coordinate system
+    crs : pyproj.CRS
+        Coordinate reference system (CRS) for the model grid
     lenuni : int
         modflow lenuni parameter
     xoffset : float
@@ -144,9 +146,11 @@ def __init__(
         botm=None,
         idomain=None,
         lenuni=None,
+        crs=None,
         epsg=None,
         proj4=None,
         prj=None,
+        prjfile=None,
         xoff=0.0,
         yoff=0.0,
         angrot=0.0,
@@ -170,9 +174,13 @@ def __init__(
         self._lenuni = lenuni
 
         self._units = lenunits[self._lenuni]
+        self._crs = get_crs(
+            prjfile=prjfile, prj=prj, epsg=epsg, proj4=proj4, crs=crs
+        )
         self._epsg = epsg
         self._proj4 = proj4
         self._prj = prj
+        self._prjfile = prjfile
         self._xoff = xoff
         self._yoff = yoff
         if angrot is None:
@@ -202,8 +210,8 @@ def __repr__(self):
                 f"yll:{self.yoffset!s}",
                 f"rotation:{self.angrot!s}",
             ]
-        if self.proj4 is not None:
-            items.append(f"proj4_str:{self.proj4}")
+        if self.crs is not None:
+            items.append(f"crs:{self.crs.srs}")
         if self.units is not None:
             items.append(f"units:{self.units}")
         if self.lenuni is not None:
@@ -244,32 +252,33 @@ def angrot(self):
     def angrot_radians(self):
         return self._angrot * np.pi / 180.0
 
+    @property
+    def crs(self):
+        return self._crs
+
+    @crs.setter
+    def crs(self, crs):
+        self._crs = get_crs(crs=crs)
+
     @property
     def epsg(self):
-        return self._epsg
+        if self._crs is not None:
+            return self._crs.to_epsg()
 
     @epsg.setter
     def epsg(self, epsg):
-        self._epsg = epsg
+        self._crs = get_crs(epsg=epsg)
+        self._epsg = self._crs.to_epsg()
 
     @property
     def proj4(self):
-        proj4 = None
-        if self._proj4 is not None:
-            if "epsg" in self._proj4.lower():
-                proj4 = self._proj4
-                # set the epsg if proj4 specifies it
-                tmp = [i for i in self._proj4.split() if "epsg" in i.lower()]
-                self._epsg = int(tmp[0].split(":")[1])
-            else:
-                proj4 = self._proj4
-        elif self.epsg is not None:
-            proj4 = f"epsg:{self.epsg}"
-        return proj4
+        if self._crs is not None:
+            return self._crs.to_proj4()
 
     @proj4.setter
     def proj4(self, proj4):
-        self._proj4 = proj4
+        self._crs = get_crs(proj4=proj4)
+        self._proj4 = self._crs.to_proj4()
 
     @property
     def prj(self):
@@ -277,7 +286,17 @@ def prj(self):
 
     @prj.setter
     def prj(self, prj):
-        self._proj4 = prj
+        self._crs = get_crs(prj=prj)
+        self._prj = prj
+
+    @property
+    def prjfile(self):
+        return self._prjfile
+
+    @prjfile.setter
+    def prjfile(self, prjfile):
+        self._crs = get_crs(prjfile=prjfile)
+        self._prjfile = prjfile
 
     @property
     def top(self):
@@ -796,10 +815,13 @@ def set_coord_info(
         xoff=None,
         yoff=None,
         angrot=None,
+        crs=None,
+        prjfile=None,
         epsg=None,
         proj4=None,
         merge_coord_info=True,
     ):
+        new_crs = get_crs(prjfile=prjfile, epsg=epsg, proj4=proj4, crs=crs)
         if merge_coord_info:
             if xoff is None:
                 xoff = self._xoff
@@ -807,10 +829,8 @@ def set_coord_info(
                 yoff = self._yoff
             if angrot is None:
                 angrot = self._angrot
-            if epsg is None:
-                epsg = self._epsg
-            if proj4 is None:
-                proj4 = self._proj4
+            if new_crs is None:
+                new_crs = self._crs
 
         if xoff is None:
             xoff = 0.0
@@ -822,8 +842,8 @@ def set_coord_info(
         self._xoff = xoff
         self._yoff = yoff
         self._angrot = angrot
-        self._epsg = epsg
-        self._proj4 = proj4
+        self._prjfile = prjfile
+        self.crs = new_crs
         self._require_cache_updates()
 
     def load_coord_info(self, namefile=None, reffile="usgs.model.reference"):
@@ -917,7 +937,7 @@ def read_usgs_model_reference_file(self, reffile="usgs.model.reference"):
                         if line.strip()[0] != "#":
                             info = line.strip().split("#")[0].split()
                             if len(info) > 1:
-                                data = " ".join(info[1:])
+                                data = " ".join(info[1:]).strip("'").strip('"')
                                 if info[0] == "xll":
                                     self._xoff = float(data)
                                 elif info[0] == "yll":
@@ -929,9 +949,9 @@ def read_usgs_model_reference_file(self, reffile="usgs.model.reference"):
                                 elif info[0] == "rotation":
                                     self._angrot = float(data)
                                 elif info[0] == "epsg":
-                                    self._epsg = int(data)
+                                    self.crs = int(data)
                                 elif info[0] == "proj4":
-                                    self._proj4 = data
+                                    self.crs = data
                                 elif info[0] == "start_date":
                                     start_datetime = data
 
@@ -1005,10 +1025,14 @@ def write_shapefile(self, filename="grid.shp", epsg=None, prj=None):
         """
         from ..export.shapefile_utils import write_grid_shapefile
 
-        if epsg is None and prj is None:
-            epsg = self.epsg
         write_grid_shapefile(
-            filename, self, array_dict={}, nan_val=-1.0e9, epsg=epsg, prj=prj
+            filename,
+            self,
+            array_dict={},
+            nan_val=-1.0e9,
+            crs=self.crs,
+            epsg=epsg,
+            prj=prj,
         )
         return
 
diff --git a/flopy/discretization/structuredgrid.py b/flopy/discretization/structuredgrid.py
index dd2c750dc..84d39d430 100644
--- a/flopy/discretization/structuredgrid.py
+++ b/flopy/discretization/structuredgrid.py
@@ -85,10 +85,35 @@ class for a structured model grid
 
     Parameters
     ----------
-    delc
-        delc array
-    delr
-        delr array
+    delr : float or ndarray
+        column spacing along a row.
+    delc : float or ndarray
+        row spacing along a column.
+    top : float or ndarray
+        top elevations of cells in topmost layer
+    botm : float or ndarray
+        bottom elevations of all cells
+    idomain : int or ndarray
+        ibound/idomain value for each cell
+    lenuni : int or ndarray
+        model length units
+    crs : pyproj.CRS, optional if `prjfile` is specified
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+    prjfile : str or pathlike, optional if `crs` is specified
+        ESRI-style projection file with well-known text defining the CRS
+        for the model grid (must be projected; geographic CRS are not supported).
+    xoff : float
+        x coordinate of the origin point (lower left corner of model grid)
+        in the spatial reference coordinate system
+    yoff : float
+        y coordinate of the origin point (lower left corner of model grid)
+        in the spatial reference coordinate system
+    angrot : float
+        rotation angle of model grid, as it is rotated around the origin point
 
     Properties
     ----------
@@ -120,9 +145,11 @@ def __init__(
         botm=None,
         idomain=None,
         lenuni=None,
+        crs=None,
         epsg=None,
         proj4=None,
         prj=None,
+        prjfile=None,
         xoff=0.0,
         yoff=0.0,
         angrot=0.0,
@@ -137,9 +164,11 @@ def __init__(
             botm,
             idomain,
             lenuni,
+            crs,
             epsg,
             proj4,
             prj,
+            prjfile,
             xoff,
             yoff,
             angrot,
diff --git a/flopy/discretization/unstructuredgrid.py b/flopy/discretization/unstructuredgrid.py
index 38ff1efea..64dddfab2 100644
--- a/flopy/discretization/unstructuredgrid.py
+++ b/flopy/discretization/unstructuredgrid.py
@@ -32,6 +32,14 @@ class UnstructuredGrid(Grid):
         list of y center coordinates for all cells in the grid if the grid
         varies by layer or for all cells in a layer if the same grid is used
         for all layers
+    top : list or ndarray
+        top elevations for all cells in the grid.
+    botm : list or ndarray
+        bottom elevations for all cells in the grid.
+    idomain : int or ndarray
+        ibound/idomain value for each cell
+    lenuni : int or ndarray
+        model length units
     ncpl : ndarray
         one dimensional array of size nlay with the number of cells in each
         layer.  This can also be passed in as a tuple or list as long as it
@@ -43,11 +51,24 @@ class UnstructuredGrid(Grid):
         If the model grid defined in verts and iverts applies for all model
         layers, then the length of iverts can be equal to ncpl[0] and there
         is no need to repeat all of the vertex information for cells in layers
+    crs : pyproj.CRS, optional if `prjfile` is specified
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+    prjfile : str or pathlike, optional if `crs` is specified
+        ESRI-style projection file with well-known text defining the CRS
+        for the model grid (must be projected; geographic CRS are not supported).
         beneath the top layer.
-    top : list or ndarray
-        top elevations for all cells in the grid.
-    botm : list or ndarray
-        bottom elevations for all cells in the grid.
+    xoff : float
+        x coordinate of the origin point (lower left corner of model grid)
+        in the spatial reference coordinate system
+    yoff : float
+        y coordinate of the origin point (lower left corner of model grid)
+        in the spatial reference coordinate system
+    angrot : float
+        rotation angle of model grid, as it is rotated around the origin point
     iac : list or ndarray
         optional number of connections per node array
     ja : list or ndarray
@@ -95,9 +116,11 @@ def __init__(
         idomain=None,
         lenuni=None,
         ncpl=None,
+        crs=None,
         epsg=None,
         proj4=None,
         prj=None,
+        prjfile=None,
         xoff=0.0,
         yoff=0.0,
         angrot=0.0,
@@ -110,9 +133,11 @@ def __init__(
             botm,
             idomain,
             lenuni,
+            crs,
             epsg,
             proj4,
             prj,
+            prjfile,
             xoff,
             yoff,
             angrot,
diff --git a/flopy/discretization/vertexgrid.py b/flopy/discretization/vertexgrid.py
index a2e8abc33..340439d3b 100644
--- a/flopy/discretization/vertexgrid.py
+++ b/flopy/discretization/vertexgrid.py
@@ -19,6 +19,31 @@ class for a vertex model grid
         list of vertices that make up the grid
     cell2d
         list of cells and their vertices
+    top : list or ndarray
+        top elevations for all cells in the grid.
+    botm : list or ndarray
+        bottom elevations for all cells in the grid.
+    idomain : int or ndarray
+        ibound/idomain value for each cell
+    lenuni : int or ndarray
+        model length units
+    crs : pyproj.CRS, optional if `prjfile` is specified
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+    prjfile : str or pathlike, optional if `crs` is specified
+        ESRI-style projection file with well-known text defining the CRS
+        for the model grid (must be projected; geographic CRS are not supported).
+    xoff : float
+        x coordinate of the origin point (lower left corner of model grid)
+        in the spatial reference coordinate system
+    yoff : float
+        y coordinate of the origin point (lower left corner of model grid)
+        in the spatial reference coordinate system
+    angrot : float
+        rotation angle of model grid, as it is rotated around the origin point
 
     Properties
     ----------
@@ -42,9 +67,11 @@ def __init__(
         botm=None,
         idomain=None,
         lenuni=None,
+        crs=None,
         epsg=None,
         proj4=None,
         prj=None,
+        prjfile=None,
         xoff=0.0,
         yoff=0.0,
         angrot=0.0,
@@ -58,9 +85,11 @@ def __init__(
             botm,
             idomain,
             lenuni,
+            crs,
             epsg,
             proj4,
             prj,
+            prjfile,
             xoff,
             yoff,
             angrot,
diff --git a/flopy/export/netcdf.py b/flopy/export/netcdf.py
index 056f77bdf..4310f9250 100644
--- a/flopy/export/netcdf.py
+++ b/flopy/export/netcdf.py
@@ -9,8 +9,10 @@
 from typing import Optional, Union
 
 import numpy as np
+from packaging import version
 
 from ..utils import import_optional_dependency
+from ..utils.crs import get_authority_crs
 from .longnames import NC_LONG_NAMES
 from .metadata import acdd
 
@@ -158,11 +160,8 @@ def __init__(
         forgive=False,
         **kwargs,
     ):
-        if isinstance(output_filename, os.PathLike):
-            output_filename = str(
-                Path(output_filename).expanduser().absolute()
-            )
-        assert output_filename.lower().endswith(".nc")
+        output_filename = Path(output_filename)
+        assert output_filename.suffix == ".nc"
         if verbose is None:
             verbose = model.verbose
         if logger is not None:
@@ -172,7 +171,7 @@ def __init__(
         self.var_attr_dict = {}
         self.log = self.logger.log
         if os.path.exists(output_filename):
-            self.logger.warn("removing existing nc file: " + output_filename)
+            self.logger.warn(f"removing existing nc file: {output_filename}")
             os.remove(output_filename)
         self.output_filename = output_filename
 
@@ -202,14 +201,13 @@ def __init__(
         self.start_datetime = dt.strftime("%Y-%m-%dT%H:%M:%SZ")
         self.logger.log(f"start datetime:{self.start_datetime}")
 
-        proj4_str = self.model_grid.proj4
-        if proj4_str is None:
-            proj4_str = "epsg:4326"
+        crs = get_authority_crs(self.model_grid.crs)
+        if crs is None:
             self.logger.warn(
                 "model has no coordinate reference system specified. "
-                f"Using default proj4 string: {proj4_str}"
             )
-        self.proj4_str = proj4_str
+        self.model_crs = crs
+        self.transformer = None
         self.grid_units = self.model_grid.units
         self.z_positive = z_positive
         if self.grid_units is None:
@@ -220,10 +218,49 @@ def __init__(
 
         self.time_units = self.model_time.time_units
 
-        # this gives us confidence that every NetCdf instance
-        # has the same attributes
         self.log("initializing attributes")
-        self._initialize_attributes()
+        self.nc_crs_str = "epsg:4326"
+        self.nc_crs_longname = "https://www.opengis.net/def/crs/EPSG/0/4326"
+        self.nc_semi_major = float(6378137.0)
+        self.nc_inverse_flat = float(298.257223563)
+
+        self.global_attributes = {}
+        self.global_attributes["namefile"] = self.model.namefile
+        self.global_attributes["model_ws"] = self.model.model_ws
+        self.global_attributes["exe_name"] = self.model.exe_name
+        self.global_attributes["modflow_version"] = self.model.version
+
+        self.global_attributes["create_hostname"] = socket.gethostname()
+        self.global_attributes["create_platform"] = platform.system()
+        self.global_attributes["create_directory"] = os.getcwd()
+
+        htol, rtol = -999, -999
+        try:
+            htol, rtol = self.model.solver_tols()
+        except Exception as e:
+            self.logger.warn(f"unable to get solver tolerances:{e!s}")
+        self.global_attributes["solver_head_tolerance"] = htol
+        self.global_attributes["solver_flux_tolerance"] = rtol
+        spatial_attribs = {
+            "xll": self.model_grid.xoffset,
+            "yll": self.model_grid.yoffset,
+            "rotation": self.model_grid.angrot,
+            "crs": self.model_grid.crs,
+        }
+        for n, v in spatial_attribs.items():
+            self.global_attributes["flopy_sr_" + n] = v
+        self.global_attributes[
+            "start_datetime"
+        ] = self.model_time.start_datetime
+
+        self.fillvalue = FILLVALUE
+
+        # initialize attributes
+        self.grid_crs = None
+        self.zs = self.model_grid.xyzcellcenters[2].copy()
+        self.ys = None
+        self.xs = None
+        self.nc = None
         self.log("initializing attributes")
 
         self.time_values_arg = time_values
@@ -384,6 +421,10 @@ def copy(self, output_filename):
         new_net.nc.sync()
         return new_net
 
+    @property
+    def nc_crs(self):
+        return get_authority_crs(self.nc_crs_str)
+
     @classmethod
     def zeros_like(
         cls, other, output_filename=None, verbose=None, logger=None
@@ -627,57 +668,6 @@ def write(self):
         self.nc.close()
         self.log("writing nc file")
 
-    def _initialize_attributes(self):
-        """private method to initial the attributes
-        of the NetCdf instance
-        """
-        assert (
-            "nc" not in self.__dict__.keys()
-        ), "NetCdf._initialize_attributes() error: nc attribute already set"
-
-        self.nc_epsg_str = "epsg:4326"
-        self.nc_crs_longname = "https://www.opengis.net/def/crs/EPSG/0/4326"
-        self.nc_semi_major = float(6378137.0)
-        self.nc_inverse_flat = float(298.257223563)
-
-        self.global_attributes = {}
-        self.global_attributes["namefile"] = self.model.namefile
-        self.global_attributes["model_ws"] = self.model.model_ws
-        self.global_attributes["exe_name"] = self.model.exe_name
-        self.global_attributes["modflow_version"] = self.model.version
-
-        self.global_attributes["create_hostname"] = socket.gethostname()
-        self.global_attributes["create_platform"] = platform.system()
-        self.global_attributes["create_directory"] = os.getcwd()
-
-        htol, rtol = -999, -999
-        try:
-            htol, rtol = self.model.solver_tols()
-        except Exception as e:
-            self.logger.warn(f"unable to get solver tolerances:{e!s}")
-        self.global_attributes["solver_head_tolerance"] = htol
-        self.global_attributes["solver_flux_tolerance"] = rtol
-        spatial_attribs = {
-            "xll": self.model_grid.xoffset,
-            "yll": self.model_grid.yoffset,
-            "rotation": self.model_grid.angrot,
-            "proj4_str": self.model_grid.proj4,
-        }
-        for n, v in spatial_attribs.items():
-            self.global_attributes["flopy_sr_" + n] = v
-        self.global_attributes[
-            "start_datetime"
-        ] = self.model_time.start_datetime
-
-        self.fillvalue = FILLVALUE
-
-        # initialize attributes
-        self.grid_crs = None
-        self.zs = None
-        self.ys = None
-        self.xs = None
-        self.nc = None
-
     def initialize_geometry(self):
         """initialize the geometric information
         needed for the netcdf file
@@ -686,20 +676,15 @@ def initialize_geometry(self):
         from ..utils.parse_version import Version
 
         # Check if using newer pyproj version conventions
-        pyproj220 = Version(pyproj.__version__) >= Version("2.2.0")
-
-        proj4_str = self.proj4_str
-        print(f"initialize_geometry::proj4_str = {proj4_str}")
+        if version.parse(pyproj.__version__) < version.parse("2.2"):
+            raise ValueError(
+                "The FloPy NetCDF module requires pyproj >= 2.2.0."
+            )
 
-        self.log(f"building grid crs using proj4 string: {proj4_str}")
-        if pyproj220:
-            self.grid_crs = pyproj.CRS(proj4_str)
-        else:
-            if proj4_str.lower().startswith("epsg:"):
-                proj4_str = "+init=" + proj4_str
-            self.grid_crs = pyproj.Proj(proj4_str, preserve_units=True)
+        print(f"initialize_geometry::")
 
-        print(f"initialize_geometry::self.grid_crs = {self.grid_crs}")
+        self.log(f"model crs: {self.model_crs}")
+        print(f"model crs: {self.model_crs}")
 
         vmin, vmax = self.model_grid.botm.min(), self.model_grid.top.max()
         if self.z_positive == "down":
@@ -711,39 +696,28 @@ def initialize_geometry(self):
         xs = self.model_grid.xyzcellcenters[0].copy()
 
         # Transform to a known CRS
-        if pyproj220:
-            nc_crs = pyproj.CRS(self.nc_epsg_str)
+        if self.model_crs is not None and self.nc_crs is not None:
             self.transformer = pyproj.Transformer.from_crs(
-                self.grid_crs, nc_crs, always_xy=True
+                self.model_crs, self.nc_crs, always_xy=True
             )
-        else:
-            nc_epsg_str = self.nc_epsg_str
-            if nc_epsg_str.lower().startswith("epsg:"):
-                nc_epsg_str = "+init=" + nc_epsg_str
-            nc_crs = pyproj.Proj(nc_epsg_str)
-            self.transformer = None
 
-        print(f"initialize_geometry::nc_crs = {nc_crs}")
+        print(f"initialize_geometry::nc_crs = {self.nc_crs}")
 
-        if pyproj220:
+        xmin, xmax, ymin, ymax = self.model_grid.extent
+        if self.transformer is not None:
             print(f"transforming coordinates using = {self.transformer}")
 
-        self.log("projecting grid cell center arrays")
-        if pyproj220:
+            self.log("projecting grid cell center arrays")
             self.xs, self.ys = self.transformer.transform(xs, ys)
-        else:
-            self.xs, self.ys = pyproj.transform(self.grid_crs, nc_crs, xs, ys)
 
-        # get transformed bounds and record to check against ScienceBase later
-        xmin, xmax, ymin, ymax = self.model_grid.extent
-        bbox = np.array(
-            [[xmin, ymin], [xmin, ymax], [xmax, ymax], [xmax, ymin]]
-        )
-        if pyproj220:
+            # get transformed bounds and record to check against ScienceBase later
+            bbox = np.array(
+                [[xmin, ymin], [xmin, ymax], [xmax, ymax], [xmax, ymin]]
+            )
             x, y = self.transformer.transform(*bbox.transpose())
+            self.bounds = x.min(), y.min(), x.max(), y.max()
         else:
-            x, y = pyproj.transform(self.grid_crs, nc_crs, *bbox.transpose())
-        self.bounds = x.min(), y.min(), x.max(), y.max()
+            self.bounds = xmin, ymin, xmax, ymax
         self.vbounds = vmin, vmax
 
     def initialize_file(self, time_values=None):
@@ -759,16 +733,14 @@ def initialize_file(self, time_values=None):
                 self.model.dis.perlen and self.start_datetime
 
         """
-        from ..export.shapefile_utils import CRS
         from ..version import __version__ as version
 
         if self.nc is not None:
             raise Exception("nc file already initialized")
 
-        if self.grid_crs is None:
-            self.log("initializing geometry")
-            self.initialize_geometry()
-            self.log("initializing geometry")
+        self.log("initializing geometry")
+        self.initialize_geometry()
+        self.log("initializing geometry")
 
         netCDF4 = import_optional_dependency("netCDF4")
 
@@ -817,7 +789,7 @@ def initialize_file(self, time_values=None):
         # Metadata variables
         crs = self.nc.createVariable("crs", "i4")
         crs.long_name = self.nc_crs_longname
-        crs.epsg_code = self.nc_epsg_str
+        crs.crs_wkt = self.nc_crs.to_wkt()
         crs.semi_major_axis = self.nc_semi_major
         crs.inverse_flattening = self.nc_inverse_flat
         self.log("setting CRS info")
@@ -919,12 +891,9 @@ def initialize_file(self, time_values=None):
         )
         y[:] = self.model_grid.xyzcellcenters[1]
 
-        # grid mapping variable
-        crs = CRS(
-            prj=self.model_grid.prj,
-            epsg=self.model_grid.epsg,
-        )
-        attribs = crs.grid_mapping_attribs
+        # convert pyproj.CRS object to a
+        # Climate and Forecast (CF) Grid Mapping Version 1.8 dict.
+        attribs = self.nc_crs.to_cf()
         if attribs is not None:
             self.log("creating grid mapping variable")
             self.create_variable(
diff --git a/flopy/export/shapefile_utils.py b/flopy/export/shapefile_utils.py
index 68bc182d0..54351a99a 100644
--- a/flopy/export/shapefile_utils.py
+++ b/flopy/export/shapefile_utils.py
@@ -16,6 +16,7 @@
 
 from ..datbase import DataInterface, DataType
 from ..utils import Util3d, flopy_io, import_optional_dependency
+from ..utils.crs import get_crs
 
 # web address of spatial reference dot org
 srefhttp = "https://spatialreference.org"
@@ -54,7 +55,8 @@ def write_gridlines_shapefile(filename: Union[str, os.PathLike], mg):
         wr.record(i)
 
     wr.close()
-    write_prj(filename, mg=mg)
+    write_prj(filename, modelgrid=mg)
+    return
 
 
 def write_grid_shapefile(
@@ -62,6 +64,8 @@ def write_grid_shapefile(
     mg,
     array_dict,
     nan_val=np.nan,
+    crs=None,
+    prjfile=None,
     epsg=None,
     prj: Optional[Union[str, os.PathLike]] = None,
     verbose=False,
@@ -79,12 +83,15 @@ def write_grid_shapefile(
         dictionary of model input arrays
     nan_val : float
         value to fill nans
-    epsg : str, int
-        epsg code
-    prj : str or PathLike, optional, default None
-        projection file path
-    verbose : bool, default False
-        whether to print verbose output
+    crs : pyproj.CRS, optional if `prjfile` is specified
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+    prjfile : str or pathlike, optional if `crs` is specified
+        ESRI-style projection file with well-known text defining the CRS
+        for the model grid (must be projected; geographic CRS are not supported).
 
     Returns
     -------
@@ -207,7 +214,8 @@ def write_grid_shapefile(
         print(f"wrote {flopy_io.relpath_safe(path)}")
 
     # write the projection file
-    write_prj(path, mg, epsg, prj, verbose=verbose)
+    write_prj(path, mg, crs=crs, epsg=epsg, prj=prj, prjfile=prjfile)
+    return
 
 
 def model_attributes_to_shapefile(
@@ -240,10 +248,15 @@ def model_attributes_to_shapefile(
         modelgrid : fp.modflow.Grid object
             if modelgrid is supplied, user supplied modelgrid is used in lieu
             of the modelgrid attached to the modflow model object
-        epsg : int
-            epsg projection information
-        prj : str or PathLike
-            prj file path
+        crs : pyproj.CRS, optional if `prjfile` is specified
+            Coordinate reference system (CRS) for the model grid
+            (must be projected; geographic CRS are not supported).
+            The value can be anything accepted by
+            :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+            such as an authority string (eg "EPSG:26916") or a WKT string.
+        prjfile : str or pathlike, optional if `crs` is specified
+            ESRI-style projection file with well-known text defining the CRS
+            for the model grid (must be projected; geographic CRS are not supported).
 
     Returns
     -------
@@ -387,10 +400,10 @@ def model_attributes_to_shapefile(
                                 array_dict[name] = arr
 
     # write data arrays to a shapefile
-    write_grid_shapefile(path, grid, array_dict, verbose=verbose)
-    epsg = kwargs.get("epsg", None)
-    prj = kwargs.get("prj", None)
-    write_prj(path, grid, epsg, prj, verbose=verbose)
+    write_grid_shapefile(path, grid, array_dict)
+    crs = kwargs.get("crs", None)
+    prjfile = kwargs.get("prjfile", None)
+    write_prj(path, grid, crs=crs, prjfile=prjfile)
 
 
 def shape_attr_name(name, length=6, keep_layer=False):
@@ -533,6 +546,8 @@ def recarray2shp(
     geoms,
     shpname: Union[str, os.PathLike] = "recarray.shp",
     mg=None,
+    crs=None,
+    prjfile=None,
     epsg=None,
     prj: Optional[Union[str, os.PathLike]] = None,
     verbose=False,
@@ -556,21 +571,19 @@ def recarray2shp(
         recarray.
     shpname : str or PathLike, default "recarray.shp"
         Path for the output shapefile
-    epsg : int
-        EPSG code. See https://www.epsg-registry.org/ or spatialreference.org
-    prj : str or PathLike, optional, default None
-        Existing projection file to be used with new shapefile.
-    verbose : bool
-        Whether to print verbose output
+    crs : pyproj.CRS, optional if `prjfile` is specified
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+    prjfile : str or pathlike, optional if `crs` is specified
+        ESRI-style projection file with well-known text defining the CRS
+        for the model grid (must be projected; geographic CRS are not supported).
 
     Notes
     -----
     Uses pyshp.
-    epsg code requires an internet connection the first time to get the
-    projection file text from spatialreference.org, but then stashes the text
-    in the file epsgref.json (located in the user's data directory) for
-    subsequent use. See flopy.reference for more details.
-
     """
     from ..utils.geospatial_utils import GeoSpatialCollection
 
@@ -624,430 +637,35 @@ def recarray2shp(
             w.record(*r)
 
     w.close()
-    write_prj(shpname, mg, epsg, prj)
-    if verbose:
-        print(f"wrote {flopy_io.relpath_safe(shpname)}")
+    write_prj(shpname, mg, crs=crs, epsg=epsg, prj=prj, prjfile=prjfile)
+    print(f"wrote {flopy_io.relpath_safe(os.getcwd(), shpname)}")
+    return
 
 
 def write_prj(
-    shpname: Union[str, os.PathLike],
-    mg=None,
+    shpname,
+    modelgrid=None,
+    crs=None,
     epsg=None,
-    prj: Optional[Union[str, os.PathLike]] = None,
+    prj=None,
+    prjfile=None,
     wkt_string=None,
-    verbose=False,
 ):
     # projection file name
-    prjname = Path(shpname).with_suffix(".prj")
-
-    # figure which CRS option to use
-    # prioritize args over grid reference
-    # no proj4 option because it is too difficult
-    # to create prjfile from proj4 string without OGR
-    prjtxt = wkt_string
-    if epsg is not None:
-        prjtxt = CRS.getprj(epsg)
-    # copy a supplied prj file
-    elif prj is not None:
-        if prjname.exists():
-            if verbose:
-                print(
-                    f".prj file {flopy_io.relpath_safe(prjname)} already exists"
-                )
-        else:
-            shutil.copy(str(prj), str(prjname))
-
-    elif mg is not None:
-        if mg.epsg is not None:
-            prjtxt = CRS.getprj(mg.epsg)
-
+    output_projection_file = Path(shpname).with_suffix(".prj")
+
+    crs = get_crs(
+        prjfile=prjfile, prj=prj, epsg=epsg, crs=crs, wkt_string=wkt_string
+    )
+    if crs is None and modelgrid is not None:
+        crs = modelgrid.crs
+    if crs is not None:
+        with open(output_projection_file, "w", encoding="utf-8") as dest:
+            write_text = crs.to_wkt()
+            dest.write(write_text)
     else:
         print(
             "No CRS information for writing a .prj file.\n"
-            "Supply an epsg code or .prj file path to the "
-            "model spatial reference or .export() method."
-            "(writing .prj files from proj4 strings not supported)"
-        )
-    if prjtxt is not None:
-        prjname.write_text(prjtxt)
-
-
-class CRS:
-    """
-    Container to parse and store coordinate reference system parameters,
-    and translate between different formats.
-    """
-
-    def __init__(self, prj=None, esri_wkt=None, epsg=None):
-        self.wktstr = None
-        if prj is not None:
-            with open(prj) as prj_input:
-                self.wktstr = prj_input.read()
-        elif esri_wkt is not None:
-            self.wktstr = esri_wkt
-        elif epsg is not None:
-            wktstr = CRS.getprj(epsg)
-            if wktstr is not None:
-                self.wktstr = wktstr
-        if self.wktstr is not None:
-            self.parse_wkt()
-
-    @property
-    def crs(self):
-        """
-        Dict mapping crs attributes to proj4 parameters
-        """
-        proj = None
-        if self.projcs is not None:
-            # projection
-            if "mercator" in self.projcs.lower():
-                if (
-                    "transvers" in self.projcs.lower()
-                    or "tm" in self.projcs.lower()
-                ):
-                    proj = "tmerc"
-                else:
-                    proj = "merc"
-            elif (
-                "utm" in self.projcs.lower() and "zone" in self.projcs.lower()
-            ):
-                proj = "utm"
-            elif "stateplane" in self.projcs.lower():
-                proj = "lcc"
-            elif "lambert" and "conformal" and "conic" in self.projcs.lower():
-                proj = "lcc"
-            elif "albers" in self.projcs.lower():
-                proj = "aea"
-        elif self.projcs is None and self.geogcs is not None:
-            proj = "longlat"
-
-        # datum
-        datum = None
-        if (
-            "NAD" in self.datum.lower()
-            or "north" in self.datum.lower()
-            and "america" in self.datum.lower()
-        ):
-            datum = "nad"
-            if "83" in self.datum.lower():
-                datum += "83"
-            elif "27" in self.datum.lower():
-                datum += "27"
-        elif "84" in self.datum.lower():
-            datum = "wgs84"
-
-        # ellipse
-        ellps = None
-        if "1866" in self.spheroid_name:
-            ellps = "clrk66"
-        elif "grs" in self.spheroid_name.lower():
-            ellps = "grs80"
-        elif "wgs" in self.spheroid_name.lower():
-            ellps = "wgs84"
-
-        return {
-            "proj": proj,
-            "datum": datum,
-            "ellps": ellps,
-            "a": self.semi_major_axis,
-            "rf": self.inverse_flattening,
-            "lat_0": self.latitude_of_origin,
-            "lat_1": self.standard_parallel_1,
-            "lat_2": self.standard_parallel_2,
-            "lon_0": self.central_meridian,
-            "k_0": self.scale_factor,
-            "x_0": self.false_easting,
-            "y_0": self.false_northing,
-            "units": self.projcs_unit,
-            "zone": self.utm_zone,
-        }
-
-    @property
-    def grid_mapping_attribs(self):
-        """
-        Map parameters for CF Grid Mappings
-        https://cfconventions.org/cf-conventions/cf-conventions.html#appendix-grid-mappings,
-        Appendix F: Grid Mappings
-
-        """
-        if self.wktstr is not None:
-            sp = [
-                p
-                for p in [
-                    self.standard_parallel_1,
-                    self.standard_parallel_2,
-                ]
-                if p is not None
-            ]
-            sp = sp if len(sp) > 0 else None
-            proj = self.crs["proj"]
-            names = {
-                "aea": "albers_conical_equal_area",
-                "aeqd": "azimuthal_equidistant",
-                "laea": "lambert_azimuthal_equal_area",
-                "longlat": "latitude_longitude",
-                "lcc": "lambert_conformal_conic",
-                "merc": "mercator",
-                "tmerc": "transverse_mercator",
-                "utm": "transverse_mercator",
-            }
-            attribs = {
-                "grid_mapping_name": names[proj],
-                "semi_major_axis": self.crs["a"],
-                "inverse_flattening": self.crs["rf"],
-                "standard_parallel": sp,
-                "longitude_of_central_meridian": self.crs["lon_0"],
-                "latitude_of_projection_origin": self.crs["lat_0"],
-                "scale_factor_at_projection_origin": self.crs["k_0"],
-                "false_easting": self.crs["x_0"],
-                "false_northing": self.crs["y_0"],
-            }
-            return {k: v for k, v in attribs.items() if v is not None}
-
-    @property
-    def proj4(self):
-        """
-        Not implemented yet
-        """
-        return None
-
-    def parse_wkt(self):
-        self.projcs = self._gettxt('PROJCS["', '"')
-        self.utm_zone = None
-        if self.projcs is not None and "utm" in self.projcs.lower():
-            self.utm_zone = self.projcs[-3:].lower().strip("n").strip("s")
-        self.geogcs = self._gettxt('GEOGCS["', '"')
-        self.datum = self._gettxt('DATUM["', '"')
-        tmp = self._getgcsparam("SPHEROID")
-        self.spheroid_name = tmp.pop(0)
-        self.semi_major_axis = tmp.pop(0)
-        self.inverse_flattening = tmp.pop(0)
-        self.primem = self._getgcsparam("PRIMEM")
-        self.gcs_unit = self._getgcsparam("UNIT")
-        self.projection = self._gettxt('PROJECTION["', '"')
-        self.latitude_of_origin = self._getvalue("latitude_of_origin")
-        self.central_meridian = self._getvalue("central_meridian")
-        self.standard_parallel_1 = self._getvalue("standard_parallel_1")
-        self.standard_parallel_2 = self._getvalue("standard_parallel_2")
-        self.scale_factor = self._getvalue("scale_factor")
-        self.false_easting = self._getvalue("false_easting")
-        self.false_northing = self._getvalue("false_northing")
-        self.projcs_unit = self._getprojcs_unit()
-
-    def _gettxt(self, s1, s2):
-        s = self.wktstr.lower()
-        strt = s.find(s1.lower())
-        if strt >= 0:  # -1 indicates not found
-            strt += len(s1)
-            end = s[strt:].find(s2.lower()) + strt
-            return self.wktstr[strt:end]
-
-    def _getvalue(self, k):
-        s = self.wktstr.lower()
-        strt = s.find(k.lower())
-        if strt >= 0:
-            strt += len(k)
-            end = s[strt:].find("]") + strt
-            try:
-                return float(self.wktstr[strt:end].split(",")[1])
-            except (
-                IndexError,
-                TypeError,
-                ValueError,
-                AttributeError,
-            ):
-                pass
-
-    def _getgcsparam(self, txt):
-        nvalues = 3 if txt.lower() == "spheroid" else 2
-        tmp = self._gettxt(f'{txt}["', "]")
-        if tmp is not None:
-            tmp = tmp.replace('"', "").split(",")
-            name = tmp[0:1]
-            values = list(map(float, tmp[1:nvalues]))
-            return name + values
-        else:
-            return [None] * nvalues
-
-    def _getprojcs_unit(self):
-        if self.projcs is not None:
-            tmp = self.wktstr.lower().split('unit["')[-1]
-            uname, ufactor = tmp.strip().strip("]").split('",')[0:2]
-            ufactor = float(ufactor.split("]")[0].split()[0].split(",")[0])
-            return uname, ufactor
-        return None, None
-
-    @staticmethod
-    def getprj(epsg, addlocalreference=True, text="esriwkt"):
-        """
-        Gets projection file (.prj) text for given epsg code from
-        spatialreference.org
-        See: https://www.epsg-registry.org/
-
-        Parameters
-        ----------
-        epsg : int
-            epsg code for coordinate system
-        addlocalreference : boolean
-            adds the projection file text associated with epsg to a local
-            database, epsgref.json, located in the user's data directory.
-
-        Returns
-        -------
-        str
-            text for a projection (*.prj) file.
-
-        """
-        epsgfile = EpsgReference()
-        wktstr = epsgfile.get(epsg)
-        if wktstr is None:
-            wktstr = CRS.get_spatialreference(epsg, text=text)
-        if addlocalreference and wktstr is not None:
-            epsgfile.add(epsg, wktstr)
-        return wktstr
-
-    @staticmethod
-    def get_spatialreference(epsg, text="esriwkt"):
-        """
-        Gets text for given epsg code and text format from spatialreference.org
-        Fetches the reference text using the url:
-            https://spatialreference.org/ref/epsg/<epsg code>/<text>/
-        See: https://www.epsg-registry.org/
-
-        Parameters
-        ----------
-        epsg : int
-            epsg code for coordinate system
-        text : str
-            string added to url
-
-        Returns
-        -------
-        str
-
-        """
-        from ..utils.flopy_io import get_url_text
-
-        epsg_categories = (
-            "epsg",
-            "esri",
+            "Supply an valid coordinate system reference to the attached modelgrid object "
+            "or .export() method."
         )
-        urls = []
-        for cat in epsg_categories:
-            url = f"{srefhttp}/ref/{cat}/{epsg}/{text}/"
-            urls.append(url)
-            result = get_url_text(url)
-            if result is not None:
-                break
-        if result is not None:
-            return result.replace("\n", "")
-        elif result is None and text != "epsg":
-            error_msg = (
-                f"No internet connection or epsg code {epsg} not found at:\n"
-            )
-            for idx, url in enumerate(urls):
-                error_msg += f"  {idx + 1:>2d}: {url}\n"
-            print(error_msg)
-        # epsg code not listed on spatialreference.org
-        # may still work with pyproj
-        elif text == "epsg":
-            return f"epsg:{epsg}"
-
-    @staticmethod
-    def getproj4(epsg):
-        """
-        Gets projection file (.prj) text for given epsg code from
-        spatialreference.org. See: https://www.epsg-registry.org/
-
-        Parameters
-        ----------
-        epsg : int
-            epsg code for coordinate system
-
-        Returns
-        -------
-        str
-            text for a projection (*.prj) file.
-        """
-        return CRS.get_spatialreference(epsg, text="proj4")
-
-
-class EpsgReference:
-    r"""
-    Sets up a local database of text representations of coordinate reference
-    systems, keyed by EPSG code.
-
-    The database is epsgref.json, located in either "%LOCALAPPDATA%\flopy"
-    for Windows users, or $HOME/.local/share/flopy for others.
-    """
-
-    def __init__(self):
-        if sys.platform.startswith("win"):
-            flopy_appdata = Path(os.path.expandvars(r"%LOCALAPPDATA%\flopy"))
-        else:
-            flopy_appdata = Path.home() / ".local" / "share" / "flopy"
-        if not flopy_appdata.exists():
-            flopy_appdata.mkdir(parents=True, exist_ok=True)
-        dbname = "epsgref.json"
-        self.location = flopy_appdata / dbname
-
-    def to_dict(self):
-        """
-        returns dict with EPSG code integer key, and WKT CRS text
-        """
-        data = {}
-        if self.location.exists():
-            loaded_data = json.loads(self.location.read_text())
-            # convert JSON key from str to EPSG integer
-            for key, value in loaded_data.items():
-                try:
-                    data[int(key)] = value
-                except ValueError:
-                    data[key] = value
-        return data
-
-    def _write(self, data):
-        with self.location.open("w") as f:
-            json.dump(data, f, indent=0)
-            f.write("\n")
-
-    def reset(self, verbose=True):
-        if self.location.exists():
-            if verbose:
-                print(f"Resetting {flopy_io.relpath_safe(self.location)}")
-            self.location.unlink()
-        elif verbose:
-            print(
-                f"{flopy_io.relpath_safe(self.location)} does not exist, no reset required"
-            )
-
-    def add(self, epsg, prj):
-        """
-        add an epsg code to epsgref.json
-        """
-        data = self.to_dict()
-        data[epsg] = prj
-        self._write(data)
-
-    def get(self, epsg):
-        """
-        returns prj from a epsg code, otherwise None if not found
-        """
-        data = self.to_dict()
-        return data.get(epsg)
-
-    def remove(self, epsg):
-        """
-        removes an epsg entry from epsgref.json
-        """
-        data = self.to_dict()
-        if epsg in data:
-            del data[epsg]
-            self._write(data)
-
-    @staticmethod
-    def show():
-        ep = EpsgReference()
-        prj = ep.to_dict()
-        for k, v in prj.items():
-            print(f"{k}:\n{v}\n")
diff --git a/flopy/export/utils.py b/flopy/export/utils.py
index 27670be8f..3b94cb10a 100644
--- a/flopy/export/utils.py
+++ b/flopy/export/utils.py
@@ -1,4 +1,5 @@
 import os
+from pathlib import Path
 from typing import Optional, Union
 
 import numpy as np
@@ -15,6 +16,7 @@
     flopy_io,
     import_optional_dependency,
 )
+from ..utils.crs import get_crs
 from . import NetCdf, netcdf, shapefile_utils, vtk
 from .longnames import NC_LONG_NAMES
 from .unitsformat import NC_UNITS_FORMAT
@@ -400,10 +402,9 @@ def output_helper(
         elif verbose:
             print(msg)
     times = [t for t in common_times[::stride]]
-
-    if isinstance(f, os.PathLike):
-        f = str(f)
-    if isinstance(f, str) and f.lower().endswith(".nc"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".nc":
         f = NetCdf(
             f, ml, time_values=times, logger=logger, forgive=forgive, **kwargs
         )
@@ -512,7 +513,9 @@ def output_helper(
                 mask_array3d=mask_array3d,
             )
 
-    elif isinstance(f, str) and f.endswith(".shp"):
+    elif (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".shp":
         attrib_dict = {}
         for _, out_obj in oudic.items():
             if (
@@ -593,11 +596,16 @@ def model_export(
         modelgrid: flopy.discretization.Grid
             user supplied modelgrid object which will supercede the built
             in modelgrid object
-        epsg : int
-            epsg projection code
-        prj : str
-            prj file name
-        if fmt is set to 'vtk', parameters of vtk.export_model
+        crs : pyproj.CRS, optional if `prjfile` is specified
+            Coordinate reference system (CRS) for the model grid
+            (must be projected; geographic CRS are not supported).
+            The value can be anything accepted by
+            :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+            such as an authority string (eg "EPSG:26916") or a WKT string.
+        prjfile : str or pathlike, optional if `crs` is specified
+            ESRI-style projection file with well-known text defining the CRS
+            for the model grid (must be projected; geographic CRS are not supported).
+            if fmt is set to 'vtk', parameters of vtk.export_model
 
     """
     assert isinstance(ml, ModelInterface)
@@ -605,13 +613,14 @@ def model_export(
     if package_names is None:
         package_names = [pak.name[0] for pak in ml.packagelist]
 
-    if isinstance(f, os.PathLike):
-        f = str(f)
-
-    if isinstance(f, str) and f.lower().endswith(".nc"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".nc":
         f = NetCdf(f, ml, **kwargs)
 
-    if isinstance(f, str) and f.lower().endswith(".shp"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".shp":
         shapefile_utils.model_attributes_to_shapefile(
             f, ml, package_names=package_names, **kwargs
         )
@@ -680,10 +689,15 @@ def package_export(
         modelgrid: flopy.discretization.Grid
             user supplied modelgrid object which will supercede the built
             in modelgrid object
-        epsg : int
-            epsg projection code
-        prj : str
-            prj file name
+        crs : pyproj.CRS, optional if `prjfile` is specified
+            Coordinate reference system (CRS) for the model grid
+            (must be projected; geographic CRS are not supported).
+            The value can be anything accepted by
+            :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+            such as an authority string (eg "EPSG:26916") or a WKT string.
+        prjfile : str or pathlike, optional if `crs` is specified
+            ESRI-style projection file with well-known text defining the CRS
+            for the model grid (must be projected; geographic CRS are not supported).
         if fmt is set to 'vtk', parameters of vtk.export_package
 
     Returns
@@ -693,13 +707,14 @@ def package_export(
     """
     assert isinstance(pak, PackageInterface)
 
-    if isinstance(f, os.PathLike):
-        f = str(f)
-
-    if isinstance(f, str) and f.lower().endswith(".nc"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".nc":
         f = NetCdf(f, pak.parent, **kwargs)
 
-    if isinstance(f, str) and f.lower().endswith(".shp"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".shp":
         shapefile_utils.model_attributes_to_shapefile(
             f, pak.parent, package_names=pak.name, verbose=verbose, **kwargs
         )
@@ -806,10 +821,9 @@ def generic_array_export(
             flopy model object
 
     """
-    if isinstance(f, os.PathLike):
-        f = str(f)
-
-    if isinstance(f, str) and f.lower().endswith(".nc"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".nc":
         assert "model" in kwargs.keys(), (
             "creating a new netCDF using generic_array_helper requires a "
             "'model' kwarg"
@@ -874,6 +888,15 @@ def mflist_export(f: Union[str, os.PathLike, NetCdf], mfl, **kwargs):
     **kwargs : keyword arguments
         modelgrid : flopy.discretization.Grid
             model grid instance which will supercede the flopy.model.modelgrid
+        crs : pyproj.CRS, optional if `prjfile` is specified
+            Coordinate reference system (CRS) for the model grid
+            (must be projected; geographic CRS are not supported).
+            The value can be anything accepted by
+            :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+            such as an authority string (eg "EPSG:26916") or a WKT string.
+        prjfile : str or pathlike, optional if `crs` is specified
+            ESRI-style projection file with well-known text defining the CRS
+            for the model grid (must be projected; geographic CRS are not supported).
 
     """
     if not isinstance(mfl, (DataListInterface, DataInterface)):
@@ -887,13 +910,14 @@ def mflist_export(f: Union[str, os.PathLike, NetCdf], mfl, **kwargs):
     if "modelgrid" in kwargs:
         modelgrid = kwargs.pop("modelgrid")
 
-    if isinstance(f, os.PathLike):
-        f = str(f)
-
-    if isinstance(f, str) and f.lower().endswith(".nc"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".nc":
         f = NetCdf(f, mfl.model, **kwargs)
 
-    if isinstance(f, str) and f.lower().endswith(".shp"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".shp":
         sparse = kwargs.get("sparse", False)
         kper = kwargs.get("kper", 0)
         squeeze = kwargs.get("squeeze", True)
@@ -938,11 +962,16 @@ def mflist_export(f: Union[str, os.PathLike, NetCdf], mfl, **kwargs):
                     ]
                 )
                 ra = df.to_records(index=False)
-            epsg = kwargs.get("epsg", None)
-            prj = kwargs.get("prj", None)
+            crs = kwargs.get("crs", None)
+            prjfile = kwargs.get("prjfile", None)
             polys = np.array([Polygon(v) for v in verts])
             recarray2shp(
-                ra, geoms=polys, shpname=f, mg=modelgrid, epsg=epsg, prj=prj
+                ra,
+                geoms=polys,
+                shpname=f,
+                mg=modelgrid,
+                crs=crs,
+                prjfile=prjfile,
             )
 
     elif isinstance(f, NetCdf) or isinstance(f, dict):
@@ -1038,13 +1067,14 @@ def transient2d_export(f: Union[str, os.PathLike], t2d, fmt=None, **kwargs):
     if "modelgrid" in kwargs:
         modelgrid = kwargs.pop("modelgrid")
 
-    if isinstance(f, os.PathLike):
-        f = str(f)
-
-    if isinstance(f, str) and f.lower().endswith(".nc"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".nc":
         f = NetCdf(f, t2d.model, **kwargs)
 
-    if isinstance(f, str) and f.lower().endswith(".shp"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".shp":
         array_dict = {}
         for kper in range(t2d.model.modeltime.nper):
             u2d = t2d[kper]
@@ -1194,13 +1224,14 @@ def array3d_export(f: Union[str, os.PathLike], u3d, fmt=None, **kwargs):
     if "modelgrid" in kwargs:
         modelgrid = kwargs.pop("modelgrid")
 
-    if isinstance(f, os.PathLike):
-        f = str(f)
-
-    if isinstance(f, str) and f.lower().endswith(".nc"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".nc":
         f = NetCdf(f, u3d.model, **kwargs)
 
-    if isinstance(f, str) and f.lower().endswith(".shp"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".shp":
         array_dict = {}
         for ilay in range(modelgrid.nlay):
             u2d = u3d[ilay]
@@ -1371,21 +1402,24 @@ def array2d_export(
     if "modelgrid" in kwargs:
         modelgrid = kwargs.pop("modelgrid")
 
-    if isinstance(f, os.PathLike):
-        f = str(f)
-
-    if isinstance(f, str) and f.lower().endswith(".nc"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".nc":
         f = NetCdf(f, u2d.model, **kwargs)
 
-    if isinstance(f, str) and f.lower().endswith(".shp"):
+    if (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".shp":
         name = shapefile_utils.shape_attr_name(u2d.name, keep_layer=True)
         shapefile_utils.write_grid_shapefile(
             f, modelgrid, {name: u2d.array}, verbose=verbose
         )
         return
 
-    elif isinstance(f, str) and f.lower().endswith(".asc"):
-        export_array(modelgrid, f, u2d.array, verbose=verbose, **kwargs)
+    elif (isinstance(f, str) or isinstance(f, Path)) and Path(
+        f
+    ).suffix.lower() == ".asc":
+        export_array(modelgrid, f, u2d.array, **kwargs)
         return
 
     elif isinstance(f, NetCdf) or isinstance(f, dict):
@@ -1521,7 +1555,7 @@ def export_array(
     kwargs:
         keyword arguments to np.savetxt (ascii)
         rasterio.open (GeoTIFF)
-        or flopy.export.shapefile_utils.write_grid_shapefile2
+        or flopy.export.shapefile_utils.write_grid_shapefile
 
     Notes
     -----
@@ -1645,17 +1679,13 @@ def export_array(
     elif filename.lower().endswith(".shp"):
         from ..export.shapefile_utils import write_grid_shapefile
 
-        epsg = kwargs.get("epsg", None)
-        prj = kwargs.get("prj", None)
-        if epsg is None and prj is None:
-            epsg = modelgrid.epsg
+        crs = get_crs(**kwargs)
         write_grid_shapefile(
             filename,
             modelgrid,
             array_dict={fieldname: a},
             nan_val=nodata,
-            epsg=epsg,
-            prj=prj,
+            crs=crs,
         )
 
 
@@ -1663,9 +1693,6 @@ def export_contours(
     filename: Union[str, os.PathLike],
     contours,
     fieldname="level",
-    epsg=None,
-    prj: Optional[Union[str, os.PathLike]] = None,
-    verbose=False,
     **kwargs,
 ):
     """
@@ -1679,12 +1706,6 @@ def export_contours(
         (object returned by matplotlib.pyplot.contour)
     fieldname : str
         gis attribute table field name
-    epsg : int
-        EPSG code. See https://www.epsg-registry.org/ or spatialreference.org
-    prj : str or PathLike, optional, default None
-        Existing projection file to be used with new shapefile.
-    verbose : bool, optional, default False
-        whether to show verbose output
     **kwargs : key-word arguments to flopy.export.shapefile_utils.recarray2shp
 
     Returns
@@ -1710,19 +1731,12 @@ def export_contours(
     # convert the dictionary to a recarray
     ra = np.array(level, dtype=[(fieldname, float)]).view(np.recarray)
 
-    recarray2shp(
-        ra, geoms, filename, epsg=epsg, prj=prj, verbose=verbose, **kwargs
-    )
+    recarray2shp(ra, geoms, filename, **kwargs)
+    return
 
 
 def export_contourf(
-    filename: Union[str, os.PathLike],
-    contours,
-    fieldname="level",
-    epsg=None,
-    prj: Optional[Union[str, os.PathLike]] = None,
-    verbose=False,
-    **kwargs,
+    filename, contours, fieldname="level", verbose=False, **kwargs
 ):
     """
     Write matplotlib filled contours to shapefile.
@@ -1737,13 +1751,8 @@ def export_contourf(
         Name of shapefile attribute field to contain the contour level.  The
         fieldname column in the attribute table will contain the lower end of
         the range represented by the polygon.  Default is 'level'.
-    epsg : int
-        EPSG code. See https://www.epsg-registry.org/ or spatialreference.org
-    prj : str or PathLike, optional, default None
-        Existing projection file to be used with new shapefile.
     verbose : bool, optional, default False
         whether to show verbose output
-
     **kwargs : keyword arguments to flopy.export.shapefile_utils.recarray2shp
 
     Returns
@@ -1809,9 +1818,8 @@ def export_contourf(
     # Create recarray
     ra = np.array(level, dtype=[(fieldname, float)]).view(np.recarray)
 
-    recarray2shp(
-        ra, geoms, filename, epsg=epsg, prj=prj, verbose=verbose, **kwargs
-    )
+    recarray2shp(ra, geoms, filename, **kwargs)
+    return
 
 
 def export_array_contours(
@@ -1822,9 +1830,6 @@ def export_array_contours(
     interval=None,
     levels=None,
     maxlevels=1000,
-    epsg=None,
-    prj: Optional[Union[str, os.PathLike]] = None,
-    verbose=False,
     **kwargs,
 ):
     """
@@ -1846,22 +1851,11 @@ def export_array_contours(
         list of contour levels
     maxlevels : int
         maximum number of contour levels
-    epsg : int
-        EPSG code. See https://www.epsg-registry.org/ or spatialreference.org
-    prj : str or PathLike, optional, default None
-        Existing projection file to be used with new shapefile.
-    verbose : bool, optional, default False
-        whether to show verbose output
     **kwargs : keyword arguments to flopy.export.shapefile_utils.recarray2shp
 
     """
     import matplotlib.pyplot as plt
 
-    if epsg is None:
-        epsg = modelgrid.epsg
-    if prj is None:
-        prj = modelgrid.proj4
-
     if interval is not None:
         imin = np.nanmin(a)
         imax = np.nanmax(a)
@@ -1871,9 +1865,9 @@ def export_array_contours(
         levels = np.arange(imin, imax, interval)
     ax = plt.subplots()[-1]
     ctr = contour_array(modelgrid, ax, a, levels=levels)
-    export_contours(
-        filename, ctr, fieldname, epsg, prj, verbose=verbose, **kwargs
-    )
+
+    kwargs["modelgrid"] = modelgrid
+    export_contours(filename, ctr, fieldname, **kwargs)
     plt.close()
 
 
diff --git a/flopy/mbase.py b/flopy/mbase.py
index 9c88dbd46..ad82da304 100644
--- a/flopy/mbase.py
+++ b/flopy/mbase.py
@@ -129,7 +129,7 @@ def __init__(self):
     def update_modelgrid(self):
         if self._modelgrid is not None:
             self._modelgrid = Grid(
-                proj4=self._modelgrid.proj4,
+                crs=self._modelgrid.crs,
                 xoff=self._modelgrid.xoffset,
                 yoff=self._modelgrid.yoffset,
                 angrot=self._modelgrid.angrot,
@@ -354,7 +354,7 @@ class BaseModel(ModelInterface):
         the lower-left corner of the grid, ``xul``/``yul`` for the
         x- and y-coordinates of the upper-left corner of the grid
         (deprecated), ``rotation`` for the grid rotation (default 0.0),
-        ``proj4_str`` for a PROJ string, and ``start_datetime`` for
+        ``crs`` for the coordinate reference system, and ``start_datetime`` for
         model start date (default "1-1-1970").
 
     """
@@ -407,12 +407,12 @@ def __init__(
         self._yul = kwargs.pop("yul", None)
 
         self._rotation = kwargs.pop("rotation", 0.0)
-        self._proj4_str = kwargs.pop("proj4_str", None)
+        self._crs = kwargs.pop("crs", None)
         self._start_datetime = kwargs.pop("start_datetime", "1-1-1970")
 
         # build model discretization objects
         self._modelgrid = Grid(
-            proj4=self._proj4_str,
+            crs=self._crs,
             xoff=xll,
             yoff=yll,
             angrot=self._rotation,
diff --git a/flopy/mf6/mfmodel.py b/flopy/mf6/mfmodel.py
index 6a9581fd1..da02f90f4 100644
--- a/flopy/mf6/mfmodel.py
+++ b/flopy/mf6/mfmodel.py
@@ -122,11 +122,9 @@ def __init__(
         self._xul = kwargs.pop("xul", None)
         self._yul = kwargs.pop("yul", None)
         rotation = kwargs.pop("rotation", 0.0)
-        proj4 = kwargs.pop("proj4_str", None)
+        crs = kwargs.pop("crs", None)
         # build model grid object
-        self._modelgrid = Grid(
-            proj4=proj4, xoff=xll, yoff=yll, angrot=rotation
-        )
+        self._modelgrid = Grid(crs=crs, xoff=xll, yoff=yll, angrot=rotation)
 
         self.start_datetime = None
         # check for extraneous kwargs
@@ -348,8 +346,7 @@ def modelgrid(self):
                         botm=None,
                         idomain=None,
                         lenuni=None,
-                        proj4=self._modelgrid.proj4,
-                        epsg=self._modelgrid.epsg,
+                        crs=self._modelgrid.crs,
                         xoff=self._modelgrid.xoffset,
                         yoff=self._modelgrid.yoffset,
                         angrot=self._modelgrid.angrot,
@@ -362,8 +359,7 @@ def modelgrid(self):
                     botm=dis.botm.array,
                     idomain=dis.idomain.array,
                     lenuni=dis.length_units.array,
-                    proj4=self._modelgrid.proj4,
-                    epsg=self._modelgrid.epsg,
+                    crs=self._modelgrid.crs,
                     xoff=self._modelgrid.xoffset,
                     yoff=self._modelgrid.yoffset,
                     angrot=self._modelgrid.angrot,
@@ -383,8 +379,7 @@ def modelgrid(self):
                         botm=None,
                         idomain=None,
                         lenuni=None,
-                        proj4=self._modelgrid.proj4,
-                        epsg=self._modelgrid.epsg,
+                        crs=self._modelgrid.crs,
                         xoff=self._modelgrid.xoffset,
                         yoff=self._modelgrid.yoffset,
                         angrot=self._modelgrid.angrot,
@@ -397,8 +392,7 @@ def modelgrid(self):
                     botm=dis.botm.array,
                     idomain=dis.idomain.array,
                     lenuni=dis.length_units.array,
-                    proj4=self._modelgrid.proj4,
-                    epsg=self._modelgrid.epsg,
+                    crs=self._modelgrid.crs,
                     xoff=self._modelgrid.xoffset,
                     yoff=self._modelgrid.yoffset,
                     angrot=self._modelgrid.angrot,
@@ -458,8 +452,7 @@ def modelgrid(self):
                 idomain=idomain,
                 lenuni=dis.length_units.array,
                 ncpl=ncpl,
-                proj4=self._modelgrid.proj4,
-                epsg=self._modelgrid.epsg,
+                crs=self._modelgrid.crs,
                 xoff=self._modelgrid.xoffset,
                 yoff=self._modelgrid.yoffset,
                 angrot=self._modelgrid.angrot,
@@ -481,8 +474,7 @@ def modelgrid(self):
                         botm=None,
                         idomain=None,
                         lenuni=None,
-                        proj4=self._modelgrid.proj4,
-                        epsg=self._modelgrid.epsg,
+                        crs=self._modelgrid.crs,
                         xoff=self._modelgrid.xoffset,
                         yoff=self._modelgrid.yoffset,
                         angrot=self._modelgrid.angrot,
@@ -495,8 +487,7 @@ def modelgrid(self):
                     botm=dis.botm.array,
                     idomain=dis.idomain.array,
                     lenuni=dis.length_units.array,
-                    proj4=self._modelgrid.proj4,
-                    epsg=self._modelgrid.epsg,
+                    crs=self._modelgrid.crs,
                     xoff=self._modelgrid.xoffset,
                     yoff=self._modelgrid.yoffset,
                     angrot=self._modelgrid.angrot,
@@ -532,7 +523,10 @@ def modelgrid(self):
         if angrot is None:
             angrot = self._modelgrid.angrot
         self._modelgrid.set_coord_info(
-            xorig, yorig, angrot, self._modelgrid.epsg, self._modelgrid.proj4
+            xorig,
+            yorig,
+            angrot,
+            self._modelgrid.crs,
         )
         self._mg_resync = not self._modelgrid.is_complete
         return self._modelgrid
diff --git a/flopy/modflow/mf.py b/flopy/modflow/mf.py
index c61baf1ab..c7531c8a9 100644
--- a/flopy/modflow/mf.py
+++ b/flopy/modflow/mf.py
@@ -292,8 +292,7 @@ def modelgrid(self):
                 botm=self.disu.bot.array,
                 idomain=ibound,
                 lenuni=self.disu.lenuni,
-                proj4=self._modelgrid.proj4,
-                epsg=self._modelgrid.epsg,
+                crs=self._modelgrid.crs,
                 xoff=self._modelgrid.xoffset,
                 yoff=self._modelgrid.yoffset,
                 angrot=self._modelgrid.angrot,
@@ -313,8 +312,7 @@ def modelgrid(self):
                 self.dis.botm.array,
                 ibound,
                 self.dis.lenuni,
-                proj4=self._modelgrid.proj4,
-                epsg=self._modelgrid.epsg,
+                crs=self._modelgrid.crs,
                 xoff=self._modelgrid.xoffset,
                 yoff=self._modelgrid.yoffset,
                 angrot=self._modelgrid.angrot,
@@ -339,8 +337,7 @@ def modelgrid(self):
             xoff,
             yoff,
             self._modelgrid.angrot,
-            self._modelgrid.epsg,
-            self._modelgrid.proj4,
+            self._modelgrid.crs,
         )
         self._mg_resync = not self._modelgrid.is_complete
         return self._modelgrid
diff --git a/flopy/modflow/mfdis.py b/flopy/modflow/mfdis.py
index 88d361ddd..ce26bf709 100644
--- a/flopy/modflow/mfdis.py
+++ b/flopy/modflow/mfdis.py
@@ -13,6 +13,7 @@
 
 from ..pakbase import Package
 from ..utils import Util2d, Util3d
+from ..utils.crs import get_crs
 from ..utils.flopy_io import line_parse
 from ..utils.reference import TemporalReference
 
@@ -87,10 +88,15 @@ class ModflowDis(Package):
     rotation : float
         counter-clockwise rotation (in degrees) of the grid about the lower-
         left corner. default is 0.0
-    proj4_str : str
-        PROJ4 string that defines the projected coordinate system
-        (e.g. '+proj=utm +zone=14 +datum=WGS84 +units=m +no_defs ').
-        Can be an EPSG code (e.g. 'EPSG:32614'). Default is None.
+    crs : pyproj.CRS, optional if `prjfile` is specified
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+    prjfile : str or pathlike, optional if `crs` is specified
+        ESRI-style projection file with well-known text defining the CRS
+        for the model grid (must be projected; geographic CRS are not supported).
     start_datetime : str
         starting datetime of the simulation. default is '1/1/1970'
 
@@ -142,6 +148,8 @@ def __init__(
         yul=None,
         rotation=None,
         proj4_str=None,
+        crs=None,
+        prjfile=None,
         start_datetime=None,
     ):
         # set default unit number of one is not specified
@@ -240,8 +248,9 @@ def __init__(
             yul = model._yul
         if rotation is None:
             rotation = model._rotation
-        if proj4_str is None:
-            proj4_str = model._proj4_str
+        crs = get_crs(prjfile=prjfile, proj4=proj4_str, crs=crs)
+        if crs is None:
+            crs = model._crs
         if start_datetime is None:
             start_datetime = model._start_datetime
 
@@ -255,7 +264,7 @@ def __init__(
             xll = mg._xul_to_xll(xul)
         if yul is not None:
             yll = mg._yul_to_yll(yul)
-        mg.set_coord_info(xoff=xll, yoff=yll, angrot=rotation, proj4=proj4_str)
+        mg.set_coord_info(xoff=xll, yoff=yll, angrot=rotation, crs=crs)
 
         self.tr = TemporalReference(
             itmuni=self.itmuni, start_datetime=start_datetime
@@ -927,7 +936,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True):
             xul=xul,
             yul=yul,
             rotation=rotation,
-            proj4_str=proj4_str,
+            crs=proj4_str,
             start_datetime=start_datetime,
             unitnumber=unitnumber,
             filenames=filenames,
diff --git a/flopy/mt3d/mt.py b/flopy/mt3d/mt.py
index d9868d9c1..c3d82cdda 100644
--- a/flopy/mt3d/mt.py
+++ b/flopy/mt3d/mt.py
@@ -280,8 +280,7 @@ def modelgrid(self):
             top=top,
             botm=botm,
             idomain=ibound,
-            proj4=self._modelgrid.proj4,
-            epsg=self._modelgrid.epsg,
+            crs=self._modelgrid.crs,
             xoff=self._modelgrid.xoffset,
             yoff=self._modelgrid.yoffset,
             angrot=self._modelgrid.angrot,
@@ -313,12 +312,9 @@ def modelgrid(self):
                     yoff = self._modelgrid._yul_to_yll(self.mf._yul)
                 else:
                     yoff = 0.0
-        proj4 = self._modelgrid.proj4
-        if proj4 is None:
-            proj4 = self.mf._modelgrid.proj4
-        epsg = self._modelgrid.epsg
-        if epsg is None:
-            epsg = self.mf._modelgrid.epsg
+        crs = self._modelgrid.crs
+        if crs is None:
+            crs = self.mf._modelgrid.crs
         angrot = self._modelgrid.angrot
         if angrot is None or angrot == 0.0:  # angrot normally defaulted to 0.0
             if self.mf._modelgrid.angrot is not None:
@@ -326,7 +322,7 @@ def modelgrid(self):
             else:
                 angrot = 0.0
 
-        self._modelgrid.set_coord_info(xoff, yoff, angrot, epsg, proj4)
+        self._modelgrid.set_coord_info(xoff, yoff, angrot, crs=crs)
         self._mg_resync = not self._modelgrid.is_complete
         return self._modelgrid
 
diff --git a/flopy/seawat/swt.py b/flopy/seawat/swt.py
index f895906a4..689ff5af0 100644
--- a/flopy/seawat/swt.py
+++ b/flopy/seawat/swt.py
@@ -202,8 +202,7 @@ def modelgrid(self):
             self.dis.botm.array,
             idomain=ibound,
             lenuni=self.dis.lenuni,
-            proj4=self._modelgrid.proj4,
-            epsg=self._modelgrid.epsg,
+            crs=self._modelgrid.crs,
             xoff=self._modelgrid.xoffset,
             yoff=self._modelgrid.yoffset,
             angrot=self._modelgrid.angrot,
@@ -227,8 +226,7 @@ def modelgrid(self):
             xoff,
             yoff,
             self._modelgrid.angrot,
-            self._modelgrid.epsg,
-            self._modelgrid.proj4,
+            self._modelgrid.crs,
         )
         self._mg_resync = not self._modelgrid.is_complete
         return self._modelgrid
diff --git a/flopy/utils/crs.py b/flopy/utils/crs.py
new file mode 100644
index 000000000..a41dcaa14
--- /dev/null
+++ b/flopy/utils/crs.py
@@ -0,0 +1,151 @@
+"""Utilities related to coordinate reference system handling.
+"""
+import warnings
+from pathlib import Path
+
+from ..utils import import_optional_dependency
+
+
+def get_authority_crs(crs):
+    """Try to get the authority representation for a
+    coordinate reference system (CRS), for more robust
+    comparison with other CRS objects.
+
+    Parameters
+    ----------
+    crs : pyproj.CRS
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+
+    Returns
+    -------
+    authority_crs : pyproj.CRS instance
+        CRS instance initiallized with the name
+        and authority code (e.g. epsg: 5070) produced by
+        :meth:`pyproj.crs.CRS.to_authority`
+
+    Notes
+    -----
+    :meth:`pyproj.crs.CRS.to_authority` will return None if a matching
+    authority name and code can't be found. In this case,
+    the input crs instance will be returned.
+
+    References
+    ----------
+    http://pyproj4.github.io/pyproj/stable/api/crs/crs.html
+
+    """
+    pyproj = import_optional_dependency("pyproj")
+    if crs is not None:
+        crs = pyproj.crs.CRS.from_user_input(crs)
+        authority = crs.to_authority()
+        if authority is not None:
+            return pyproj.CRS.from_user_input(authority)
+        return crs
+
+
+def get_shapefile_crs(shapefile):
+    """Get the coordinate reference system for a shapefile.
+
+    Parameters
+    ----------
+    shapefile : str or pathlike
+        Path to a shapefile or an associated
+        projection (.prj) file.
+
+    Returns
+    -------
+    crs : pyproj.CRS instance
+
+    """
+    pyproj = import_optional_dependency("pyproj")
+    shapefile = Path(shapefile)
+    prjfile = shapefile.with_suffix(".prj")
+    if prjfile.exists():
+        with open(prjfile, encoding="utf-8") as src:
+            wkt = src.read()
+            crs = pyproj.crs.CRS.from_wkt(wkt)
+            return get_authority_crs(crs)
+
+
+def get_crs(prjfile=None, crs=None, **kwargs):
+    """Helper function to produce a pyproj.CRS object from
+    various input. Longer-term, this would just handle the ``crs``
+    and ``prjfile`` arguments, but in the near term, we need to
+    warn users about deprecating the ``prj``, ``epsg``, ``proj4``
+    and ``wkt_string`` inputs.
+
+    Parameters
+    ----------
+    prjfile : str or pathlike, optional
+        _description_, by default None
+    prj : str or pathlike, optional
+        .. deprecated:: 3.4
+        use ``prjfile`` instead.
+    epsg : int, optional
+        .. deprecated:: 3.4
+        use ``crs`` instead.
+    proj4 : str, optional
+        .. deprecated:: 3.4
+        use ``crs`` instead.
+    crs : pyproj.CRS, optional if `prjfile` is specified
+        Coordinate reference system (CRS) for the model grid
+        (must be projected; geographic CRS are not supported).
+        The value can be anything accepted by
+        :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
+        such as an authority string (eg "EPSG:26916") or a WKT string.
+    wkt_string : str, optional
+        .. deprecated:: 3.4
+        use ``crs`` instead.
+
+    Returns
+    -------
+    crs : pyproj.CRS instance
+
+    """
+    if crs is not None:
+        crs = get_authority_crs(crs)
+    if kwargs.get("prj") is not None:
+        warnings.warn(
+            "the prj argument will be deprecated and will be removed in version "
+            "3.4. Use prjfile instead.",
+            PendingDeprecationWarning,
+        )
+        prjfile = kwargs.get("prj")
+    if kwargs.get("epsg") is not None:
+        warnings.warn(
+            "the epsg argument will be deprecated and will be removed in version "
+            "3.4. Use crs instead.",
+            PendingDeprecationWarning,
+        )
+        if crs is None:
+            crs = get_authority_crs(kwargs.get("epsg"))
+    elif prjfile is not None:
+        prjfile_crs = get_shapefile_crs(prjfile)
+        if (crs is not None) and (crs != prjfile_crs):
+            raise ValueError(
+                "Different coordinate reference systems "
+                f"in crs argument and supplied projection file: {prjfile}\n"
+                f"\nuser supplied crs: {crs}  !=\ncrs from projection file: {prjfile_crs}"
+            )
+        else:
+            crs = prjfile_crs
+    elif kwargs.get("proj4") is not None:
+        warnings.warn(
+            "the proj4 argument will be deprecated and will be removed in version "
+            "3.4. Use crs instead.",
+            PendingDeprecationWarning,
+        )
+        if crs is None:
+            crs = get_authority_crs(kwargs.get("proj4"))
+    elif kwargs.get("wkt_string") is not None:
+        if crs is None:
+            crs = get_authority_crs(kwargs.get("wkt_string"))
+    if crs is not None and not crs.is_projected:
+        raise ValueError(
+            f"Only projected coordinate reference systems are supported.\n{crs}"
+        )
+    return crs
diff --git a/flopy/utils/mfreadnam.py b/flopy/utils/mfreadnam.py
index 27c34963b..be900cde2 100644
--- a/flopy/utils/mfreadnam.py
+++ b/flopy/utils/mfreadnam.py
@@ -212,6 +212,7 @@ def attribs_from_namfile_header(namefile):
         "xul": None,
         "yul": None,
         "rotation": 0.0,
+        "crs": None,
         "proj4_str": None,
     }
     if namefile is None:
@@ -259,7 +260,15 @@ def attribs_from_namfile_header(namefile):
                 proj4 = ":".join(item.split(":")[1:]).strip()
                 if proj4.lower() == "none":
                     proj4 = None
-                defaults["proj4_str"] = proj4
+                defaults["crs"] = proj4
+            except:
+                print(f"   could not parse proj4_str in {namefile}")
+        elif "crs" in item.lower():
+            try:
+                crs = ":".join(item.split(":")[1:]).strip()
+                if crs.lower() == "none":
+                    proj4 = None
+                defaults["crs"] = crs
             except:
                 print(f"   could not parse proj4_str in {namefile}")
         elif "start" in item.lower():