diff --git a/.github/workflows/dependencies/gcc.sh b/.github/workflows/dependencies/gcc.sh
index b658a65b1..2573d9300 100755
--- a/.github/workflows/dependencies/gcc.sh
+++ b/.github/workflows/dependencies/gcc.sh
@@ -22,4 +22,6 @@ sudo apt-get install -y \
     wget
 
 python3 -m pip install -U pip setuptools wheel
+python3 -m pip install -U cmake pytest
 python3 -m pip install -r requirements.txt
+python3 -m pip install -r examples/requirements.txt
diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml
index ff4bb2d66..0e8d7d625 100644
--- a/.github/workflows/ubuntu.yml
+++ b/.github/workflows/ubuntu.yml
@@ -52,3 +52,46 @@ jobs:
         { cat Backtrace.0.0; exit 1; }
         build/bin/impactx examples/fodo/input_fodo.in algo.particle_shape = 3 || \
         { cat Backtrace.0.0; exit 1; }
+
+  build_gcc_python:
+    name: GCC w/o MPI w/ Python
+    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    env:
+      CMAKE_GENERATOR: Ninja
+      CXXFLAGS: "-Werror"
+      OMP_NUM_THREADS: 2
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: install dependencies
+      run: |
+        .github/workflows/dependencies/gcc.sh
+
+    - name: CCache Cache
+      uses: actions/cache@v2
+      # - once stored under a key, they become immutable (even if local cache path content changes)
+      # - for a refresh the key has to change, e.g., hash of a tracked file in the key
+      with:
+        path: |
+          ~/.ccache
+          ~/.cache/ccache
+        key: ccache-openmp-pygcc-${{ hashFiles('.github/workflows/ubuntu.yml') }}-${{ hashFiles('cmake/dependencies/ABLASTR.cmake') }}
+        restore-keys: |
+          ccache-openmp-pygcc-${{ hashFiles('.github/workflows/ubuntu.yml') }}-
+          ccache-openmp-pygcc-
+
+    - name: build ImpactX
+      run: |
+        cmake -S . -B build            \
+          -DCMAKE_BUILD_TYPE=Debug     \
+          -DCMAKE_VERBOSE_MAKEFILE=ON  \
+          -DImpactX_APP=OFF            \
+          -DImpactX_MPI=OFF            \
+          -DImpactX_PYTHON=ON
+        cmake --build build -j 2
+        cmake --build build --target pip_install
+
+    - name: run ImpactX
+      run: |
+        ctest --test-dir build --output-on-failure
diff --git a/.gitignore b/.gitignore
index 643e35c1a..7e8820fd6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,6 +13,7 @@ chk*
 ##########
 # Python #
 ##########
+_tmppythonbuild/
 *.pyc
 __pycache__
 dist/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7279b7045..b2e53aa44 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -44,19 +44,20 @@ set_ccache()
 # Output Directories ##########################################################
 #
 # temporary build directories
-set_default_build_dirs()
+impactx_set_default_build_dirs()
 
-# install directories
-set_default_install_dirs()
+# default installation directories (w/o Python)
+impactx_set_default_install_dirs()
 
 
 # Options and Variants ########################################################
 #
 include(CMakeDependentOption)
 option(ImpactX_APP           "Build the ImpactX executable application"     ON)
-option(ImpactX_LIB           "Build ImpactX as a shared library"            OFF)
+option(ImpactX_LIB           "Build ImpactX as a library"                   OFF)
 option(ImpactX_MPI           "Multi-node support (message-passing)"         ON)
 option(ImpactX_OPENPMD       "openPMD I/O (HDF5, ADIOS)"                    OFF)
+option(ImpactX_PYTHON        "Python bindings"                              OFF)
 
 set(ImpactX_PRECISION_VALUES SINGLE DOUBLE)
 set(ImpactX_PRECISION DOUBLE CACHE STRING "Floating point precision (SINGLE/DOUBLE)")
@@ -77,6 +78,10 @@ mark_as_advanced(ImpactX_MPI_THREAD_MULTIPLE)
 
 option(ImpactX_ablastr_internal                  "Download & build ABLASTR" ON)
 option(ImpactX_amrex_internal                    "Download & build AMReX" ON)
+option(ImpactX_pyamrex_internal                  "Download & build pyAMReX" ON)
+
+set(pyImpactX_VERSION_INFO "" CACHE STRING
+    "PEP-440 conformant version (set by distutils)")
 
 # change the default build type to Release (or RelWithDebInfo) instead of Debug
 set_default_build_type("Release")
@@ -99,9 +104,28 @@ include(CTest)
 include(${ImpactX_SOURCE_DIR}/cmake/dependencies/ABLASTR.cmake)
 impactx_make_third_party_includes_system(WarpX::ablastr ablastr)
 
+# Python
+if(ImpactX_PYTHON)
+    find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+
+    # default installation directories: Python
+    impactx_set_default_install_dirs_python()
+
+    # pybind11
+    #   builds pybind11 from git (default), form local source or
+    #   finds an existing install
+    include(${ImpactX_SOURCE_DIR}/cmake/dependencies/pybind11.cmake)
+
+    # pyAMReX
+    include(${ImpactX_SOURCE_DIR}/cmake/dependencies/pyAMReX.cmake)
+endif()
+
 
 # Targets #####################################################################
 #
+if(ImpactX_PYTHON)
+    set(ImpactX_LIB ON CACHE STRING "library" FORCE)
+endif()
 if(NOT ImpactX_APP AND NOT ImpactX_LIB)
     message(FATAL_ERROR "Need to build at least ImpactX app or "
                         "library/Python bindings")
@@ -122,20 +146,56 @@ if(ImpactX_APP)
     list(APPEND _ALL_TARGETS app)
 endif()
 
-# link into a shared library
+# link into a library (shared or static)
 if(ImpactX_LIB)
-    add_library(shared MODULE)
-    add_library(ImpactX::shared ALIAS shared)
-    target_link_libraries(shared PUBLIC ImpactX)
-    set(_BUILDINFO_SRC shared)
-    list(APPEND _ALL_TARGETS shared)
+    add_library(lib)
+    add_library(ImpactX::lib ALIAS lib)
+    target_link_libraries(lib PUBLIC ImpactX)
+    set(_BUILDINFO_SRC lib)
+    list(APPEND _ALL_TARGETS lib)
 
