diff --git a/.github/workflows/user_project_ci.yml b/.github/workflows/user_project_ci.yml
index 0377c64..1edf3ec 100644
--- a/.github/workflows/user_project_ci.yml
+++ b/.github/workflows/user_project_ci.yml
@@ -83,9 +83,9 @@
           export OUTPUT=$OUTPUT_DIRECTORY/logs/precheck.log
           export PDKPATH=$PDK_ROOT/sky130A
 
-          git clone --depth=1 -b mpw-5b https://github.com/efabless/mpw_precheck.git
+          git clone --depth=1 -b mpw-7a https://github.com/efabless/mpw_precheck.git
 
-          docker run -v "$PRECHECK_ROOT":"$PRECHECK_ROOT" -v "$INPUT_DIRECTORY":"$INPUT_DIRECTORY" -v "${{ env.PDK_ROOT }}":"${{ env.PDK_ROOT }}" -e INPUT_DIRECTORY="$INPUT_DIRECTORY" -e PDK_ROOT="${{ env.PDK_ROOT }}" -e PDKPATH="${{ env.PDKPATH }}" -u $(id -u "$USER"):$(id -g "$USER") efabless/mpw_precheck:latest bash -c "cd $PRECHECK_ROOT; python3 mpw_precheck.py --input_directory $INPUT_DIRECTORY --pdk_root ${{ env.PDK_ROOT }} --output_directory $OUTPUT_DIRECTORY license makefile consistency xor magic_drc klayout_beol klayout_feol klayout_met_min_ca_density klayout_offgrid klayout_pin_label_purposes_overlapping_drawing klayout_zeroarea"
+          docker run -v "$PRECHECK_ROOT":"$PRECHECK_ROOT" -v "$INPUT_DIRECTORY":"$INPUT_DIRECTORY" -v "${{ env.PDK_ROOT }}":"${{ env.PDK_ROOT }}" -e INPUT_DIRECTORY="$INPUT_DIRECTORY" -e PDK_ROOT="${{ env.PDK_ROOT }}" -e PDKPATH="${{ env.PDKPATH }}" -u $(id -u "$USER"):$(id -g "$USER") efabless/mpw_precheck:latest bash -c "cd $PRECHECK_ROOT; python3 mpw_precheck.py --input_directory $INPUT_DIRECTORY --pdk_path ${{ env.PDKPATH }} --output_directory $OUTPUT_DIRECTORY license makefile consistency xor magic_drc klayout_beol klayout_feol klayout_met_min_ca_density klayout_offgrid klayout_pin_label_purposes_overlapping_drawing klayout_zeroarea"
 
           cnt=$(grep -c "All Checks Passed" "$OUTPUT")
           if ! [[ $cnt ]]; then cnt=0; fi
diff --git a/.gitignore b/.gitignore
index 9ccca4b..04edfb0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,7 @@
-precheck_results
+/.idea/
+/precheck_results/
+*/tmp
+*/*/tmp
 *.hex*
 *.lst
 *.vcd
diff --git a/Makefile b/Makefile
index 2a76e29..0d20cb9 100644
--- a/Makefile
+++ b/Makefile
@@ -25,15 +25,16 @@
 export PDK_MAGIC_COMMIT=7d601628e4e05fd17fcb80c3552dacb64e9f6e7b
 export OPENLANE_TAG=2022.02.23_02.50.41
 export MISMATCHES_OK=1
-export PDKPATH?=$(PDK_ROOT)/sky130B
 
 # Install lite version of caravel, (1): caravel-lite, (0): caravel
 CARAVEL_LITE?=1
 
 # PDK switch varient
 export PDK?=sky130B
+export PDKPATH?=$(PDK_ROOT)/$(PDK)
 
-MPW_TAG ?= mpw-6c
+MPW_TAG ?= mpw-7a
+
 
 ifeq ($(CARAVEL_LITE),1)
 	CARAVEL_NAME := caravel-lite
@@ -141,6 +142,11 @@
 # Install Openlane
 .PHONY: openlane
 openlane:
+	@if [ "$$(realpath $${OPENLANE_ROOT})" = "$$(realpath $$(pwd)/openlane)" ]; then\
+		echo "OPENLANE_ROOT is set to '$$(pwd)/openlane' which contains openlane config files"; \
+		echo "Please set it to a different directory"; \
+		exit 1; \
+	fi
 	cd openlane && $(MAKE) openlane
 
 #### Not sure if the targets following are of any use
@@ -184,10 +190,10 @@
 	-v $(INPUT_DIRECTORY):$(INPUT_DIRECTORY) \
 	-v $(PDK_ROOT):$(PDK_ROOT) \
 	-e INPUT_DIRECTORY=$(INPUT_DIRECTORY) \
-	-e PDK_ROOT=$(PDK_ROOT) \
+	-e PDK_PATH=$(PDK_ROOT)/$(PDK) \
 	-e PDKPATH=$(PDKPATH) \
 	-u $(shell id -u $(USER)):$(shell id -g $(USER)) \
-	efabless/mpw_precheck:latest bash -c "cd $(PRECHECK_ROOT) ; python3 mpw_precheck.py --input_directory $(INPUT_DIRECTORY) --pdk_root $(PDK_ROOT)"
+	efabless/mpw_precheck:latest bash -c "cd $(PRECHECK_ROOT) ; python3 mpw_precheck.py --input_directory $(INPUT_DIRECTORY) --pdk_path $($PDK_PATH)"
 
 
 
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 89574f1..039dd9a 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -171,6 +171,9 @@
 
     # set PDK_ROOT to the path you wish to use for the pdk
     export PDK_ROOT=<pdk-installation-path>
+    
+    # set the PDK variant depending on your shuttle, if you don't know leave it as default
+    export PDK=sky130B
 
     # use volare to download the pdk
     # To change the default pdk version you can export OPEN_PDKS_COMMIT=<pdk_commit>
diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst
index f79208a..1f2ab08 100644
--- a/docs/source/quickstart.rst
+++ b/docs/source/quickstart.rst
@@ -43,7 +43,7 @@
 
     .. code:: bash
 
-        git clone -b mpw-6c  <your github repo URL> caravel_example
+        git clone -b mpw-7a  <your github repo URL> caravel_example
 	
 #.  Now that your git environment is setup, it's time to setup your local environment by running.
 
@@ -51,11 +51,14 @@
     
 	cd caravel_example
 
-    	# make sure to change <directory_name> with the directory you created in step 2
+  # make sure to change <directory_name> with the directory you created in step 2
 	# in this case it is caravel_tutorial
-	export OPENLANE_ROOT=~/<directory_name>/openlane # you need to export this whenever you start a new shell
-	
+
+	export OPENLANE_ROOT=~/<directory_name>/openlane_src # you need to export this whenever you start a new shell
 	export PDK_ROOT=~/<directory_name>/pdks # you need to export this whenever you start a new shell
+	
+	# export the PDK variant depending on your shuttle, if you don't know leave it to the default
+	export PDK=sky130B
 
         make setup
 