-    set_target_properties(ImpactX shared PROPERTIES
+    set_target_properties(ImpactX lib PROPERTIES
         POSITION_INDEPENDENT_CODE ON
         WINDOWS_EXPORT_ALL_SYMBOLS ON
     )
 endif()
 
+# build Python module (this is always a shared library)
+if(ImpactX_PYTHON)
+    add_library(pyImpactX MODULE src/python/pyImpactX.cpp)
+    add_library(ImpactX::pyImpactX ALIAS pyImpactX)
+    target_link_libraries(pyImpactX PUBLIC lib)
+    set(_BUILDINFO_SRC pyImpactX)
+    list(APPEND _ALL_TARGETS pyImpactX)
+
+    # set Python module properties
+    set_target_properties(pyImpactX PROPERTIES
+        # hide symbols for combining multiple pybind11 modules downstream & for
+        # reduced binary size
+        CXX_VISIBILITY_PRESET "hidden"
+        CUDA_VISIBILITY_PRESET "hidden"
+        # name of the pybind-generated python module, which is wrapped in another
+        # fluffy front-end modules, so we can extend it with pure Python
+        ARCHIVE_OUTPUT_NAME impactx_pybind
+        LIBRARY_OUTPUT_NAME impactx_pybind
+        # build output directories - mainly set to run tests from CMake & IDEs
+        ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_PYTHON_OUTPUT_DIRECTORY}/impactx
+        LIBRARY_OUTPUT_DIRECTORY ${CMAKE_PYTHON_OUTPUT_DIRECTORY}/impactx
+        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_PYTHON_OUTPUT_DIRECTORY}/impactx
+        PDB_OUTPUT_DIRECTORY ${CMAKE_PYTHON_OUTPUT_DIRECTORY}/impactx
+        COMPILE_PDB_OUTPUT_DIRECTORY ${CMAKE_PYTHON_OUTPUT_DIRECTORY}/impactx
+    )
+    if(EMSCRIPTEN)
+        set_target_properties(pyImpactX PROPERTIES
+            PREFIX "")
+    else()
+        pybind11_extension(pyImpactX)
+    endif()
+    if(NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug|RelWithDebInfo)
+        pybind11_strip(pyImpactX)
+    endif()
+endif()
+
 # own headers
 target_include_directories(ImpactX PUBLIC
     $<BUILD_INTERFACE:${ImpactX_SOURCE_DIR}/src>
@@ -168,6 +228,9 @@ endif()
 # link dependencies
 #     note: only PUBLIC because ImpactX is an OBJECT collection
 target_link_libraries(ImpactX PUBLIC ImpactX::thirdparty::ablastr)
+if(ImpactX_PYTHON)
+    target_link_libraries(pyImpactX PRIVATE pybind11::module pybind11::lto pybind11::windows_extras)
+endif()
 
 if(ImpactX_OPENPMD)
     target_compile_definitions(ImpactX PUBLIC ImpactX_USE_OPENPMD)
@@ -199,7 +262,7 @@ if(ImpactX_COMPUTE STREQUAL CUDA)
 endif()
 
 # fancy binary name for build variants
-set_ImpactX_binary_name()
+impactx_set_binary_name()
 
 
 # Defines #####################################################################
@@ -207,6 +270,11 @@ set_ImpactX_binary_name()
 if(ImpactX_OPENPMD)
     target_compile_definitions(ImpactX PUBLIC ImpactX_USE_OPENPMD)
 endif()
+if(ImpactX_PYTHON)
+    # for module __version__
+    target_compile_definitions(pyImpactX PRIVATE
+        PYIMPACTX_VERSION_INFO=${pyImpactX_VERSION_INFO})
+endif()
 
 
 # Warnings ####################################################################
@@ -235,13 +303,17 @@ configure_file(
 
 # Installs ####################################################################
 #
+
 # headers, libraries and executables
 set(ImpactX_INSTALL_TARGET_NAMES)
 if(ImpactX_APP)
     list(APPEND ImpactX_INSTALL_TARGET_NAMES app)
 endif()
 if(ImpactX_LIB)
-    list(APPEND ImpactX_INSTALL_TARGET_NAMES shared)
+    list(APPEND ImpactX_INSTALL_TARGET_NAMES lib)
+endif()
+if(ImpactX_PYTHON)
+    list(APPEND ImpactX_INSTALL_TARGET_NAMES pyImpactX)
 endif()
 
 install(TARGETS ${ImpactX_INSTALL_TARGET_NAMES}
@@ -266,7 +338,7 @@ if(ImpactX_LIB)
         set(ABS_INSTALL_LIB_DIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
     endif()
     install(CODE "file(CREATE_LINK
-        $<TARGET_FILE_NAME:shared>
+        $<TARGET_FILE_NAME:lib>
         ${ABS_INSTALL_LIB_DIR}/libImpactX.${mod_ext}
         COPY_ON_ERROR SYMBOLIC)")
 endif()
@@ -275,26 +347,96 @@ endif()
 #install(EXPORT ImpactXTargets
 #    FILE ImpactXTargets.cmake
 #    NAMESPACE ImpactX::
-#    DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+#    DESTINATION ${ImpactX_INSTALL_CMAKEDIR}
 #)
 #install(
 #    FILES
 #        ${ImpactX_BINARY_DIR}/ImpactXConfig.cmake
 #        ${ImpactX_BINARY_DIR}/ImpactXConfigVersion.cmake
-#    DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+#    DESTINATION ${ImpactX_INSTALL_CMAKEDIR}
 #)
 
 
+# pip helpers for the impactx package #########################################
+#
+if(ImpactX_PYTHON)
+    set(PYINSTALLOPTIONS "" CACHE STRING
+        "Additional parameters to pass to `pip install`")
+
+    # add a prefix to custom targets so we do not collide if used as a subproject
+    if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+        set(_ImpactX_CUSTOM_TARGET_PREFIX_DEFAULT "")
+    else()
+        set(_ImpactX_CUSTOM_TARGET_PREFIX_DEFAULT "impactx_")
+    endif()
+    set(ImpactX_CUSTOM_TARGET_PREFIX "${_ImpactX_CUSTOM_TARGET_PREFIX_DEFAULT}"
+        CACHE STRING "Prefix for custom targets")
+
+    # build the wheel by re-using the lib library we build
+    add_custom_target(${ImpactX_CUSTOM_TARGET_PREFIX}pip_wheel
+        ${CMAKE_COMMAND} -E rm -f "impactx*.whl"
+        COMMAND
+            ${CMAKE_COMMAND} -E env PYIMPACTX_LIBDIR=$<TARGET_FILE_DIR:pyImpactX>
+                ${Python_EXECUTABLE} -m pip wheel -v --no-build-isolation ${ImpactX_SOURCE_DIR}
+        WORKING_DIRECTORY
+            ${ImpactX_BINARY_DIR}
+        DEPENDS
+            pyImpactX
+    )
+
+    # this will also upgrade/downgrade dependencies, e.g., when the version of numpy changes
+    add_custom_target(${ImpactX_CUSTOM_TARGET_PREFIX}pip_install_requirements
+        ${Python_EXECUTABLE} -m pip install ${PYINSTALLOPTIONS} -r "${ImpactX_SOURCE_DIR}/requirements.txt"
+        WORKING_DIRECTORY
+            ${ImpactX_BINARY_DIR}
+    )
+
+    # if we do a superbuild, make sure we install pyAMReX via its custom install
+    # target
+    set(_EXTRA_INSTALL_DEPENDS)
+    if(ImpactX_pyamrex_internal OR ImpactX_pyamrex_src)
+        set(_EXTRA_INSTALL_DEPENDS pyamrex_pip_install)
+    endif()
+
+    # We force-install because in development, it is likely that the version of
+    # the package does not change, but the code did change. We need --no-deps,
+    # because otherwise pip would also force reinstall all dependencies.
+    add_custom_target(${ImpactX_CUSTOM_TARGET_PREFIX}pip_install
+        ${CMAKE_COMMAND} -E env IMPACTX_MPI=${ImpactX_MPI}
+            ${Python_EXECUTABLE} -m pip install --force-reinstall --no-deps ${PYINSTALLOPTIONS} "impactx*.whl"
+        WORKING_DIRECTORY
+            ${ImpactX_BINARY_DIR}
+        DEPENDS
+            pyImpactX
+            ${ImpactX_CUSTOM_TARGET_PREFIX}pip_wheel ${ImpactX_CUSTOM_TARGET_PREFIX}pip_install_requirements
+            ${_EXTRA_INSTALL_DEPENDS}
+    )
+endif()
+
+
 # Tests #######################################################################
 #
 if(BUILD_TESTING)
     enable_testing()
 
     # examples
-    add_subdirectory(examples)
+    if(ImpactX_APP)
+        add_subdirectory(examples)
+    endif()
+
+    # unit tests
+    if(ImpactX_PYTHON)
+        # copy Python wrapper library to build directory
+        add_custom_command(TARGET pyImpactX POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_directory
+                ${ImpactX_SOURCE_DIR}/src/python/impactx
+                $<TARGET_FILE_DIR:pyImpactX>
+        )
+    endif()
+    add_subdirectory(tests)
 endif()
 
 
 # Status Summary for Build Options ############################################
 #
-ImpactX_print_summary()
+impactx_print_summary()
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 000000000..8ea37b3b7
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,18 @@
+include README.md LICENSE
+include CODE_OF_CONDUCT.rst CONTRIBUTING.rst
+include pyproject.toml
+include requirements.txt
+
+global-include CMakeLists.txt *.cmake *.in
+
+recursive-include cmake *
+recursive-include docs *
+recursive-include etc *
+recursive-include examples *
+recursive-include include *
+recursive-include src *
+recursive-include tests *
+
+# see .gitignore
+prune cmake-build*
+prune .spack-env*
diff --git a/README.md b/README.md
index 6f0211f39..a1918ce2f 100644
--- a/README.md
+++ b/README.md
@@ -238,6 +238,16 @@ or by adding arguments with `-D<OPTION>=<VALUE>` to the first CMake call, e.g.:
 cmake -S . -B build -DImpactX_COMPUTE=CUDA -DImpactX_MPI=OFF
 ```
 
+### Python Compile
+
+```bash
+# find dependencies & configure
+cmake -S . -B build -DImpactX_PYTHON=ON
+
+# compile & install
+cmake --build build -j 4 --target pip_install
+```
+
 ## Run
 
 An executable ImpactX binary with the current compile-time options encoded in its file name will be created in `build/bin/`.
@@ -284,6 +294,7 @@ In order to run our tests, you need to have a few Python packages installed:
 ```console
 python3 -m pip install -U pip setuptools wheel
 python3 -m pip install -r requirements.txt
+python3 -m pip install -r examples/requirements.txt
 ```
 
 You can run all our tests with:
diff --git a/cmake/ImpactXFunctions.cmake b/cmake/ImpactXFunctions.cmake
index 8e5ba5204..9c2122100 100644
--- a/cmake/ImpactXFunctions.cmake
+++ b/cmake/ImpactXFunctions.cmake
@@ -47,7 +47,7 @@ endmacro()
 # the defaults in CMake are sub-ideal for historic reasons, lets make them more
 # Unix-ish and portable.
 #
-macro(set_default_build_dirs)
+macro(impactx_set_default_build_dirs)
     if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
         set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
                 CACHE PATH "Build directory for archives")
@@ -63,6 +63,12 @@ macro(set_default_build_dirs)
                 CACHE PATH "Build directory for binaries")
         mark_as_advanced(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
     endif()
+    if(NOT CMAKE_PYTHON_OUTPUT_DIRECTORY)
+        set(CMAKE_PYTHON_OUTPUT_DIRECTORY
+            "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/site-packages"
+            CACHE PATH "Build directory for python modules"
+        )
+    endif()
 endmacro()
 
 
@@ -70,11 +76,11 @@ endmacro()
 # the defaults in CMake are sub-ideal for historic reasons, lets make them more
 # Unix-ish and portable.
 #
-macro(set_default_install_dirs)
+macro(impactx_set_default_install_dirs)
     if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
         include(GNUInstallDirs)
         if(NOT CMAKE_INSTALL_CMAKEDIR)
-            set(CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/ImpactX"
+            set(CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake"
                     CACHE PATH "CMake config package location for installed targets")
             if(WIN32)
                 set(CMAKE_INSTALL_LIBDIR Lib
@@ -84,6 +90,37 @@ macro(set_default_install_dirs)
             mark_as_advanced(CMAKE_INSTALL_CMAKEDIR)
         endif()
     endif()
+
+    if(WIN32)
+        set(ImpactX_INSTALL_CMAKEDIR "${CMAKE_INSTALL_CMAKEDIR}")
+    else()
+        set(ImpactX_INSTALL_CMAKEDIR "${CMAKE_INSTALL_CMAKEDIR}/ImpactX")
+    endif()
+endmacro()
+
+
+# set names and paths for Python modules
+# this needs to be slightly delayed until we found Python and know its
+# major and minor version number
+#
+macro(impactx_set_default_install_dirs_python)
+    if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+        # Python install and build output dirs
+        if(NOT CMAKE_INSTALL_PYTHONDIR)
+            if(WIN32)
+                set(CMAKE_INSTALL_PYTHONDIR_DEFAULT
+                    "${CMAKE_INSTALL_LIBDIR}/site-packages"
+                )
+            else()
+                set(CMAKE_INSTALL_PYTHONDIR_DEFAULT
+                    "${CMAKE_INSTALL_LIBDIR}/python${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}/site-packages"
+                )
+            endif()
+            set(CMAKE_INSTALL_PYTHONDIR "${CMAKE_INSTALL_PYTHONDIR_DEFAULT}"
+                CACHE STRING "Location for installed python package"
+            )
+        endif()
+    endif()
 endmacro()
 
 
@@ -180,7 +217,7 @@ endfunction()
 # Set a feature-based binary name for the ImpactX executable and create a generic
 # ImpactX symlink to it. Only sets options relevant for users (see summary).
 #
-function(set_ImpactX_binary_name)
+function(impactx_set_binary_name)
     set(ImpactX_bin_names)
     if(ImpactX_APP)
         list(APPEND ImpactX_bin_names app)
@@ -237,10 +274,10 @@ function(set_ImpactX_binary_name)
         else()
             set(mod_ext "so")
         endif()
-        add_custom_command(TARGET shared POST_BUILD
+        add_custom_command(TARGET lib POST_BUILD
             COMMAND ${CMAKE_COMMAND} -E create_symlink
-                $<TARGET_FILE_NAME:shared>
-                $<TARGET_FILE_DIR:shared>/libimpactx.${mod_ext}
+                $<TARGET_FILE_NAME:lib>
+                $<TARGET_FILE_DIR:lib>/libimpactx.${mod_ext}
         )
     endif()
 endfunction()
@@ -301,7 +338,7 @@ endfunction ()
 
 # Prints a summary of ImpactX options at the end of the CMake configuration
 #
-function(ImpactX_print_summary)
+function(impactx_print_summary)
     message("")
     message("ImpactX build configuration:")
     message("  Version: ${ImpactX_VERSION} (${ImpactX_GIT_VERSION})")
@@ -314,8 +351,8 @@ function(ImpactX_print_summary)
     message("        bin: ${CMAKE_INSTALL_BINDIR}")
     message("        lib: ${CMAKE_INSTALL_LIBDIR}")
     message("    include: ${CMAKE_INSTALL_INCLUDEDIR}")
-    message("      cmake: ${CMAKE_INSTALL_CMAKEDIR}")
-    if(ImpactX_HAVE_PYTHON)
+    message("      cmake: ${ImpactX_INSTALL_CMAKEDIR}")
+    if(ImpactX_PYTHON)
         message("     python: ${CMAKE_INSTALL_PYTHONDIR}")
     endif()
     message("")
@@ -345,6 +382,7 @@ function(ImpactX_print_summary)
         message("    MPI (thread multiple): ${ImpactX_MPI_THREAD_MULTIPLE}")
     endif()
     message("    PRECISION: ${ImpactX_PRECISION}")
+    message("    PYTHON: ${ImpactX_PYTHON}")
     message("    OPENPMD: ${ImpactX_OPENPMD}")
     #message("    SENSEI: ${ImpactX_SENSEI}")
     message("")
diff --git a/cmake/dependencies/ABLASTR.cmake b/cmake/dependencies/ABLASTR.cmake
index f3570ae45..619198fc7 100644
--- a/cmake/dependencies/ABLASTR.cmake
+++ b/cmake/dependencies/ABLASTR.cmake
@@ -40,9 +40,24 @@ macro(find_ablastr)
         set(WarpX_COMPUTE ${ImpactX_COMPUTE} CACHE INTERNAL "" FORCE)
         set(WarpX_OPENPMD ${ImpactX_OPENPMD} CACHE INTERNAL "" FORCE)
         set(WarpX_PRECISION ${ImpactX_PRECISION} CACHE INTERNAL "" FORCE)
+        set(WarpX_MPI ${ImpactX_MPI} CACHE INTERNAL "" FORCE)
         set(WarpX_MPI_THREAD_MULTIPLE ${ImpactX_MPI_THREAD_MULTIPLE} CACHE INTERNAL "" FORCE)
         set(WarpX_IPO ${ImpactX_IPO} CACHE INTERNAL "" FORCE)
 
+        # shared libs, i.e. for Python bindings, need relocatable code
+        if(ImpactX_PYTHON OR (ImpactX_LIB AND BUILD_SHARED_LIBS))
+            set(AMReX_PIC ON CACHE INTERNAL
+                "Build AMReX with position independent code")
+            set(ABLASTR_POSITION_INDEPENDENT_CODE ON CACHE INTERNAL
+                "Build ABLASTR with position independent code")
+
+            # WE NEED AMReX AS SHARED LIB, OTHERWISE WE CANNOT SHARE ITS GLOBALS
+            # BETWEEN MULTIPLE PYTHON MODULES
+            # TODO this is likely an export/symbol hiding issue that we could
+            #      alleviate later on
+            set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
+        endif()
+
         if(ImpactX_ablastr_src)
             #list(APPEND CMAKE_MODULE_PATH "${WarpX_amrex_src}/Tools/CMake")
             if(ImpactX_COMPUTE STREQUAL CUDA)
@@ -98,6 +113,7 @@ macro(find_ablastr)
     else()
         message(STATUS "Searching for pre-installed ABLASTR ...")
         message(FATAL_ERROR "Not yet supported!")
+        # TODO: MPI control
         set(COMPONENT_DIM 3D)
         set(COMPONENT_PRECISION ${ImpactX_PRECISION} P${ImpactX_PRECISION})
 
diff --git a/cmake/dependencies/pyAMReX.cmake b/cmake/dependencies/pyAMReX.cmake
new file mode 100644
index 000000000..bf5a176eb
--- /dev/null
+++ b/cmake/dependencies/pyAMReX.cmake
@@ -0,0 +1,83 @@
+function(find_pyamrex)
+    if(ImpactX_pyamrex_src)
+        message(STATUS "Compiling local pyAMReX ...")
+        message(STATUS "pyAMReX source path: ${ImpactX_pyamrex_src}")
+    elseif(ImpactX_pyamrex_internal)
+        message(STATUS "Downloading pyAMReX ...")
+        message(STATUS "pyAMReX repository: ${ImpactX_pyamrex_repo} (${ImpactX_pyamrex_branch})")
+        include(FetchContent)
+    endif()
+
+    # transitive control for AMReX & pybind11 superbuild
+    #   note: if we do superbuilds, we want the same AMReX commit for
+    #           AMReX->ABLASTR->ImpactX and
+    #           AMReX->pyAMReX->pyImpactX
+    #   note: this is performed after we did the transitive logic control in
+    #         ABLASTR.cmake
+    set(pyAMReX_amrex_internal ${ImpactX_amrex_internal} CACHE BOOL
+        "Download & build AMReX" FORCE)
+    set(pyAMReX_pybind11_internal ${ImpactX_pybind11_internal} CACHE BOOL
+        "Download & build AMReX" FORCE)
+
+    if(ImpactX_amrex_src)
+        set(pyAMReX_amrex_src ${ImpactX_amrex_src} CACHE PATH
+            "Local path to AMReX source directory (preferred if set)" FORCE)
+    elseif(ImpactX_amrex_internal)
+        if(ImpactX_amrex_repo)
+            set(pyAMReX_amrex_repo ${ImpactX_amrex_repo} CACHE STRING
+                "Repository URI to pull and build AMReX from if(ImpactX_amrex_internal)" FORCE)
+        endif()
+        if(ImpactX_amrex_branch)
+            set(pyAMReX_amrex_branch ${ImpactX_amrex_branch} CACHE STRING
+                "Repository branch for ImpactX_amrex_repo if(ImpactX_amrex_internal)" FORCE)
+        endif()
+    endif()
+
+    if(ImpactX_pyamrex_internal OR ImpactX_pyamrex_src)
+        set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+
+        if(ImpactX_pyamrex_src)
+            add_subdirectory(${ImpactX_pyamrex_src} _deps/localpyamrex-build/)
+        else()
+            FetchContent_Declare(fetchedpyamrex
+                GIT_REPOSITORY ${ImpactX_pyamrex_repo}
+                GIT_TAG        ${ImpactX_pyamrex_branch}
+                BUILD_IN_SOURCE 0
+            )
+            FetchContent_GetProperties(fetchedpyamrex)
+
+            if(NOT fetchedpyamrex_POPULATED)
+                FetchContent_Populate(fetchedpyamrex)
+                add_subdirectory(${fetchedpyamrex_SOURCE_DIR} ${fetchedpyamrex_BINARY_DIR})
+            endif()
+
+            # advanced fetch options
+            mark_as_advanced(FETCHCONTENT_BASE_DIR)
+            mark_as_advanced(FETCHCONTENT_FULLY_DISCONNECTED)
+            mark_as_advanced(FETCHCONTENT_QUIET)
+            mark_as_advanced(FETCHCONTENT_SOURCE_DIR_FETCHEDpyamrex)
+            mark_as_advanced(FETCHCONTENT_UPDATES_DISCONNECTED)
+            mark_as_advanced(FETCHCONTENT_UPDATES_DISCONNECTED_FETCHEDpyamrex)
+        endif()
+    elseif(NOT ImpactX_pyamrex_internal)
+        # TODO: MPI control
+        find_package(pyAMReX 21.02 CONFIG REQUIRED)
+        message(STATUS "pyAMReX: Found version '${pyamrex_VERSION}'")
+    endif()
+endfunction()
+
+# local source-tree
+set(ImpactX_pyamrex_src ""
+    CACHE PATH
+    "Local path to pyAMReX source directory (preferred if set)")
+
+# Git fetcher
+option(ImpactX_pyamrex_internal "Download & build pyAMReX" ON)
+set(ImpactX_pyamrex_repo "https://github.com/AMReX-Codes/pyamrex.git"
+    CACHE STRING
+    "Repository URI to pull and build pyamrex from if(ImpactX_pyamrex_internal)")
+set(ImpactX_pyamrex_branch "development"
+    CACHE STRING
+    "Repository branch for ImpactX_pyamrex_repo if(ImpactX_pyamrex_internal)")
+
+find_pyamrex()
diff --git a/cmake/dependencies/pybind11.cmake b/cmake/dependencies/pybind11.cmake
new file mode 100644
index 000000000..f21648293
--- /dev/null
+++ b/cmake/dependencies/pybind11.cmake
@@ -0,0 +1,56 @@
+function(find_pybind11)
+    if(ImpactX_pybind11_src)
+        message(STATUS "Compiling local pybind11 ...")
+        message(STATUS "pybind11 source path: ${ImpactX_pybind11_src}")
+    elseif(ImpactX_pybind11_internal)
+        message(STATUS "Downloading pybind11 ...")
+        message(STATUS "pybind11 repository: ${ImpactX_pybind11_repo} (${ImpactX_pybind11_branch})")
+        include(FetchContent)
+    endif()
+    if(ImpactX_pybind11_internal OR ImpactX_pybind11_src)
+        set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+
+        if(ImpactX_pybind11_src)
+            add_subdirectory(${ImpactX_pybind11_src} _deps/localpybind11-build/)
+        else()
+            FetchContent_Declare(fetchedpybind11
+                GIT_REPOSITORY ${ImpactX_pybind11_repo}
+                GIT_TAG        ${ImpactX_pybind11_branch}
+                BUILD_IN_SOURCE 0
+            )
+            FetchContent_GetProperties(fetchedpybind11)
+
+            if(NOT fetchedpybind11_POPULATED)
+                FetchContent_Populate(fetchedpybind11)
+                add_subdirectory(${fetchedpybind11_SOURCE_DIR} ${fetchedpybind11_BINARY_DIR})
+            endif()
+
+            # advanced fetch options
+            mark_as_advanced(FETCHCONTENT_BASE_DIR)
+            mark_as_advanced(FETCHCONTENT_FULLY_DISCONNECTED)
+            mark_as_advanced(FETCHCONTENT_QUIET)
+            mark_as_advanced(FETCHCONTENT_SOURCE_DIR_FETCHEDpybind11)
+            mark_as_advanced(FETCHCONTENT_UPDATES_DISCONNECTED)
+            mark_as_advanced(FETCHCONTENT_UPDATES_DISCONNECTED_FETCHEDpybind11)
+        endif()
+    else()
+        find_package(pybind11 2.9.1 CONFIG REQUIRED)
+        message(STATUS "pybind11: Found version '${pybind11_VERSION}'")
+    endif()
+endfunction()
+
+# local source-tree
+set(ImpactX_pybind11_src ""
+    CACHE PATH
+    "Local path to pybind11 source directory (preferred if set)")
+
+# Git fetcher
+option(ImpactX_pybind11_internal "Download & build pybind11" ON)
+set(ImpactX_pybind11_repo "https://github.com/pybind/pybind11.git"
+    CACHE STRING
+    "Repository URI to pull and build pybind11 from if(ImpactX_pybind11_internal)")
+set(ImpactX_pybind11_branch "v2.9.1"
+    CACHE STRING
+    "Repository branch for ImpactX_pybind11_repo if(ImpactX_pybind11_internal)")
+
+find_pybind11()
diff --git a/docs/source/install/cmake.rst b/docs/source/install/cmake.rst
index d09a6db71..d2bd05f3b 100644
--- a/docs/source/install/cmake.rst
+++ b/docs/source/install/cmake.rst
@@ -66,6 +66,39 @@ or by adding arguments with ``-D<OPTION>=<VALUE>`` to the first CMake call, e.g.
 
    cmake -S . -B build -DImpactX_COMPUTE=CUDA
 
+
+Compile including Python Bindings
+---------------------------------
+
+.. note::
+
+   Preparation: make sure you work with up-to-date Python tooling.
+
+   .. code-block:: bash
+
+      python3 -m pip install -U pip setuptools wheel
+
+For PICMI Python bindings, add a configure option and call our ``pip_install`` *CMake target*:
+
+.. code-block:: bash
+
+   # find dependencies & configure
+   cmake -S . -B build -DImpactX_PYTHON=ON
+
+   # build and then call "python3 -m pip install ..."
+   cmake --build build --target pip_install -j 4
+
+**That's it!**
+*TODO:* You can now :ref:`run a first 3D PICMI script <usage-picmi>` from our :ref:`examples <usage-examples>`.
+
+Developers could now change the ImpactX source code and then call the build line again to refresh the Python installation.
+
+.. tip::
+
+   If you do *not* develop with :ref:`a user-level package manager <install-dependencies>`, e.g., because you rely on a HPC system's environment modules, then consider to set up a virtual environment via `Python venv <https://docs.python.org/3/library/venv.html>`__.
+   Otherwise, without a virtual environment, you likely need to add the CMake option ``-DPYINSTALLOPTIONS="--user"``.
+
+
 Build Options
 -------------
 
@@ -79,10 +112,12 @@ CMake Option                    Default & Values                             Des
 ``ImpactX_APP``                 **ON**/OFF                                   Build the ImpactX executable application
 ``ImpactX_COMPUTE``             NOACC/**OMP**/CUDA/SYCL/HIP                  On-node, accelerated computing backend
 ``ImpactX_IPO``                 ON/**OFF**                                   Compile ImpactX with interprocedural optimization (aka LTO)
-``ImpactX_LIB``                 ON/**OFF**                                   Build ImpactX as a shared library
+``ImpactX_LIB``                 ON/**OFF**                                   Build ImpactX as a library (shared or static)
 ``ImpactX_MPI``                 **ON**/OFF                                   Multi-node support (message-passing)
 ``ImpactX_MPI_THREAD_MULTIPLE`` **ON**/OFF                                   MPI thread-multiple support, i.e. for ``async_io``
 ``ImpactX_PRECISION``           SINGLE/**DOUBLE**                            Floating point precision (single/double)
+``ImpactX_PYTHON``              ON/**OFF**                                   Python bindings
+``Python_EXECUTABLE``           (newest found)                               Path to Python executable
 =============================== ============================================ ===========================================================
 
 ImpactX can be configured in further detail with options from AMReX, which are `documented in the AMReX manual <https://amrex-codes.github.io/amrex/docs_html/BuildingAMReX.html#customization-options>`_.
@@ -102,6 +137,10 @@ CMake Option                  Default & Values                               Des
 ``ImpactX_amrex_repo``        ``https://github.com/AMReX-Codes/amrex.git``   Repository URI to pull and build AMReX from
 ``ImpactX_amrex_branch``      *we set and maintain a compatible commit*      Repository branch for ``ImpactX_amrex_repo``
 ``ImpactX_amrex_internal``    **ON**/OFF                                     Needs a pre-installed AMReX library if set to ``OFF``
+``ImpactX_pyamrex_src``       *None*                                         Path to AMReX source directory (preferred if set)
+``ImpactX_pyamrex_repo``      ``https://github.com/AMReX-Codes/pyamrex.git`` Repository URI to pull and build pyAMReX from
+``ImpactX_pyamrex_branch``    *we set and maintain a compatible commit*      Repository branch for ``ImpactX_pyamrex_repo``
+``ImpactX_pyamrex_internal``  **ON**/OFF                                     Needs a pre-installed pyAMReX module if set to ``OFF``
 ============================= ============================================== ===========================================================
 
 For example, one can also build against a local AMReX copy.
@@ -120,6 +159,7 @@ Please see the :ref:`introduction to CMake <building-cmake-intro>` if this sound
 If you re-compile often, consider installing the `Ninja <https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages>`__ build system.
 Pass ``-G Ninja`` to the CMake configuration call to speed up parallel compiles.
 
+
 Configure your compiler
 -----------------------
 
diff --git a/examples/requirements.txt b/examples/requirements.txt
new file mode 100644
index 000000000..1c813b686
--- /dev/null
+++ b/examples/requirements.txt
@@ -0,0 +1,3 @@
+numpy
+pandas
+scipy
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..d7096f82d
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,7 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel",
+    "cmake>=3.20.0,<4.0.0"
+]
+build-backend = "setuptools.build_meta"
diff --git a/requirements.txt b/requirements.txt
index 1c813b686..21096b23d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1 @@
-numpy
-pandas
-scipy
+numpy~=1.15
diff --git a/setup.py b/setup.py
new file mode 100644
index 000000000..8c1ab4e9c
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+#
+# Copyright 2021 The ImpactX Community
+#
+# Authors: Axel Huebl
+# License: BSD-3-Clause-LBNL
+#
+from distutils.command.build import build
+from distutils.command.clean import clean
+from distutils.version import LooseVersion
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+
+from setuptools import Extension, setup
+from setuptools.command.build_ext import build_ext
+
+
+class CopyPreBuild(build):
+    def initialize_options(self):
+        build.initialize_options(self)
+        # We just overwrite this because the default "build" (and "build/lib")
+        # clashes with directories many developers have in their source trees;
+        # this can create confusing results with "pip install .", which clones
+        # the whole source tree by default
+        self.build_base = '_tmppythonbuild'
+
+    def run(self):
+        # remove existing build directory
+        #   by default, this stays around. we want to make sure generated
+        #   files like libwarpx.(2d|3d|rz).(so|pyd) are always only the
+        #   ones we want to package and not ones from an earlier wheel's stage
+        c = clean(self.distribution)
+        c.all = True
+        c.finalize_options()
+        c.run()
+
+        # call superclass
+        build.run(self)
+
+        # matches: impactx_pybind.*.(so|pyd)
+        re_libprefix = re.compile(r"impactx_pybind\..*\.(?:so|pyd)")
+        libs_found = []
+        for lib_name in os.listdir(PYIMPACTX_libdir):
+            if re_libprefix.match(lib_name):
+                lib_path = os.path.join(PYIMPACTX_libdir, lib_name)
+                libs_found.append(lib_path)
+        if len(libs_found) == 0:
+            raise RuntimeError("Error: no pre-build pyImpactX libraries found in "
+                               "PYIMPACTX_libdir='{}'".format(PYIMPACTX_libdir))
+
+        # copy external libs into collection of files in a temporary build dir
+        dst_path = os.path.join(self.build_lib, "impactx")
+        for lib_path in libs_found:
+            shutil.copy(lib_path, dst_path)
+
+
+class CMakeExtension(Extension):
+    def __init__(self, name, sourcedir=''):
+        Extension.__init__(self, name, sources=[])
+        self.sourcedir = os.path.abspath(sourcedir)
+
+
+class CMakeBuild(build_ext):
+    def run(self):
+        try:
+            out = subprocess.check_output(['cmake', '--version'])
+        except OSError:
+            raise RuntimeError(
+                "CMake 3.20.0+ must be installed to build the following " +
+                "extensions: " +
+                ", ".join(e.name for e in self.extensions))
+
+        cmake_version = LooseVersion(re.search(
+            r'version\s*([\d.]+)',
+            out.decode()
+        ).group(1))
+        if cmake_version < '3.20.0':
+            raise RuntimeError("CMake >= 3.20.0 is required")
+
+        for ext in self.extensions:
+            self.build_extension(ext)
+
+    def build_extension(self, ext):
+        extdir = os.path.abspath(os.path.dirname(
+            self.get_ext_fullpath(ext.name)
+        ))
+        # required for auto-detection of auxiliary "native" libs
+        if not extdir.endswith(os.path.sep):
+            extdir += os.path.sep
+
+        cmake_args = [
+            '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' +
+                os.path.join(extdir, "impactx"),
+            '-DCMAKE_VERBOSE_MAKEFILE=ON',
+            '-DCMAKE_PYTHON_OUTPUT_DIRECTORY=' + extdir,
+            '-DPython_EXECUTABLE=' + sys.executable,
+            ## variants
+            '-DImpactX_COMPUTE=' + ImpactX_COMPUTE,
+            '-DImpactX_MPI:BOOL=' + ImpactX_MPI,
+            '-DImpactX_PRECISION=' + ImpactX_PRECISION,
+            #'-DImpactX_PARTICLES_PRECISION=' + ImpactX_PARTICLES_PRECISION,
+            '-DImpactX_PYTHON:BOOL=ON',
+            ## dependency control (developers & package managers)
+            #'-DImpactX_pyamrex_internal=' + ImpactX_pyamrex_internal,
+            #'-DImpactX_pyamrex_repo=' + ImpactX_pyamrex_repo,
+            #'-DImpactX_pyamrex_branch=' + ImpactX_pyamrex_branch,
+            # PEP-440 conformant version from package
+            "-DpyImpactX_VERSION_INFO=" + self.distribution.get_version(),
+            #        see PICSAR and openPMD below
+            ## static/shared libs
+            '-DBUILD_SHARED_LIBS:BOOL=' + BUILD_SHARED_LIBS,
+            ## Unix: rpath to current dir when packaged
+            '-DCMAKE_BUILD_WITH_INSTALL_RPATH:BOOL=ON',
+            '-DCMAKE_INSTALL_RPATH_USE_LINK_PATH:BOOL=OFF',
+            # Windows: has no RPath concept, all `.dll`s must be in %PATH%
+            #          or same dir as calling executable
+        ]
+        # further dependency control (developers & package managers)
+        if ImpactX_amrex_src:
+            cmake_args.append('-DImpactX_amrex_src=' + ImpactX_amrex_src)
+        #if ImpactX_pyamrex_src:
+        #    cmake_args.append('-DImpactX_pyamrex_src=' + ImpactX_pyamrex_src)
+
+        if sys.platform == "darwin":
+            cmake_args.append('-DCMAKE_INSTALL_RPATH=@loader_path')
+        else:
+            # values: linux*, aix, freebsd, ...
+            #   just as well win32 & cygwin (although Windows has no RPaths)
+            cmake_args.append('-DCMAKE_INSTALL_RPATH=$ORIGIN')
+
+        cfg = 'Debug' if self.debug else 'Release'
+        build_args = ['--config', cfg]
+
+        if platform.system() == "Windows":
+            cmake_args += [
+                '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(
+                    cfg.upper(),
+                    os.path.join(extdir, "impactx")
+                )
+            ]
+            if sys.maxsize > 2**32:
+                cmake_args += ['-A', 'x64']
+        else:
+            cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
+
+        # this environment variable is standardized in CMake
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            # optional -j parameter in the build_ext call, not supported by pip
+            if hasattr(self, "parallel") and self.parallel:
+                build_args += ["-j{}".format(self.parallel)]
+            else:
+                build_args += ["-j2"]
+
+        build_dir = os.path.join(self.build_temp, cfg)
+        os.makedirs(build_dir, exist_ok=True)
+        subprocess.check_call(
+            ['cmake', ext.sourcedir] + cmake_args,
+            cwd=build_dir
+        )
+        subprocess.check_call(
+            ['cmake', '--build', '.'] + build_args,
+            cwd=build_dir
+        )
+        # note that this does not call install;
+        # we pick up artifacts directly from the build output dirs
+
+
+with open('./README.md', encoding='utf-8') as f:
+    long_description = f.read()
+
+# Allow to control options via environment vars.
+#   Work-around for https://github.com/pypa/setuptools/issues/1712
+# Pick up existing ImpactX libraries or...
+PYIMPACTX_libdir = os.environ.get('PYIMPACTX_LIBDIR')
+
+# ... build ImpactX libraries with CMake
+#   note: changed default for SHARED, MPI, TESTING and EXAMPLES
+ImpactX_COMPUTE = os.environ.get('IMPACTX_COMPUTE', 'OMP')
+ImpactX_MPI = os.environ.get('IMPACTX_MPI', 'OFF')
+ImpactX_PRECISION = os.environ.get('IMPACTX_PRECISION', 'DOUBLE')
+#   already prepared as a list 1;2;3
+ImpactX_SPACEDIM = os.environ.get('IMPACTX_SPACEDIM', '3')
+BUILD_SHARED_LIBS = os.environ.get('IMPACTX_BUILD_SHARED_LIBS',
+                                   'OFF')
+# CMake dependency control (developers & package managers)
+ImpactX_amrex_src = os.environ.get('IMPACTX_AMREX_SRC')
+ImpactX_amrex_internal = os.environ.get('IMPACTX_AMREX_INTERNAL', 'ON')
+ImpactX_amrex_repo = os.environ.get('IMPACTX_AMREX_REPO',
+    'https://github.com/AMReX-Codes/amrex.git')
+ImpactX_amrex_branch = os.environ.get('IMPACTX_PYAMREX_BRANCH', 'development')
+#ImpactX_pyamrex_src = os.environ.get('IMPACTX_PYAMREX_SRC')
+#ImpactX_pyamrex_internal = os.environ.get('IMPACTX_PYAMREX_INTERNAL', 'ON')
+#ImpactX_pyamrex_repo = os.environ.get('IMPACTX_PYAMREX_REPO',
+#    'https://github.com/AMReX-Codes/pyamrex.git')
+#ImpactX_pyamrex_branch = os.environ.get('IMPACTX_PYAMREX_BRANCH', 'development')
+
+# https://cmake.org/cmake/help/v3.0/command/if.html
+if ImpactX_MPI.upper() in ['1', 'ON', 'TRUE', 'YES']:
+    ImpactX_MPI = "ON"
+else:
+    ImpactX_MPI = "OFF"
+
+# for CMake
+cxx_modules = []     # values: impactx or empty
+cmdclass = {}        # build extensions
+
+# externally pre-built: pick up pre-built pyImpactX libraries
+if PYIMPACTX_libdir:
+    cmdclass = dict(build=CopyPreBuild)
+# CMake: build pyImpactX ourselves
+else:
+    cmdclass = dict(build_ext=CMakeBuild)
+    cxx_modules.append(CMakeExtension("impactx"))
+
+# Get the package requirements from the requirements.txt file
+install_requires = []
+with open('./requirements.txt') as f:
+    install_requires = [line.strip('\n') for line in f.readlines()]
+    if ImpactX_MPI == "ON":
+        install_requires.append('mpi4py>=2.1.0')
+
+# keyword reference:
+#   https://packaging.python.org/guides/distributing-packages-using-setuptools
+setup(
+    name='impactx',
+    # note PEP-440 syntax: x.y.zaN but x.y.z.devN
+    version = '22.02',
+    packages = ['impactx'],
+
+    # Python sources:
+    package_dir = {'': 'src/python'},
+
+    # ImpactX authors:
+    author='Axel Huebl, Chad Mitchell, Ryan Sandberg, Ji Qiang, et al.',
+    author_email='axelhuebl@lbl.gov, chadmitchell@lbl.gov, RSandberg@lbl.gov, jqiang@lbl.gov',
+    # wheel/pypi packages:
+    maintainer='Axel Huebl, Chad Mitchell, Ji Qiang',
+    maintainer_email='axelhuebl@lbl.gov, chadmitchell@lbl.gov, jqiang@lbl.gov',
+    description='ImpactX: the next generation of the IMPACT-Z beam dynamics code',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    keywords=('research simulation particle-in-cell gpu accelerator physics pic particle beam-dynamics'),
+    url='https://impactx.readthedocs.io',
+    project_urls={
+        'Documentation': 'https://impactx.readthedocs.io',
+#        'Tutorials': 'https://impactx-codes.github.io/impactx/tutorials_html/',
+        'Doxygen': 'https://impactx.readthedocs.io/en/latest/_static/doxyhtml',
+#        'Reference': 'https://doi.org/10.5281/zenodo.2555438',  TODO
+        'Source': 'https://github.com/ECP-WarpX/impactx',
+        'Tracker': 'https://github.com/ECP-WarpX/impactx/issues',
+    },
+    # CMake: self-built as extension module
+    ext_modules=cxx_modules,
+    cmdclass=cmdclass,
+    zip_safe=False,
+    python_requires='>=3.6',
+    tests_require=['numpy', 'pandas', 'pytest', 'scipy'],
+    install_requires=install_requires,
+    # cmdclass={'test': PyTest},
+    # platforms='any',
+    classifiers=[
+        'Development Status :: 2 - Pre-Alpha',
+        'Natural Language :: English',
+        'Environment :: Console',
+        'Environment :: GPU',
+        'Environment :: GPU :: NVIDIA CUDA',
+        'Intended Audience :: Science/Research',
+        'Operating System :: OS Independent',
+        'Topic :: Scientific/Engineering',
+        'Topic :: Scientific/Engineering :: Physics',
+        'Topic :: Software Development :: Libraries',
+        'Programming Language :: C++',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        ('License :: OSI Approved :: '
+         'BSD License'), # TODO: use real SPDX: BSD-3-Clause-LBNL
+    ],
+    # new PEP 639 format
+    license='BSD-3-Clause-LBNL',
+    license_files = ['LICENSE'],
+)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3aa396c76..6f823ac23 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -11,6 +11,15 @@ target_sources(ImpactX
 add_subdirectory(initialization)
 add_subdirectory(particles)
 
+
+###############################################################################
+# This builds Python bindings for classes and functions
+#
+if(ImpactX_PYTHON)
+    add_subdirectory(python)
+endif()
+
+
 ###############################################################################
 # This is the entry point of the application.
 # This fail primarily contains main(), so we can run ImpactX as an application
diff --git a/src/ImpactX.H b/src/ImpactX.H
index 7c3153555..ef9d9bd8c 100644
--- a/src/ImpactX.H
+++ b/src/ImpactX.H
@@ -92,6 +92,7 @@ namespace impactx
         //! Delete level data
         void ClearLevel (int lev) override;
 
+      public:
         /** Resize the mesh, based on the extent of the bunch of particle
          *
          * This only changes the physical extent of the mesh, but not the
@@ -107,6 +108,8 @@ namespace impactx
 
         /** these are elements defining the lattice */
         std::list<KnownElements> m_lattice;
+
+        std::list<std::variant<int>> m_lattice_test;
     };
 
 } // namespace impactx
diff --git a/src/particles/ImpactXParticleContainer.H b/src/particles/ImpactXParticleContainer.H
index ca38f13d3..fb86ce61c 100644
--- a/src/particles/ImpactXParticleContainer.H
+++ b/src/particles/ImpactXParticleContainer.H
@@ -160,6 +160,16 @@ namespace impactx
          */
         void SetParticleShape ();
 
+        /** Set Particle Shape order
+         *
+         * Note: this can only be called once. All later calls are a logic error.
+         * The reason for that is that subsequent calls would need to change
+         * the guard size of all our MultiFabs, which is not implemented.
+         *
+         * @param order the order of the particle shape
+         */
+        void SetParticleShape (int const order);
+
         /** Compute the min and max of the particle position in each dimension
          *
          * @returns x_min, y_min, z_min, x_max, y_max, z_max
diff --git a/src/particles/ImpactXParticleContainer.cpp b/src/particles/ImpactXParticleContainer.cpp
index c245efe1c..1d37a7408 100644
--- a/src/particles/ImpactXParticleContainer.cpp
+++ b/src/particles/ImpactXParticleContainer.cpp
@@ -29,23 +29,28 @@ namespace impactx
         SetParticleSize();
     }
 
-    void ImpactXParticleContainer::SetParticleShape ()
-    {
-        if (m_particle_shape.has_value()) {
+    void ImpactXParticleContainer::SetParticleShape (int const order) {
+        if (m_particle_shape.has_value())
+        {
             throw std::logic_error(
                 "ImpactXParticleContainer::SetParticleShape This was already called before and cannot be changed.");
         } else
         {
-            amrex::ParmParse pp_algo("algo");
-            int v = 0;
-            pp_algo.get("particle_shape", v);
-            m_particle_shape = v;
-            if (m_particle_shape.value() < 1 || m_particle_shape.value() > 3) {
-                amrex::Abort("algo.particle_shape can be only 1, 2, or 3");
+            if (order < 1 || order > 3) {
+                amrex::Abort("algo.particle_shape order can be only 1, 2, or 3");
             }
+            m_particle_shape = order;
         }
     }
 
+    void ImpactXParticleContainer::SetParticleShape ()
+    {
+        amrex::ParmParse pp_algo("algo");
+        int v = 0;
+        pp_algo.get("particle_shape", v);
+        SetParticleShape(v);
+    }
+
     void
     ImpactXParticleContainer::AddNParticles (int lev,
                                              amrex::Vector<amrex::ParticleReal> const & x,
diff --git a/src/particles/elements/All.H b/src/particles/elements/All.H
index 236061325..c66ef414c 100644
--- a/src/particles/elements/All.H
+++ b/src/particles/elements/All.H
@@ -17,6 +17,7 @@
 #include "ConstF.H"
 #include "ShortRF.H"
 #include "Multipole.H"
+#include "None.H"
 #include "NonlinearLens.H"
 
 #include <variant>
@@ -24,8 +25,10 @@
 
 namespace impactx
 {
-    using KnownElements = std::variant<Drift, Sbend, Quad, DipEdge, ConstF,
-                                       ShortRF, Multipole, NonlinearLens>;
+    using KnownElements = std::variant<
+        None, /* must be first, so KnownElements creates a default constructor */
+        ConstF, DipEdge, Drift, Multipole, NonlinearLens,
+        Quad, Sbend, ShortRF>;
 
 } // namespace impactx
 
diff --git a/src/particles/elements/None.H b/src/particles/elements/None.H
new file mode 100644
index 000000000..789376ae4
--- /dev/null
+++ b/src/particles/elements/None.H
@@ -0,0 +1,67 @@
+/* Copyright 2022 The Regents of the University of California, through Lawrence
+ *           Berkeley National Laboratory (subject to receipt of any required
+ *           approvals from the U.S. Dept. of Energy). All rights reserved.
+ *
+ * This file is part of ImpactX.
+ *
+ * Authors: Axel Huebl
+ * License: BSD-3-Clause-LBNL
+ */
+#ifndef IMPACTX_NONE_H
+#define IMPACTX_NONE_H
+
+#include "particles/ImpactXParticleContainer.H"
+
+#include <AMReX_Extension.H>
+#include <AMReX_REAL.H>
+
+
+namespace impactx
+{
+    struct None
+    {
+        using PType = ImpactXParticleContainer::ParticleType;
+
+        /** This element does nothing.
+         */
+        None ()
+        {
+        }
+
+        /** Does nothing to a particle.
+         *
+         * @param p Particle AoS data for positions and cpu/id
+         * @param px particle momentum in x
+         * @param py particle momentum in y
+         * @param pt particle momentum in t
+         * @param refpart reference particle
+         */
+        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
+        void operator() (
+                [[maybe_unused]] PType& AMREX_RESTRICT p,
+                [[maybe_unused]] amrex::ParticleReal & AMREX_RESTRICT px,
+                [[maybe_unused]] amrex::ParticleReal & AMREX_RESTRICT py,
+                [[maybe_unused]] amrex::ParticleReal & AMREX_RESTRICT pt,
+                [[maybe_unused]] RefPart const refpart) const
+        {
+            // nothing to do
+        }
+
+
+        /** This pushes the reference particle.
+         *
+         * @param[in,out] refpart reference particle
+         */
+        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
+        void operator() (
+                [[maybe_unused]] RefPart & AMREX_RESTRICT refpart) const {
+
+            // nothing to do: this is a zero-length element
+
+        }
+
+    };
+
+} // namespace impactx
+
+#endif // IMPACTX_NONE_H
diff --git a/src/python/CMakeLists.txt b/src/python/CMakeLists.txt
new file mode 100644
index 000000000..9315680de
--- /dev/null
+++ b/src/python/CMakeLists.txt
@@ -0,0 +1,9 @@
+###############################################################################
+# These are the files equivalent to the primary C++ implementation - but here
+# we define how they will appear in our Python module (aka Python bindings).
+#
+target_sources(pyImpactX
+  PRIVATE
+    elements.cpp
+    ImpactX.cpp
+)
diff --git a/src/python/ImpactX.cpp b/src/python/ImpactX.cpp
new file mode 100644
index 000000000..9c04440fd
--- /dev/null
+++ b/src/python/ImpactX.cpp
@@ -0,0 +1,120 @@
+/* Copyright 2021-2022 The ImpactX Community
+ *
+ * Authors: Axel Huebl
+ * License: BSD-3-Clause-LBNL
+ */
+#include "pyImpactX.H"
+
+#include <ImpactX.H>
+#include <AMReX.H>
+#include <AMReX_ParmParse.H>
+
+#if defined(AMREX_DEBUG) || defined(DEBUG)
+#   include <cstdio>
+#endif
+
+
+namespace py = pybind11;
+using namespace impactx;
+
+namespace {
+    struct Config {};
+}
+
+void init_ImpactX(py::module& m)
+{
+    /*
+    py::bind_map<
+        std::unordered_map<int, amrex::MultiFab>
+    >(m, "MultiFabPerLevel");
+    */
+
+    py::class_<ImpactX, amrex::AmrCore>(m, "ImpactX")
+        .def(py::init<>())
+
+        .def("load_inputs_file",
+            [](ImpactX const & /* ix */, std::string const filename) {
+#if defined(AMREX_DEBUG) || defined(DEBUG)
+                // note: only in debug, since this is costly for the file
+                // system for highly parallel simulations with MPI
+                // possible improvement:
+                // - rank 0 tests file & broadcasts existence/failure
+                bool inputs_file_exists = false;
+                if (FILE *fp = fopen(filename.c_str(), "r")) {
+                    fclose(fp);
+                    inputs_file_exists = true;
+                }
+                AMREX_ALWAYS_ASSERT_WITH_MESSAGE(inputs_file_exists,
+                    "load_inputs_file: invalid filename");
+#endif
+
+                amrex::ParmParse::addfile(filename);
+            })
+        .def("set_particle_shape",
+            [](ImpactX & ix, int const order) {
+                AMREX_ALWAYS_ASSERT_WITH_MESSAGE(ix.m_particle_container,
+                    "particle container not initialized");
+                // todo: why does that not work?
+                //ix.m_particle_container->SetParticleShape(order);
+
+                amrex::ParmParse pp_ago("algo");
+                pp_ago.add("particle_shape", order);
+            })
+        .def("init_grids", &ImpactX::initGrids)
+        .def("init_beam_distribution_from_inputs", &ImpactX::initBeamDistributionFromInputs)
+        .def("init_lattice_elements_from_inputs", &ImpactX::initLatticeElementsFromInputs)
+        .def("evolve", &ImpactX::evolve, py::arg("num_steps"))
+
+        //.def_property("particle_container", &ImpactX::m_particle_container)
+        //.def_readwrite("rho", &ImpactX::m_rho)
+        .def_readwrite("lattice", &ImpactX::m_lattice)
+        //.def_readwrite("lattice", &ImpactX::m_lattice_test)
+    ;
+
+    py::class_<Config>(m, "Config")
+//        .def_property_readonly_static(
+//            "impactx_version",
+//            [](py::object) { return Version(); },
+//            "ImpactX version")
+        .def_property_readonly_static(
+            "have_mpi",
+            [](py::object){
+#ifdef AMREX_USE_MPI
+                return true;
+#else
+                return false;
+#endif
+            })
+        .def_property_readonly_static(
+            "have_gpu",
+            [](py::object){
+#ifdef AMREX_USE_GPU
+                return true;
+#else
+                return false;
+#endif
+            })
+        .def_property_readonly_static(
+            "have_omp",
+            [](py::object){
+#ifdef AMREX_USE_OMP
+                return true;
+#else
+                return false;
+#endif
+            })
+        .def_property_readonly_static(
+            "gpu_backend",
+            [](py::object){
+#ifdef AMREX_USE_CUDA
+                return "CUDA";
+#elif defined(AMREX_USE_HIP)
+                return "HIP";
+#elif defined(AMREX_USE_DPCPP)
+                return "SYCL";
+#else
+                return py::none();
+#endif
+            })
+        ;
+}
diff --git a/src/python/elements.cpp b/src/python/elements.cpp
new file mode 100644
index 000000000..5901ef54b
--- /dev/null
+++ b/src/python/elements.cpp
@@ -0,0 +1,116 @@
+/* Copyright 2021-2022 The ImpactX Community
+ *
+ * Authors: Axel Huebl
+ * License: BSD-3-Clause-LBNL
+ */
+#include "pyImpactX.H"
+
+#include <particles/elements/All.H>
+#include <AMReX.H>
+
+namespace py = pybind11;
+using namespace impactx;
+
+
+void init_elements(py::module& m)
+{
+    py::module_ me = m.def_submodule(
+        "elements",
+        "Accelerator lattice elements in ImpactX"
+    );
+
+    using KnownElementsList = std::list<KnownElements>;
+    py::class_<KnownElementsList> kel(me, "KnownElementsList");
+    kel
+        .def(py::init<>())
+        .def(py::init<KnownElements>())
+        .def(py::init([](py::list l){
+            auto v = new KnownElementsList;
+            for (auto &handle : l)
+                v->push_back(handle.cast<KnownElements>());
+            return v;
+        }))
+
+        .def("append", [](KnownElementsList &v, KnownElements el) { v.emplace_back(el); })
+
+        .def("extend", [](KnownElementsList &v, KnownElementsList l) {
+            for (auto &el : l)
+                v.push_back(el);
+            return v;
+        })
+        .def("extend", [](KnownElementsList &v, py::list l) {
+            for (auto &handle : l)
+            {
+                auto el = handle.cast<KnownElements>();
+                v.push_back(el);
+            }
+            return v;
+        })
+
+        .def("clear", &KnownElementsList::clear)
+        .def("pop_back", &KnownElementsList::pop_back)
+        .def("__len__", [](const KnownElementsList &v) { return v.size(); })
+        .def("__iter__", [](KnownElementsList &v) {
+            return py::make_iterator(v.begin(), v.end());
+        }, py::keep_alive<0, 1>()) /* Keep list alive while iterator is used */
+    ;
+
+    py::class_<ConstF>(me, "ConstF")
+        .def(py::init<
+                amrex::ParticleReal const,
+                amrex::ParticleReal const,
+                amrex::ParticleReal const,
+                amrex::ParticleReal const>(),
+             py::arg("ds"), py::arg("kx"), py::arg("ky"), py::arg("kt")
+        );
+
+    py::class_<DipEdge>(me, "DipEdge")
+        .def(py::init<
+                amrex::ParticleReal const,
+                amrex::ParticleReal const,
+                amrex::ParticleReal const,
+                amrex::ParticleReal const>(),
+             py::arg("psi"), py::arg("rc"), py::arg("g"), py::arg("K2")
+        );
+
+    py::class_<Drift>(me, "Drift")
+        .def(py::init<amrex::ParticleReal const>(),
+             py::arg("ds")
+        );
+
+    py::class_<Multipole>(me, "Multipole")
+        .def(py::init<
+                int const,
+                amrex::ParticleReal const,
+                amrex::ParticleReal const>(),
+             py::arg("multiple"), py::arg("K_normal"), py::arg("K_skew")
+        );
+
+    py::class_<NonlinearLens>(me, "NonlinearLens")
+        .def(py::init<
+                amrex::ParticleReal const,
+                amrex::ParticleReal const>(),
+             py::arg("knll"), py::arg("cnll")
+        );
+
+    py::class_<Sbend>(me, "Sbend")
+        .def(py::init<
+                amrex::ParticleReal const,
+                amrex::ParticleReal const>(),
+             py::arg("ds"), py::arg("rc")
+        );
+
+    py::class_<ShortRF>(me, "ShortRF")
+        .def(py::init<
+                amrex::ParticleReal const,
+                amrex::ParticleReal const>(),
+             py::arg("V"), py::arg("k")
+        );
+
+    py::class_<Quad>(me, "Quad")
+        .def(py::init<
+                amrex::ParticleReal const,
+                amrex::ParticleReal const>(),
+             py::arg("ds"), py::arg("k")
+        );
+}
diff --git a/src/python/impactx/__init__.py b/src/python/impactx/__init__.py
new file mode 100644
index 000000000..a9ac835fb
--- /dev/null
+++ b/src/python/impactx/__init__.py
@@ -0,0 +1,11 @@
+from . import impactx_pybind
+from .impactx_pybind import *  # noqa
+
+__version__ = impactx_pybind.__version__
+__doc__ = impactx_pybind.__doc__
+__license__ = impactx_pybind.__license__
+__author__ = impactx_pybind.__author__
+
+# at this place we can enhance Python classes with additional methods written
+# in pure Python or add some other Python logic
+#
diff --git a/src/python/pyImpactX.H b/src/python/pyImpactX.H
new file mode 100644
index 000000000..cacba33e3
--- /dev/null
+++ b/src/python/pyImpactX.H
@@ -0,0 +1,21 @@
+/* Copyright 2021-2022 The ImpactX Community
+ *
+ * This header is used to centrally define classes that shall not violate the
+ * C++ one-definition-rule (ODR) for various Python translation units.
+ *
+ * Authors: Axel Huebl
+ * License: BSD-3-Clause-LBNL
+ */
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/stl_bind.h>
+#include <pybind11/functional.h>
+
+#include <particles/elements/All.H>
+
+#include <list>
+
+namespace py = pybind11;
+using namespace impactx;
+
+PYBIND11_MAKE_OPAQUE(std::list<KnownElements>)
diff --git a/src/python/pyImpactX.cpp b/src/python/pyImpactX.cpp
new file mode 100644
index 000000000..3b0b7016b
--- /dev/null
+++ b/src/python/pyImpactX.cpp
@@ -0,0 +1,64 @@
+/* Copyright 2021-2022 The ImpactX Community
+ *
+ * Authors: Axel Huebl
+ * License: BSD-3-Clause-LBNL
+ */
+#include "pyImpactX.H"
+
+#include <ImpactX.H>
+#include <particles/elements/All.H>
+
+#define STRINGIFY(x) #x
+#define MACRO_STRINGIFY(x) STRINGIFY(x)
+
+namespace py = pybind11;
+using namespace impactx;
+
+
+// forward declarations of exposed classes
+void init_elements(py::module&);
+void init_ImpactX(py::module&);
+
+PYBIND11_MODULE(impactx_pybind, m) {
+    // make sure AMReX types are known
+    py::module::import("amrex");
+
+    m.doc() = R"pbdoc(
+            impactx_pybind
+            --------------
+            .. currentmodule:: impactx_pybind
+
+            .. autosummary::
+               :toctree: _generate
+               ImpactX
+               elements
+    )pbdoc";
+
+    // note: order from parent to child classes
+    init_elements(m);
+    init_ImpactX(m);
+
+    // API runtime version
+    //   note PEP-440 syntax: x.y.zaN but x.y.z.devN
+#ifdef PYIMPACTX_VERSION_INFO
+    m.attr("__version__") = MACRO_STRINGIFY(PYIMPACTX_VERSION_INFO);
+#else
+    m.attr("__version__") = "dev";
+#endif
+
+    // authors
+    m.attr("__author__") =
+        "Axel Huebl, Chad Mitchell, Ryan Sandberg, Ji Qiang, et al.";
+
+    // API runtime build-time feature variants
+    // m.attr("variants") = impactx::getVariants();
+    // TODO allow to query runtime versions of all dependencies
+
+    // license SPDX identifier
+    m.attr("__license__") = "BSD-3-Clause-LBNL";
+
+    // TODO broken numpy if not at least v1.15.0: raise warning
+    // auto numpy = py::module::import("numpy");
+    // auto npversion = numpy.attr("__version__");
+    // std::cout << "numpy version: " << py::str(npversion) << std::endl;
+}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 000000000..8bed16479
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,10 @@
+# C++ Unit tests ##############################################################
+#
+# TODO, e.g., with Catch2
+
+
+# Python Unit Tests ###########################################################
+#
+if(ImpactX_PYTHON)
+    add_subdirectory(python)
+endif()
diff --git a/tests/python/CMakeLists.txt b/tests/python/CMakeLists.txt
new file mode 100644
index 000000000..d42ac8838
--- /dev/null
+++ b/tests/python/CMakeLists.txt
@@ -0,0 +1,6 @@
+add_test(NAME pytest
+    COMMAND ${Python_EXECUTABLE} -m pytest
+        ${ImpactX_SOURCE_DIR}/tests/python
+    WORKING_DIRECTORY
+        ${CMAKE_PYTHON_OUTPUT_DIRECTORY}
+)
diff --git a/tests/python/conftest.py b/tests/python/conftest.py
new file mode 100644
index 000000000..42f900260
--- /dev/null
+++ b/tests/python/conftest.py
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+import amrex
+import impactx
+import pytest
+
+if impactx.Config.have_mpi:
+    from mpi4py import MPI
+    print("loaded mpi4py")
+else:
+    print("NO mpi4py load")
+
+@pytest.fixture(autouse=True, scope='session')
+def amrex_init():
+    amrex.initialize([
+        # print AMReX status messages
+        "amrex.verbose=2",
+        # throw exceptions and create core dumps instead of
+        # AMReX backtrace files: allows to attach to
+        # debuggers
+        "amrex.throw_exception=1",
+        "amrex.signal_handling=0",
+        # abort GPU runs if out-of-memory instead of swapping to host RAM
+        "amrex.abort_on_out_of_gpu_memory=1"
+    ])
+    yield
+    amrex.finalize()
diff --git a/tests/python/test_impactx.py b/tests/python/test_impactx.py
new file mode 100644
index 000000000..df446f6df
--- /dev/null
+++ b/tests/python/test_impactx.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+from impactx import ImpactX, elements
+
+
+def aasdtest_impactx_fodo_file():
+    """
+    This tests an equivalent to main.cpp in C++
+    """
+    impactX = ImpactX()
+
+    impactX.load_inputs_file("examples/fodo/input_fodo.in")
+
+    impactX.init_grids()
+    impactX.init_beam_distribution_from_inputs()
+    impactX.init_lattice_elements_from_inputs()
+
+    impactX.evolve(num_steps=1)
+
+
+def test_impactx_nofile():
+    """
+    This tests using ImpactX without an inputs file
+    """
+    impactX = ImpactX()
+
+    impactX.set_particle_shape(2)
+    impactX.init_grids()
+
+    # init particle beam
+    # TODO
+
+    # init accelerator lattice
+    fodo = [
+        elements.Drift(0.25),
+        elements.Quad(1.0, 1.0),
+        elements.Drift(0.5),
+        elements.Quad(1.0, -1.0),
+        elements.Drift(0.25)
+    ]
+    #  assign a fodo segment
+    #impactX.lattice = fodo
+
+    #  add 4 more FODO segments
+    for i in range(4):
+        impactX.lattice.extend(fodo)
+
+    # add 2 more drifts
+    for i in range(4):
+        impactX.lattice.append(elements.Drift(0.25))
+
+    print(impactX.lattice)
+    print(len(impactX.lattice))
+    assert(len(impactX.lattice) > 5)
+
+    #impactX.evolve(num_steps=1)