diff --git a/Makefile b/Makefile
index 77a938b..8752b31 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-# See the INSTALL.md notes on how to use this Makefile
+# See the README.md notes on how to use this Makefile
 
 #
 SHELL = /bin/bash
@@ -15,13 +15,17 @@ GIT_DIRS = athena athenak
 
 # URLs that we'll need
 
+URL0  = https://github.com/teuben/Athena-Cversion
 URL1  = https://github.com/PrincetonUniversity/athena
 URL2  = https://gitlab.com/theias/hpc/jmstone/athena-parthenon/athenak
+URL2  = https://gitlab.com/theias/hpc/jmstone/athena-parthenon/athena-mini-k
+URL2  = https://github.com/teuben/Athena-miniK
 URL3  = https://github.com/teuben/nemo
 URL4  = https://github.com/teuben/tkrun
 URL5a = https://github.com/teuben/agui
 URL5b = https://github.com/anhhcao/agui
 URL5c = https://github.com/KylieGong/agui
+URL6  = https://github.com/teuben/pyThena
 
 # the ATHENA executable (from athena or athenak)
 # ATHENA = athena/bin/athena
@@ -60,84 +64,100 @@ branch:
 	-@for dir in $(GIT_DIRS); do\
 	(echo -n "$$dir: " ;cd $$dir; git branch --show-current); done
 
+athenac:
+	git clone $(URL0) -b teuben1 athenac
+	$(MAKE) build_athenac
 
 athena:
 	git clone $(URL1)
+	$(MAKE) build_athena
 
 athenak:
-	git clone --recursive $(URL2)
+	git clone --recursive $(URL2) athenak
 
 nemo:
 	git clone $(URL3)
 
+python: nemo anaconda3
+
+anaconda3:
+	nemo/src/scripts/install_anaconda3
+
 tkrun:
 	git clone $(URL4)
 
-## build:         build athenak
-build:	athenak
-	(mkdir -p athenak/build; cd athenak/build; cmake ..; make -j 4)
+## build_athenak:  build athenak
+build_athenak:	athenak
+	(mkdir -p athenak/build; cd athenak/build; cmake ..; make -j 8)
+
+# See also:   https://kokkos.github.io/kokkos-core-wiki/keywords.html#keywords-arch
+B_ARM = -D CMAKE_CXX_COMPILER=clang++-mp-15 -D CMAKE_C_COMPILER=clang-mp-15 -D Kokkos_ARCH_ARMV81=On
+arm:	athenak
+	(mkdir -p athenak/build; cd athenak/build; cmake $(B_ARM) ..; make -j 8)
+
+#PJT =  -D CMAKE_CXX_COMPILER=clang++ -D CMAKE_C_COMPILER=clang -D Kokkos_ARCH_INTEL_DG1=On
+#PJT =  -D Kokkos_ARCH_INTEL_DG1=On
+PJT =  -D Kokkos_ENABLE_OPENMP=On
+#PJT =  -D Athena_ENABLE_MPI=ON
+pjt:	athenak
+	(mkdir -p athenak/build; cd athenak/build; cmake $(PJT) ..; make -j 8)
 
-## build_athena   build athena++ for the linear_wave problem
+## build_athena    build athena++ for the linear_wave problem
 build_athena: athena
 	(cd athena; ./configure.py --prob linear_wave; make clean; make -j)
 
-## build_nemo:    build nemo
-build_nemo:	nemo
-	(cd nemo; ./configure ; make build check bench5)
+## build_athenac   build AthenaC for the linear_wave problem
+build_athenac: athenac
+	(cd athenac; autoconf;  ./configure; make all)
+
+## build_nemo:     build nemo - will also build classic tkrun
+build_nemo:    nemo
+	(cd nemo; ./configure ; make build check)
+
+## build_python:    build your private anaconda3
+build_python:  python
 
 # a few sample runs
 
-## run1:          example linear_wave_hydro
+##
+
+## run1:          example 1D linear_wave_hydro (athenak)   [ < 1sec  1069 cycles]
 run1:
-	$(ATHENA) -i athenak/inputs/tests/linear_wave_hydro.athinput -d run1
+	$(TIME) $(ATHENA) -i linear_wave_hydro.athinput -d run1
 	@echo ./animate1 base=run1/tab/LinWave xcol=x1v ycol=velx
-	# -> LinWave.hydro_w.00000.tab
 
-## run1:          example advect_hyd
+## run2:          example 2D orszag_tang (athenak) [ ~109"  1403 cycles]
 run2:
-	$(ATHENA) -i athenak/inputs/tests/advect_hyd.athinput        -d run2
+	$(TIME) $(ATHENA) -i orszag_tang.athinput      -d run2
 	@echo ./animate1 base=run2/tab/Advect xcol=x1v ycol=dens
-	# -> Advect.hydro_u.00000.tab
 
-run3:
-	$(ATHENA) -i athenak/inputs/tests/advect_mhd.athinput        -d run3
-	#  -> Advect.mhd_u.00000.tab
 
-run4:
-	$(ATHENA) -i athenak/inputs/tests/hohlraum_1d.athinput       -d run4
-	#  -> hohlraum_1d.rad_coord.00000.tab  
 
-run5:
-	$(ATHENA) -i athenak/inputs/tests/rad_linwave.athinput       -d run5
-	# -> rad_linwave.hydro_w.*.tab
-	# -> rad_linwave.rad_coord.*.tab
+#  We use past tense for old versions of athena :-)
+##  ran1 and ran2 are made by ATHENA++
+##  ran3 by good old AthenaC
+## ran1:          example athena++ linear_wave1d in vtk format
+ran1: athena
+	athena/bin/athena  -i inputs/hydro/athinput.linear_wave1d  -d ran1
+	@echo Results in ran1
 
-run6:
-	$(ATHENA) -i athenak/inputs/hydro/sod.athinput               -d run6
-	# -> Sod.hydro_w.00000.tab
-	#   base=run6/tab/Sod  xcol=3 ycol=4
-	#   base=run6/tab/Sod  xcol=3 ycol=5
-	#   base=run6/tab/Sod  xcol=3 ycol=6
+## ran2:          example athena++ linear_wave1d needed by some tests - will also build athena++
+ran2: athena
+	athena/bin/athena  -i inputs/hydro/athinput.linear_wave1d  -d ran2 output2/file_type=tab
+	@echo Results in ran2
 
-run7:
-	$(ATHENA) -i athenak/inputs/hydro/shu_osher.athinput         -d run7
-	#   THIS IS A KNOWN ERROR
+## ran3:          example AthenaC linear_wave1d needed by some tests - will also build athenac
+ran3: athenac
+	athenac/bin/athena  -i athenac/tst/1D-hydro/athinput.linear_wave1d  -d ran3
 
-run8:
-	$(ATHENA) -i athenak/inputs/hydro/viscosity.athinput         -d run8
-	#   ViscTest.hydro_w.00000.tab 
-	#   base=run8/tab/ViscTest xcol=3 ycol=6
 
 
-ran1: athena
-	(cd athena; bin/athena  -i inputs/hydro/athinput.linear_wave1d  -d ran1)
-	@echo Results in athena/ran1
-
-ran2: athena
-	(cd athena; bin/athena  -i inputs/hydro/athinput.linear_wave1d  -d ran2 output2/file_type=tab)
-	@echo Results in athena/ran2
+## 
 
+test0:
+	./z1.sh
 
+## test1:         old tkrun via arun1
 test1:
 	./arun1.py athinput.linear_wave1d > test1.sh
 	tkrun test1.sh
@@ -153,7 +173,8 @@ test3:
 test4:
 	python pysimplegui.py
 
-#bash format
+
+## test5:         native pyqt, tkrun style
 test5:
 	python pyqt.py testfile.sh
 
@@ -169,6 +190,43 @@ test7:
 test8:
 	python pyqt.py testfile4.csh
 
+## test7:         qooey, athena style
+test7:
+	./gooey_run2.py linear_wave_hydro.athinput
+
+# will try Qt first, else fall back to tkinter
+test8:
+	./pysg_run.py athinput.linear_wave1d
+
+test9: 	ran2
+	./plot1d.py -d ran2
+
+test10:
+	./pysg_run.py test.athinput
+
+test11:
+	./pyqt_run.py test.athinput
+
+# will run the plot when run is clicked
+## test12:        pyqt native, athena style
+test12:
+	./pyqt_run.py athinput.linear_wave1d
+
+## test13:        pysg, athena style
+test13: athena_problems.json
+	./pysg_menu.py
+
+## test14:        pyqt, athena style
+test14: athena_problems.json
+	./pyqt_menu.py
+
+## test15:        miniki version
+test15:
+	./pythena.py
+
+athena_problems.json:
+	./write_problems.py
+
 # collaborations
 agui_t:
 	git clone $(URL5a) agui_t
@@ -178,3 +236,10 @@ agui_a:
 
 agui_k:
 	git clone $(URL5c) agui_k
+
+# testing a pyThena from scratch:
+
+pythena:
+	rm -rf pyThena
+	git clone $(URL6)
+	(cd pyThena; make build_athenak; make run1; make test1)
diff --git a/README.md b/README.md
index e150435..b98eec4 100644
--- a/README.md
+++ b/README.md
@@ -1,24 +1,91 @@
-# Testing an Athena* GUI
+# Developing an Athena GUI (AGUI)
 
-We show some examples of executing *athena* using a dynamic GUI.  In
-theory could apply to any of the
+This is the development verson of **agui**, not to be confused with
+the public version **pyThena** that only works with "*Athena-miniK*" that
+was extracted from this code base during the Aug 21-25 week at IAS.
+
+Here show some examples of executing **athena** using a dynamic GUI.
+nIn theory this could apply to any of the
 [Athena](https://www.athena-astro.app/) family (athena [AC], athena++
 [AX], or athenak [AK]). It is easiest to work with **athenak**, since
 all the problems are compiled into one executable. We cover some
 examples of athena++ below as well, since at the moment athenak is not
-yet public.
+yet public. For good historic measure, classic athenaC is also
+available.
 
 
 Related and inspired by is NEMO's **tkrun** and **run** frontends,
-but we aim to use python based software here.
+but we aim to use python based software here. The GUI directive we
+are proposing are an updated version of the one that was used in
+[tkrun](https://teuben.github.io/nemo/man_html/tkrun.l.html)
+
+## Quick Start Guide
+
+This **agui** is a convenience repo that can contain all dependant
+repos (athenac, athena, athenak and nemo). First get **agui**:
+
+      git clone https://github.com/teuben/agui
+      cd agui
+
+after which any of the components can be built, or pick the one you want to focus on:
+
+      make build_athenac
+      make build_athena
+      make build_athenak
+      make build_nemo
+      make build_python
+
+For some systems you may need to install additional software, which are assembled
+in the **requirement** files, e.g.
+
+### for Ubuntu Linux:
+
+      sudo apt install $(grep -v ^# requirements.apt)
+
+### for Redhat style Linux:
+
+      sudo dnf install $(grep -v ^# requirements.dnf)
+
+### for a Mac with brew:
+
+      brew install $(grep -v ^# requirements.brew)
+
+### for python (which should apply to any)
+
+      pip install -r requirements.txt
+
+How the user sets up python could be covered in a separate document. We do mention
+the **build_python** target listed before, which sets up a personal anaconda3 tree
+in this directory, but needs an additional
+
+      source anaconda3/python_start.sh
+
+to be activated in your shell.
+
+
+### Method-1:  using pyqt (the preferred method)
 
+Using native Qt is probably our preferred method of using the GUI, viz.
 
-## Example (athenak) 
+      ./pyqt_menu.py
+
+should show a  GUI where to select an athinput file. Everything should guide itself.
+
+### Method-2:  using pysg
+
+pySimpleGui (pysg) is an alternative method where you can pick the GUI from "qt" or "tkinter",
+and actually two more we didn't play with. Here you would start with
+
+      ./pysq_menu.py
+
+and again, since it's a GUI, things should guide itself.
+
+## Detailed Example (athenak) 
 
 Using **athenak** is preferred, as it has *all* problems compiled
-into the executable. Some older comments on athena++ can be found below.
+into one executable. Examples  using **athena++** can be found below.
 
-Again, an example how to compile and run the code
+First, an example how to compile and run the code
 
 ```bash
      git clone --recursive https://gitlab.com/theias/hpc/jmstone/athena-parthenon/athenak
@@ -28,14 +95,14 @@ Again, an example how to compile and run the code
      make -j
 ```
 
-or if you're lazy, use the Makefile in this directory:
+or if you're lazy, use the Makefile in this agui directory:
 
 ```bash
      make build
 ```     
 
-this takes a bit longer than athena++,
-mostly because the kokkos library has to be compiled with).   The binary is
+this compilation takes a bit longer than athena++,
+mostly because the kokkos library has to be compiled first.   The binary is
 now in **athenak/build/src/athena**.
 
 ```text
@@ -70,7 +137,7 @@ build/src/athena -i inputs/hydro/viscosity.athinput         -d run8
 ```
 
 
-## Example (athena++) using Linear Wave
+## Detailed Example (athena++) using Linear Wave
 
 First we grab and compile the code for the linear wave problem
 
@@ -90,13 +157,15 @@ After this we can run it
      bin/athena  -i inputs/hydro/athinput.linear_wave1d  -d run1
 ```          
 
-but the default output from that **athinput** file is the **vtk** data format, which for this demo will
+but the default output from that **athinput** file is the **vtk** data format, which for this GUI demo would
 be too complex to parse. TBD. For now we switch to the ascii table format, viz.
 
 ```bash
      bin/athena  -i inputs/hydro/athinput.linear_wave1d  -d run2 output2/file_type=tab
 ```
 
+which also shows how the GUI will have to deal with command line parameters beyond the -i and -d options.
+
 ### Animations
 
 First example is NEMO biased, effectively quickly plotting all **tab** files using tabplot. Noting that the second row
@@ -154,45 +223,82 @@ median: 2.50312      0.003125    1      -3.21566e-23 0       0       2.49757e-13
 
 # TKRUN format
 
-Old style V1 (the parameter setting and GUI specifications were separated):
+The old style V1 tkrun format separated the parameter setting from the GUI specification:
 
        #>  RADIO   mode=gauss              gauss,newton,leibniz
 
-new style V2 will allow us to mix the GUI specifications with
+but in the new style V2 will allow us to mix the GUI specifications with
 the (language dependent) key=val construct that gives it
 a default value, e.g.
 
-bash/csh:
+bash:
+ 
+       mode=gauss         # specify the integration method      #> RADIO   gauss,newton,leibniz
 
-       mode=gauss       # specify the integration method      #> RADIO   gauss,newton,leibniz
-       set mode = gauss # specify the integration method      #> RADIO   gauss,newton,leibniz
+csh:
+
+       set mode = gauss   # specify the integration method      #> RADIO   gauss,newton,leibniz
        
 python:
 
-       mode="gauss"     # specify the integration method      #> RADIO   gauss,newton,leibniz
+       mode="gauss"       # specify the integration method      #> RADIO   gauss,newton,leibniz
 
 athinput:
 
        <integration>
-       mode = gauss     # specify the integration method      #> RADIO   gauss,newton,leibniz
+       mode = gauss       # specify the integration method      #> RADIO   gauss,newton,leibniz
 
 
-but will still  leave open the option to build an executionar.
+but will still leave open the option to build an executionar.
 
-# Which GUI builder?
 
-We explored gooey and psg (pySimpleGui):
+# How to run AGUI
 
-     python gooey_run.py         linear_wave_hydro.athinput 
-     python gooey_special_run.py linear_wave_hydro.athinput 
+This is how we envision running **agui**:
 
-     python pysg_run.py          linear_wave_hydro.athinput
-     python pysg_special_run.py  linear_wave_hydro.athinput
+```text
+     agui [-i athinput] [-x athena] [-s scriptfile]
+
+     -i     optional athinput file. If not provided, a filebrowser will let you search for and select one
+            Default:  athinput
+     -x     name (and or location) of the athena executable to use.
+            Default: athena
+     -s     name of a script file where run commands will be appended to. This can act like a logfile
+            Default: agui.log
+```
+
+This will bring up a succession of 3 GUI's:
+
+1.  The (optional) athinput file selector. Here the defaults of all parameters are given
+
+2.  Setting parameters for the run
+    1. The "-d" run directory
+    2. parameters parsed from the athinput file (with or without the "#> GUI" specifications
+
+    The user can then run the simulation. This should probably detach from this GUI, maybe
+    bring up a progress bar in a new window, which will then morph into the results browser(s)
+    as described in the next two steps:
 
+3. History (.hst) file browser.  This is a file that as function of simulation time has stored a number
+   of variables. This GUI will allow you to plot any column vs. any other column using a standard
+   matplotlib windows embedded in the GUI. This will otherwise be a static plot, as time is one of
+   the columns in the history table.
 
+3. Results (1D: .tab) browser. This browser is similar to the history file browser, except results
+   are available for each selected dump time. An animation button will allow you to move through
+   time, as well as select two variables from the results table.
+
+This will of course fine for 1D problems, for 2D problems the last GUI ("plot1D") will be a "plot2D"
+widget that shows an image with a color-bar instead of a 1D plot. This has not been implemented yet.
+Also to be determined is the allowed format?  FITS and HDF ?
 
 # References
 
 1. athena++ GRMHD code and adaptive mesh refinement (AMR) framework - https://www.athena-astro.app/
 
 1. pyro: a python hydro code - https://github.com/python-hydro/pyro2 
+
+
+# History
+
+* summer 2023:  UMD students Anh Hoang Cao and Kylie Gong coding pyqt, gooey and pysimplegui examples (test1..9)
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000..e427bf9
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,83 @@
+# List of issues and todo's
+
+- python vs. python3 (just a worry if some have no python, but do have python3)
+
+- better detect what's available (tab, vtk, bin)
+  - use the -d flag in plot1.py for directory, it should auto-detect *.tab or tab/*.tab  [done]
+  - use vtk reader to grab vtk files (1d and 2d)  [no more vtk, we use bin]
+  - use bin reader (can do AMR, where vtk cannot) - check between
+
+- for output (run) directory, use basename of the problem set, and then run1, run2, ..... inside of those?
+  - the startup tool could look inside the problem run directories
+  - this closes the loop in running and reviewing old runs  
+
+- GUI peculiarities
+  - when browsing, a cancel does not repopulate with the old entry
+  - killing parent will not kill the children (could be an advanced option,
+    because it's nice killing a parent keeps the children alive.
+
+- option to integrate with a running athena
+
+- plot1d:  bring up multiple plots.  issue will be what scaling to use
+
+- plot2d:  allow option of contour with color, or just contour or just color. this would
+  (like in plot1d) give us option to combine two variables
+
+  
+
+# Older vis software from athenak
+
+Awkward to use, but here it is:
+
+      ./plot_tab.py  -i tab/LinWave.hydro_w.00000.tab  -n 100 -v dens
+
+and for 2D:
+
+      ./plot_slice.py run2/bin/OrszagTang.mhd_w_bcc.00001.bin dens show --notex
+
+but this only brings up one plot, no animation. our plot2d should do that
+
+
+# Features
+
+Stating perhaps the obvious, the different GUIs all have their own issues. Here is the current GUI list
+
+                           click_+/-  scroll_+/-    step<1      run?     comments
+     tkrun   (test1)       ok         not           ok		 -
+     qtrun   (test5)       ok         ok  
+     gooey   (test7)       ok         ok            ?            ?
+     pyqt    (test1        ok         ok            ok           ok
+     pysg-tk (test13)      ok         not           weird        not     step < 1 not working?
+     pysg-qt (test13)      ok         ok            ok           not
+ 
+
+
+# Python versions
+
+A recent nuisance is the label_props= and radio_props= arguments to
+matplotlib.widgets.RadioButtons(), introduces in matplotlib 3.7.0, but
+also with a missing module pyparsing. They can usually be solved by
+updating your modules in your python, viz.
+
+     pip install --upgrade matplotlib
+
+or
+
+     pip install -r requirements.txt
+     
+Here's a summary of older versions of python that gave us trouble. Again, the solution
+could we be to just update matplotlib.
+
+     distro:                python:    mpl:     comments
+     -------------------    -------    -----    --------
+     ubuntu 22.04           3.10.12    3.7.2      ok
+     ubuntu 22.04           3.10.12    3.5.1      unexpected keyword argument 'label_props'
+     anaconda3 2023.07-2    3.11.4     3.7.1      ok
+     anaconda3 2023.03-1    3.10.12               No module named 'pyparsing' - broken release?
+     anaconda3 2022.10      3.9.13     3.5.2      unexpected keyword argument 'label_props'
+
+where versions can be retrieved as follows:
+
+     python --version
+     python -c 'import matplotlib as m; print(m.__version__)'
+
diff --git a/VERSION b/VERSION
new file mode 100644
index 0000000..a88289c
--- /dev/null
+++ b/VERSION
@@ -0,0 +1 @@
+0.2-dev
diff --git a/aparser.py b/aparser.py
index 340bb14..a448c38 100644
--- a/aparser.py
+++ b/aparser.py
@@ -2,18 +2,24 @@
 
 # ^\s*((?:set)\s+)?([^#]+)\s*=([^#]+)(#.*)?#>\s+([^\s]+)(.*=[^\s]*)?(.+)?$
 # requires that each line has a #>
-def parse_generic(filename):
+def parse_generic(filename, silent=False):
+    with open(filename) as file:
+        return parse_s(file.readlines(), filename=filename, silent=silent)
 
+def parse_s(lines, filename=None, silent=False):
     #lines = file.readlines()
     recognized = ['.sh', '.csh', '.py', '.athinput'] # recognized filetypes
-    file = open(filename, 'r')
     data = {} # data from the file
     info = {} # info about the file (if athinput, then from the comment block usually)
-    type = '' # the type of the file (sh, csh, etc.)
+    type = None # the type of the file (sh, csh, etc.)
     block = '' # keeps track of the current block (athinput files only)
     
+    def sprint(s):
+        if not silent:
+            print(s)
+
     # check if filename has an extension
-    m = match('^([^\.]+)(..*)?$', filename)
+    m = match('^([^\.]+)(..*)?$', filename) if filename else None
     if m:
         ext = m.group(2)
         if m.group(1) == 'athinput': # currently athinput.* is the only prefix file type
@@ -21,17 +27,16 @@ def parse_generic(filename):
         elif ext in recognized:
             type = ext[1:] # remove the dot
         else:
-            print('File type not recognized, trying to determine from file content')
+            sprint('File type not recognized, trying to determine from file content')
 
-    # file.readlines() is only called once (i think)
-    for line in file.readlines():
+    for line in lines:
 
         # check for block line
         m = match('^\s*<(.+)>.*', line)
         if m:
             block = m.group(1).strip() + '/'
             if not type:
-                print('File type deduced to be athinput')
+                sprint('File type deduced to be athinput')
                 type = 'athinput'
             continue
 
@@ -49,7 +54,7 @@ def parse_generic(filename):
             if not type:
                 # if the set keyword is used, then its a csh file
                 if m.group(1):
-                    print('File type deduced to be csh')
+                    sprint('File type deduced to be csh')
                     type = 'csh'
                 # else still undetermined
             
@@ -62,7 +67,7 @@ def parse_generic(filename):
             if match('^\'.*\'|\".*\"$', value):
                 # for now, assume that quotes => python, otherwise impossible to deduce python code
                 if not type:
-                    print('File type deduced to be python')
+                    sprint('File type deduced to be python')
                     type = 'python'
                 value = value[1:-1]
 
@@ -85,7 +90,7 @@ def parse_generic(filename):
     
     # default to sh if a type was not deduced
     if not type:
-        print('Unable to deduce file type from content, defaulting to sh')
+        sprint('Unable to deduce file type from content, defaulting to sh')
         type = 'sh'
 
     # for athinput files, info should be empty
diff --git a/athena_problems.json b/athena_problems.json
new file mode 100644
index 0000000..df6073d
--- /dev/null
+++ b/athena_problems.json
@@ -0,0 +1,253 @@
+{
+   "athenac": {
+      "3D driven isothermal hydrodynamical turbulence": "./athenac/apps/athinput.turb",
+      "Einfeldt's 1-1-2-5 test.": "./athenac/tst/1D-hydro/athinput.einfeldt1125",
+      "Einfeldt's 1-2-0-3 test.": "./athenac/tst/1D-hydro/athinput.einfeldt1203",
+      "leveque": "./athenac/tst/1D-hydro/athinput.leveque",
+      "linear wave convergence": "./athenac/tst/particle/athinput.par_linearwave2d",
+      "linear wave convergence with 3 level 1 Domains": "./athenac/tst/1D-mhd/athinput.linear_wave1d-3lev1",
+      "Noh's colliding winds test (uses SHKSET1D problem generator!)": "./athenac/tst/1D-hydro/athinput.noh",
+      "planar gravitational flow": "./athenac/tst/2D-hydro/athinput.pgflow",
+      "Mach 3 shock interacting with a sine wave in the density (Example 6)": "./athenac/tst/1D-hydro/athinput.shu-osher",
+      "LeVeque's slowly moving shock": "./athenac/tst/1D-hydro/athinput.slow-moving-shock",
+      "Sod's shock tube": "./athenac/tst/3D-hydro/athinput.sod",
+      "LW variant on Sod's shock tube, adds a jump in transverse velocity": "./athenac/tst/1D-hydro/athinput.sod-lw",
+      "Toro's variant on Sod's shock tube, adds a sonic point in rarefaction": "./athenac/tst/1D-hydro/athinput.sod-toro",
+      "Two Interacting Blast Waves": "./athenac/tst/1D-hydro/athinput.twoibw",
+      "Brio & Wu shock tube": "./athenac/tst/2D-sr-mhd/athinput.brio-wu",
+      "Circularly Polarized Alfven Waves": "./athenac/tst/1D-mhd/athinput.cpaw1d",
+      "C-shock test": "./athenac/tst/1D-mhd/athinput.cshock1d",
+      "Riemann problem from Figure 1a of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj1a",
+      "Riemann problem from Figure 1b of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj1b",
+      "Riemann problem from Figure 2a of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj2a",
+      "Riemann problem from Figure 2b of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj2b",
+      "Riemann problem from Figure 3a of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj3a",
+      "Riemann problem from Figure 3b of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj3b",
+      "Riemann problem from Figure 4a of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj4a",
+      "Riemann problem from Figure 4b of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj4b",
+      "Riemann problem from Figure 4c of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj4c",
+      "Riemann problem from Figure 4d of Ryu & Jones (1995)": "./athenac/tst/1D-mhd/athinput.rj4d",
+      "Torrihlon shock tube": "./athenac/tst/1D-mhd/athinput.torrilhon",
+      "SR hydro shocktube problem 1": "./athenac/tst/1D-sr-hydro/athinput.mb4",
+      "SR hydro shocktube problem 2": "./athenac/tst/1D-sr-hydro/athinput.mb2",
+      "SR hydro shocktube problem 3": "./athenac/tst/1D-sr-hydro/athinput.mb3",
+      "Fast Shock 1": "./athenac/tst/1D-sr-mhd/athinput.FastShk1",
+      "Fast Shock 2": "./athenac/tst/1D-sr-mhd/athinput.FastShk2",
+      "Fast Shock 3": "./athenac/tst/1D-sr-mhd/athinput.FastShk3",
+      "SR mhd shocktube 1 from MUB (Brio & Wu)": "./athenac/tst/1D-sr-mhd/athinput.mub1",
+      "SR mhd shocktube 2 from MUB (Brio & Wu)": "./athenac/tst/1D-sr-mhd/athinput.mub2",
+      "SR mhd shocktube 3 from MUB (Brio & Wu)": "./athenac/tst/1D-sr-mhd/athinput.mub3",
+      "SR mhd shocktube 4 from MUB (Brio & Wu)": "./athenac/tst/1D-sr-mhd/athinput.mub4",
+      "SR mhd isolated contact wave from MUB (Brio & Wu)": "./athenac/tst/1D-sr-mhd/athinput.mubcontact",
+      "SR mhd isolated rotational wave from MUB (Brio & Wu)": "./athenac/tst/1D-sr-mhd/athinput.mubrot",
+      "Slow Shock": "./athenac/tst/1D-sr-mhd/athinput.SlowShock",
+      "Switch Off Fast Rarefaction": "./athenac/tst/1D-sr-mhd/athinput.SWoffFRF",
+      "Switch On Fast Rarefaction": "./athenac/tst/1D-sr-mhd/athinput.SWonSRF",
+      "Blast wave": "./athenac/tst/3D-sr-mhd/athinput.blast",
+      "carbuncle test": "./athenac/tst/3D-hydro/athinput.carbuncle",
+      "double Mach reflection": "./athenac/tst/2D-hydro/athinput.dmr",
+      "jeans problem (standing wave; stable or unstable)": "./athenac/tst/2D-hydro/athinput.jeans",
+      "KH instability of slip surface": "./athenac/tst/2D-hydro/athinput.kh",
+      "2D implosion from Liska & Wendroff": "./athenac/tst/2D-hydro/athinput.lw_implode",
+      "non-linear non-axisymmetric shearing wave test": "./athenac/tst/3D-hydro/athinput.nl-shwave",
+      "Noh's strong shock test in 2D": "./athenac/tst/2D-hydro/athinput.noh",
+      "RT instability": "./athenac/tst/2D-hydro/athinput.rt",
+      "shock cloud interaction": "./athenac/tst/3D-hydro/athinput.shk_cloud",
+      "blast_B1": "./athenac/tst/2D-mhd/athinput.blast_B1",
+      "blast_B10": "./athenac/tst/3D-mhd/athinput.blast_B10",
+      "2D Circularly Polarized Alfven Wave": "./athenac/tst/2D-mhd/athinput.cpaw2d",
+      "field loop advection test": "./athenac/tst/3D-mhd/athinput.field_loop4",
+      "hall_drift": "./athenac/tst/2D-mhd/athinput.hall_drift",
+      "2D MRI": "./athenac/tst/2D-mhd/athinput.hb3",
+      "MHD KH instability": "./athenac/tst/2D-mhd/athinput.kh",
+      "Orszag-Tang vortex": "./athenac/tst/2D-mhd/athinput.orszag-tang",
+      "Riemann problem from Figure 2a of Ryu & Jones (1995) in 2D": "./athenac/tst/2D-mhd/athinput.rj2a",
+      "First rotor test": "./athenac/tst/2D-mhd/athinput.rotor",
+      "MHD RT instability": "./athenac/tst/3D-mhd/athinput.rt",
+      "Temperature conduction test": "./athenac/tst/3D-mhd/athinput.Tconduct",
+      "SR hydro jet": "./athenac/tst/3D-sr-hydro/athinput.jet",
+      "current-sheet": "./athenac/tst/2D-sr-mhd/athinput.current-sheet",
+      "SR MHD jet": "./athenac/tst/3D-sr-mhd/athinput.jet",
+      "FFT test for SMR and MPI": "./athenac/tst/3D-hydro/athinput.fft_test",
+      "nonlinear density wave test": "./athenac/tst/3D-hydro/athinput.fp-wave",
+      "Noh's strong shock test in 3D": "./athenac/tst/3D-hydro/athinput.noh",
+      "planar gravitational flow, runs 2D problem in 3D": "./athenac/tst/3D-hydro/athinput.pgflow",
+      "3D shearing wave test": "./athenac/tst/3D-hydro/athinput.shwave",
+      "Thermal Instability Test": "./athenac/tst/3D-hydro/athinput.ti_test",
+      "3D Circularly Polarized Alfven Wave": "./athenac/tst/3D-mhd/athinput.cpaw3d",
+      "3D MRI": "./athenac/tst/3D-mhd/athinput.hgb",
+      "MSA test for 3D using Jeans' swindle": "./athenac/tst/3D-mhd/athinput.msa",
+      "Riemann problem from Figure 2a of Ryu & Jones (1995) in 3D": "./athenac/tst/3D-mhd/athinput.rj2a",
+      "Stratified 3D MRI with zero-net vertical flux": "./athenac/tst/3D-mhd/athinput.strat",
+      "Advection (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cyladvect-3D",
+      "Hydrodynamic blast wave (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylblast_B0-3D",
+      "cylblast_B10-2D": "./athenac/tst/cylindrical/athinput.cylblast_B10-2D",
+      "cylblast_B10-3D": "./athenac/tst/cylindrical/athinput.cylblast_B10-3D",
+      "cylblast_B1-2D": "./athenac/tst/cylindrical/athinput.cylblast_B1-2D",
+      "cylblast_B1-3D": "./athenac/tst/cylindrical/athinput.cylblast_B1-3D",
+      "Force balance tests, B_phi only (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylbphi-3D",
+      "Force balance tests, B_R only (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylbr-3D",
+      "diffusion (CYLINDRICAL); integrator must be turned off!": "./athenac/tst/cylindrical/athinput.cyldiff",
+      "Field Loop Advection (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylfieldloop-3D",
+      "Global Newtonian Disk (Unstratified, global, cylindrical)": "./athenac/tst/cylindrical/athinput.cylnewtmri",
+      "Rayleigh instability test (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylrayleigh-3D",
+      "Global spiral arms test (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylspiral-2D",
+      "Axisymmetric hydrodynamic wind, no rotation (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylwind-3D",
+      "Axisymmetric rotating hydrodynamic wind (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylwindrot-3D",
+      "Axisymmetric rotating MHD wind (CYLINDRICAL)": "./athenac/tst/cylindrical/athinput.cylwindrotb-3D",
+      "HK Accretion Disk, cylindrical coords": "./athenac/tst/cylindrical/athinput.hkdisk-3D",
+      "particle code test: circular flow": "./athenac/tst/particle/athinput.par_circ",
+      "particle-gas \"collision\" test": "./athenac/tst/particle/athinput.par_collision",
+      "particle code test: epicyclic motion": "./athenac/tst/particle/athinput.par_epicycle",
+      "particle code test: friction test": "./athenac/tst/particle/athinput.par_friction",
+      "shear wave test with particles": "./athenac/tst/particle/athinput.par_shwave1d",
+      "shear wave with particles": "./athenac/tst/particle/athinput.par_shwave2d",
+      "Streaming instability in non-stratified disks": "./athenac/tst/particle/athinput.streaming3d_single"
+   },
+   "athena": {
+      "cosmic ray diffusion": "./athena/inputs/cosmic_ray/athinput.cr_diffusion",
+      "poisson's solver test": "./athena/inputs/hydro/athinput.poisson",
+      "spherical blast wave": "./athena/inputs/hydro/athinput.blast",
+      "spherical blast wave in cylindrical coordinates": "./athena/inputs/hydro/athinput.blast_cyl",
+      "spherical blast wave in spherical coordinates": "./athena/inputs/hydro/athinput.blast_sph",
+      "Protostellar collapse": "./athena/inputs/mhd/athinput.collapse",
+      "Keplerian disk in cylindrical coordinates": "./athena/inputs/hydro/athinput.disk_cyl",
+      "Keplerian disk in spherical polar coordinates": "./athena/inputs/hydro/athinput.disk_sph",
+      "double Mach reflection": "./athena/inputs/hydro/athinput.dmr_amr",
+      "Einfeldt's 1-1-2-5 test": "./athena/inputs/hydro/athinput.einfeldt1125",
+      "Einfeldt's 1-2-0-3 test": "./athena/inputs/hydro/athinput.einfeldt1203",
+      "Testing and debugging the compiled EOS to ensure correct behavior.": "./athena/inputs/hydro/athinput.eos_test",
+      "FFT test and timing": "./athena/inputs/hydro/athinput.fft",
+      "Jeans test": "./athena/inputs/hydro/athinput.jeans_3d",
+      "underdense Mach10 jet": "./athena/inputs/hydro/athinput.jet",
+      "Kelvin-Helmholtz instability": "./athena/inputs/mhd/athinput.kh-shear-lecoanet",
+      "1D Hydro linear wave convergence": "./athena/inputs/hydro/athinput.linear_wave1d",
+      "2D Hydro linear wave convergence": "./athena/inputs/hydro/athinput.linear_wave2d",
+      "3D Hydro linear wave convergence": "./athena/inputs/hydro/athinput.linear_wave3d",
+      "2D implosion from Liska & Wendroff": "./athena/inputs/hydro/athinput.lw_implode",
+      "1D passive scalar advection of Gaussian profile along the meridional coordinate": "./athena/inputs/hydro/athinput.mignone_meridional",
+      "1D passive scalar advection of Gaussian profile along the radial coordinate": "./athena/inputs/hydro/athinput.mignone_radial",
+      "Noh's strong shock test in 2D": "./athena/inputs/hydro/athinput.noh2d",
+      "Quirk's Carbuncle test": "./athena/inputs/hydro/athinput.quirk",
+      "Rayleigh-Taylor instability": "./athena/inputs/hydro/athinput.rt3d",
+      "scalar diffusion": "./athena/inputs/hydro/athinput.scalar_diff",
+      "shock cloud interaction": "./athena/inputs/hydro/athinput.shk_cloud",
+      "Mach 3 shock interacting with a sine wave in the density (Example 6)": "./athena/inputs/hydro/athinput.shu_osher",
+      "advection of a 2D slotted cylinder passive scalar profile": "./athena/inputs/hydro/athinput.slotted_cylinder2d",
+      "advection of a 2D slotted cylinder passive scalar profile (with SMR or AMR)": "./athena/inputs/hydro/athinput.slotted_cylinder2d_refined",
+      "Slow moving shock causes post-shock oscillations": "./athena/inputs/hydro/athinput.slow_shock",
+      "Sod's shock tube": "./athena/inputs/hydro/athinput.sod",
+      "A Sod-like shock tube for testing general EOS; initialize temp not pres": "./athena/inputs/mhd/athinput.sod_general_H",
+      "HD shwave test": "./athena/inputs/hydro/athinput.ssheet",
+      "Turbulence with power-law PS": "./athena/inputs/hydro/athinput.turb",
+      "Two Interacting Blast Waves": "./athena/inputs/hydro/athinput.twoibw",
+      "viscous diffusion": "./athena/inputs/hydro/athinput.visc",
+      "GR hydro accretion in radial direction": "./athena/inputs/hydro_gr/athinput.bondi",
+      "Geodesic infall (Hydro only)": "./athena/inputs/hydro_gr/athinput.geodesic",
+      "1D linear wave": "./athena/inputs/mhd_sr/athinput.linear_wave",
+      "SR hydro shocktube problem 1": "./athena/inputs/hydro_sr/athinput.mb_1",
+      "SR hydro shocktube problem 2": "./athena/inputs/hydro_sr/athinput.mb_2",
+      "SR hydro shocktube problem 3": "./athena/inputs/hydro_sr/athinput.mb_3",
+      "SR hydro shocktube problem 4": "./athena/inputs/hydro_sr/athinput.mb_4",
+      "spherical MHD blast wave": "./athena/inputs/mhd/athinput.blast",
+      "spherical MHD blast wave in cylindrical coordinates": "./athena/inputs/mhd/athinput.blast_cyl",
+      "spherical MHD blast wave in spherical coordinates": "./athena/inputs/mhd/athinput.blast_sph",
+      "Brio & Wu shock tube": "./athena/inputs/mhd/athinput.bw",
+      "2D Circularly Polarized Alfven Wave": "./athena/inputs/mhd/athinput.cpaw2d",
+      "field loop advection test": "./athena/inputs/mhd/athinput.field_loop",
+      "field loop advection test through poles in spherical polar coords": "./athena/inputs/mhd/athinput.field_loop_poles",
+      "preexisting array": "./athena/inputs/mhd/athinput.from_array",
+      "2D MRI": "./athena/inputs/mhd/athinput.hb3",
+      "3D MRI test": "./athena/inputs/mhd/athinput.hgb",
+      "MHD shwave test": "./athena/inputs/mhd/athinput.jgg",
+      "1D MHD linear wave convergence": "./athena/inputs/mhd/athinput.linear_wave1d",
+      "2D MHD linear wave convergence": "./athena/inputs/mhd/athinput.linear_wave2d",
+      "2D MHD linear wave convergence with AMR": "./athena/inputs/mhd/athinput.linear_wave2d_amr",
+      "3D MHD linear wave convergence": "./athena/inputs/mhd/athinput.linear_wave3d",
+      "3D MHD linear wave convergence with AMR": "./athena/inputs/mhd/athinput.linear_wave3d_amr",
+      "Z-pinch; Magnetized Noh with axial and azimuthal field": "./athena/inputs/mhd/athinput.magnoh3",
+      "Orszag-Tang vortex": "./athena/inputs/mhd/athinput.orszag-tang",
+      "resistive diffusion": "./athena/inputs/mhd/athinput.resist",
+      "Riemann problem from Figure 2a of Ryu & Jones (1995)": "./athena/inputs/mhd/athinput.rj2a",
+      "MHD Rotor": "./athena/inputs/mhd/athinput.rotor",
+      "Stratified 3D MRI with zero-net vertical flux": "./athena/inputs/mhd/athinput.strat",
+      "Test outputs based on Orszag-Tang vortex": "./athena/inputs/mhd/athinput.test_outputs",
+      "GR MHD spherical blast wave": "./athena/inputs/mhd_gr/athinput.blast",
+      "Fishbone-Moncrief equilibrium torus": "./athena/inputs/mhd_gr/athinput.fm_torus",
+      "magnetized_inflow": "./athena/inputs/mhd_gr/athinput.magnetized_inflow",
+      "SR MHD shocktube problem 1": "./athena/inputs/mhd_sr/athinput.mub_1",
+      "SR MHD shocktube problem 2": "./athena/inputs/mhd_sr/athinput.mub_2",
+      "SR MHD shocktube problem 3": "./athena/inputs/mhd_sr/athinput.mub_3",
+      "SR MHD shocktube problem 4": "./athena/inputs/mhd_sr/athinput.mub_4",
+      "Radiation linear wave test": "./athena/inputs/radiation/athinput.rad_linearwave_amr",
+      "Radiation thermal relaxation with multi-group": "./athena/inputs/radiation/athinput.thermal_multigroup",
+      "Radiation thermal relaxation test": "./athena/inputs/radiation/athinput.thermal_relaxation"
+   },
+   "athenak": {
+      "gr_fm_torus_sane_uniform": "./athenak/inputs/grhydro/gr_fm_torus_sane_uniform.athinput",
+      "blast_grmhd_amr": "./athenak/inputs/grmhd/blast_grmhd_amr.athinput",
+      "gr_chakrabarti_torus_sane_8_4": "./athenak/inputs/grmhd/gr_chakrabarti_torus_sane_8_4.athinput",
+      "gr_fm_torus_mad_8_4": "./athenak/inputs/grmhd/gr_fm_torus_mad_8_4.athinput",
+      "gr_fm_torus_sane_8_4": "./athenak/inputs/grmhd/gr_fm_torus_sane_8_4.athinput",
+      "mub1-gr": "./athenak/inputs/grmhd/mub1-gr.athinput",
+      "blast_hydro_amr": "./athenak/inputs/hydro/blast_hydro_amr.athinput",
+      "blast_hydro": "./athenak/inputs/hydro/blast_hydro.athinput",
+      "kh2d-lecoanet": "./athenak/inputs/hydro/kh2d-lecoanet.athinput",
+      "lw_implode": "./athenak/inputs/hydro/lw_implode.athinput",
+      "rt2d": "./athenak/inputs/hydro/rt2d.athinput",
+      "shock_cloud": "./athenak/inputs/hydro/shock_cloud.athinput",
+      "shu_osher": "./athenak/inputs/hydro/shu_osher.athinput",
+      "slotted_cyl": "./athenak/inputs/hydro/slotted_cyl.athinput",
+      "sod": "./athenak/inputs/hydro/sod.athinput",
+      "turb": "./athenak/inputs/hydro/turb.athinput",
+      "viscosity": "./athenak/inputs/hydro/viscosity.athinput",
+      "blast_2fluid_amr": "./athenak/inputs/ion-neutral/blast_2fluid_amr.athinput",
+      "blast_2fluid": "./athenak/inputs/ion-neutral/blast_2fluid.athinput",
+      "blast_mhd_amr": "./athenak/inputs/mhd/blast_mhd_amr.athinput",
+      "blast_mhd": "./athenak/inputs/mhd/blast_mhd.athinput",
+      "bw": "./athenak/inputs/mhd/bw.athinput",
+      "current_sheet": "./athenak/inputs/mhd/current_sheet.athinput",
+      "kh2d-lecoanet-mhd": "./athenak/inputs/mhd/kh2d-lecoanet-mhd.athinput",
+      "mri2d": "./athenak/inputs/mhd/mri2d.athinput",
+      "orszag_tang": "./athenak/inputs/mhd/orszag_tang.athinput",
+      "resistivity": "./athenak/inputs/mhd/resistivity.athinput",
+      "rt2d-mhd": "./athenak/inputs/mhd/rt2d-mhd.athinput",
+      "beam": "./athenak/inputs/radiation/beam.athinput",
+      "bh_beam": "./athenak/inputs/radiation/bh_beam.athinput",
+      "hohlraum_2d": "./athenak/inputs/radiation/hohlraum_2d.athinput",
+      "rad_diffusion": "./athenak/inputs/radiation/rad_diffusion.athinput",
+      "rad_fm_sane_8_4": "./athenak/inputs/radiation/rad_fm_sane_8_4.athinput",
+      "relax": "./athenak/inputs/radiation/relax.athinput",
+      "shadow": "./athenak/inputs/radiation/shadow.athinput",
+      "snake": "./athenak/inputs/radiation/snake.athinput",
+      "blast_srhyd": "./athenak/inputs/srhydro/blast_srhyd.athinput",
+      "kh_srhyd1": "./athenak/inputs/srhydro/kh_srhyd1.athinput",
+      "mb1": "./athenak/inputs/srhydro/mb1.athinput",
+      "mb2": "./athenak/inputs/srhydro/mb2.athinput",
+      "mb3": "./athenak/inputs/srhydro/mb3.athinput",
+      "mb4": "./athenak/inputs/srhydro/mb4.athinput",
+      "blast_srmhd": "./athenak/inputs/srmhd/blast_srmhd.athinput",
+      "mub1": "./athenak/inputs/srmhd/mub1.athinput",
+      "mub2": "./athenak/inputs/srmhd/mub2.athinput",
+      "mub3": "./athenak/inputs/srmhd/mub3.athinput",
+      "mub4": "./athenak/inputs/srmhd/mub4.athinput",
+      "advect_hyd": "./athenak/inputs/tests/advect_hyd.athinput",
+      "advect_mhd": "./athenak/inputs/tests/advect_mhd.athinput",
+      "bondi": "./athenak/inputs/tests/bondi.athinput",
+      "cpaw3d": "./athenak/inputs/tests/cpaw3d.athinput",
+      "cpaw3d_smr": "./athenak/inputs/tests/cpaw3d_smr.athinput",
+      "hohlraum_1d": "./athenak/inputs/tests/hohlraum_1d.athinput",
+      "linear_wave_hydro_amr": "./athenak/inputs/tests/linear_wave_hydro_amr.athinput",
+      "linear_wave_hydro": "./athenak/inputs/tests/linear_wave_hydro.athinput",
+      "linear_wave_hydro_smr": "./athenak/inputs/tests/linear_wave_hydro_smr.athinput",
+      "linear_wave_mhd_amr": "./athenak/inputs/tests/linear_wave_mhd_amr.athinput",
+      "linear_wave_mhd": "./athenak/inputs/tests/linear_wave_mhd.athinput",
+      "linear_wave_mhd_smr": "./athenak/inputs/tests/linear_wave_mhd_smr.athinput",
+      "linear_wave_z4c": "./athenak/inputs/tests/linear_wave_z4c.athinput",
+      "monopole": "./athenak/inputs/tests/monopole.athinput",
+      "rad_linwave": "./athenak/inputs/tests/rad_linwave.athinput",
+      "tetrad": "./athenak/inputs/tests/tetrad.athinput",
+      "z4c_onepuncture": "./athenak/inputs/z4c/onepuncture/z4c_onepuncture.athinput",
+      "z4c_twopuncture": "./athenak/inputs/z4c/twopuncture/z4c_twopuncture.athinput"
+   }
+}
\ No newline at end of file
diff --git a/example4.py b/example4.py
index 4c2eef0..ab4cb42 100755
--- a/example4.py
+++ b/example4.py
@@ -1,26 +1,30 @@
 #! /usr/bin/env python
 #
-# new 2023 style python 
+# new 2023 style python
 
-file1   = 'foo'       # help for input file1          #> IFILE file1=
-file2   = 'bar'       # help for output file2         #> OFILE file2=
-dir3    = 'fum'       # help for input dir3           #> IDIR  dir3=
-dir4    = 'baz'       # help for output dir4          #> ODIR  dir4=
-hello   = 'world'     # help for text entry hello     #> ENTRY hello=world
-a       = 1           # help for a, between 0 and 2   #> SCALE a=1       0:2:0.1
-b       = '2'         # help for b, pick 1, 2 or 3    #> RADIO b=2       0,1,2
-c       = '3,c'       # help for c, check any of 6    #> CHECK c=3       1,2,3,a,b,c
-
-#
 import sys
+
+file1 = "foo"       # help for input file1          #> IFILE
+file2 = "bar"       # help for output file2         #> OFILE
+dir3  = "fum"       # help for input dir3           #> IDIR
+dir4  =  "baz"      # help for output dir4          #> ODIR
+hello = "world"     # help for text entry hello     #> ENTRY
+a     = "1"         # help for a, between 0 and 2   #> SCALE       0:2:0.1
+b     = "2"         # help for b, pick 1, 2 or 3    #> RADIO       0,1,2
+c     = "3,c"       # help for c, check any of 6    #> CHECK       0,1,2,a,b,c
+
+# parse the key=val command line
 for _arg in sys.argv[1:]:
-    exec(_arg)
+    ie = _arg.find('=')
+    cmd = '%s="%s"' % (_arg[:ie],_arg[ie+1:])
+    exec(cmd)
 
-print('file1=',file1)
-print('file2=',file2)
-print('dir3=',dir3)
-print('dir4=',dir4)
-print('hello=',hello)
-print('a=',a)
-print('b=',b)
-print('c=',c)
+# print keyword vaues
+print('file1',file1)
+print('file2',file2)
+print('dir3', dir3)
+print('dir4', dir4)
+print('hello',hello)
+print('a',    a)
+print('b',    b)
+print('c',    c)
diff --git a/formats.txt b/formats.txt
index ca0054f..223e3f0 100644
--- a/formats.txt
+++ b/formats.txt
@@ -9,14 +9,14 @@ set rmax    = 1         #> SCALE rmax=1       0:2:0.1
 set vscale  = 0.9       #> SCALE vscale=0.9   -2:2:0.1
 set outflow = 0.4       #> SCALE outflow=0.4  0:2:0.1
 
-# new CSH
+# new CSH (but without optional help)
 set nbody   = 10000     #> SCALE  1000:1000000:1000
 set rmin    = 0.3       #> SCALE  0:1:0.1
 set rmax    = 1         #> SCALE  0:2:0.1
 set vscale  = 0.9       #> SCALE -2:2:0.1
 set outflow = 0.4       #> SCALE  0:2:0.1
 
-# new SH
+# new SH (but without optional help)
   nbody=10000     #> SCALE  1000:1000000:1000
    rmin=0.3       #> SCALE  0:1:0.1
    rmax=1         #> SCALE  0:2:0.1
@@ -24,7 +24,7 @@ set outflow = 0.4       #> SCALE  0:2:0.1
 outflow=0.4       #> SCALE  0:2:0.1
    file=foobar
 
-# new python
+# new python (without optional help)
 
   nbody=10000     #> SCALE  1000:1000000:1000
    rmin=0.3       #> SCALE  0:1:0.1
@@ -33,3 +33,17 @@ outflow=0.4       #> SCALE  0:2:0.1
 outflow=0.4       #> SCALE  0:2:0.1
 file="foobar"     #> IFILE
 
+# extended  (new) format
+
+This is the proposed new format that should fit (c)sh, python and athinput. athinput is special, since the
+<block>'s in the athinput file gets translated to block/key=val for the commandline.
+
+The help goes between the defaults for key=val and the '#>' GUI directive.
+
+#<mesh>
+nx1=64          # Number of zones in X1-direction                #> SCALE  16:512:16
+nx2=32          # Number of zones in X2-direction                #> RADIO  1,16,32,64,128,256
+nx3=32          # Number of zones in X3-direction                #> RADIO  1,16,32,64,128,256
+<time>
+time/cfl_number=0.3  # The Courant, Friedrichs, & Lewy (CFL) Number   #> SCALE  0:1.2:0.1
+time/tlim=5.0        # time limit                                     #> SCALE  1:100:1
diff --git a/gooey_run2.py b/gooey_run2.py
index 1fd33e2..f93d116 100755
--- a/gooey_run2.py
+++ b/gooey_run2.py
@@ -5,8 +5,19 @@
 from aparser import parse_generic as parse
 from argparse import ArgumentParser
 
+def rm_dot(x):
+    # being too precise causes problems, but hopefully this is enough
+    s = '%.8g' % float(x)
+    dot_pos = s.rfind('.')
+    if dot_pos < 0:
+        return int(s)
+    s = s.replace('.', '')
+    return int(s)
+
 cwd = getcwd()
 
+options = {}
+
 # parsing arguments
 argparser = ArgumentParser(description='Creates a GUI script, then runs it. The GUI will allow for configuring the provided athinput file')
 argparser.add_argument('file', help='the athinput file to configure')
@@ -29,15 +40,24 @@
 @Gooey(program_name=\'gooey_run2\')\n\
 def main():\n\
 \tparser = GooeyParser(description=\'Problem: {name}\\nReference: {reference}\')\n\
-\tparser.add_argument(\'output_dir\', help=\'The directory where the output files will be dumped\', metavar=\'output directory\', default=\'{cwd}\', widget=\'DirChooser\')\n')
+\tparser.add_argument(\'--output_dir\', help=\'The directory where the output files will be dumped\', metavar=\'output directory\', default=\'{cwd}\', widget=\'DirChooser\')\n')
 
-# for some reason 
+#>  IFILE   in=
+#>  OFILE   out=
+#>  IDIR    indir=
+#>  ODIR    odir=
+#>  ENTRY   eps=0.01
+#>  RADIO   mode=gauss              gauss,newton,leibniz
+#>  CHECK   options=mean,sigma      sum,mean,sigma,skewness,kurtosis
+#>  SCALE   n=3.141592              0:10:0.01
+i = 0
 for k in data:
     e = data[k]
-    if e['gtype'] == 'ENTRY' or e['gtype'] == 'SCALE': # no sliders in gooey?
+    t = e['gtype']
+    if t == 'ENTRY':
         # entry = text box
-        file.write('\tparser.add_argument(\'%s\', help=\'%s\', metavar=\'%s\', default=\'%s\')\n' % (k, e['help'][1:].strip(), k, e['value']))
-    elif e['gtype'] == 'RADIO': # currently dropdown menus and not radio buttons
+        file.write('\tparser.add_argument(\'--%s\', help=\'%s\', metavar=\'%s\', default=\'%s\')\n' % (k, e['help'][1:].strip(), k, e['value']))
+    elif t == 'RADIO': # currently dropdown menus and not radio buttons, radio buttons seem to be a massive pain
         # number of options is not predetermined, so can't use regex
         options = e['gparams'].split(',')
         # create string list
@@ -45,7 +65,21 @@ def main():\n\
         for o in options:
             c += f'\'{o}\',' # not wrapping o in quotes causes an error
         c += ']'
-        file.write('\tparser.add_argument(\'%s\', help=\'%s\', metavar=\'%s\', choices=%s, default=\'%s\')\n' % (k, e['help'][1:].strip(), k, c, e['value']))
+        file.write('\tparser.add_argument(\'--%s\', help=\'%s\', metavar=\'%s\', choices=%s, default=\'%s\')\n' % (k, e['help'][1:].strip(), k, c, e['value']))
+        '''file.write('\tgroup = parser.add_argument_group()\n')
+        file.write('\trgroup = group.add_mutually_exclusive_group()\n')
+        for o in options:
+            if o in options:
+                
+            file.write('\trgroup.add_argument(\'--%s\', action=\'store_true\')\n' % ('option', i))'''
+    elif t == 'SCALE':
+        [minimum, maximum, increment] = e['gparams'].split(':')
+        # scale = slider
+        # build sliders differently depending on whether tk or qt is used
+        scaled_default = rm_dot(e['value'])
+        scale = round(scaled_default / float(e['value']))
+        file.write('\tparser.add_argument(\'--%s\', help=\'%s\\nscale: %s\', metavar=\'%s\', default=%s, widget=\'Slider\', gooey_options={\'min\':%s, \'max\':%s, \'increment\':%s})\n' 
+                   % (k, e['help'][1:].strip(), 1 / scale, k, scaled_default, rm_dot(minimum), rm_dot(maximum), rm_dot(increment)))
     else:
         print('GUI type %s not implemented' & e['gtype'])
         exit()
diff --git a/inputs.txt b/inputs.txt
index 03922ab..2883723 100644
--- a/inputs.txt
+++ b/inputs.txt
@@ -1,3 +1,160 @@
+./athenac/apps/athinput.turb
+./athenac/tst/1D-hydro/athinput.einfeldt1125
+./athenac/tst/1D-hydro/athinput.einfeldt1203
+./athenac/tst/1D-hydro/athinput.leveque
+./athenac/tst/1D-hydro/athinput.linear_wave1d
+./athenac/tst/1D-hydro/athinput.linear_wave1d-3lev1
+./athenac/tst/1D-hydro/athinput.noh
+./athenac/tst/1D-hydro/athinput.pgflow
+./athenac/tst/1D-hydro/athinput.shu-osher
+./athenac/tst/1D-hydro/athinput.slow-moving-shock
+./athenac/tst/1D-hydro/athinput.sod
+./athenac/tst/1D-hydro/athinput.sod-lw
+./athenac/tst/1D-hydro/athinput.sod-toro
+./athenac/tst/1D-hydro/athinput.twoibw
+./athenac/tst/1D-mhd/athinput.brio-wu
+./athenac/tst/1D-mhd/athinput.cpaw1d
+./athenac/tst/1D-mhd/athinput.cshock1d
+./athenac/tst/1D-mhd/athinput.linear_wave1d
+./athenac/tst/1D-mhd/athinput.linear_wave1d-3lev1
+./athenac/tst/1D-mhd/athinput.rj1a
+./athenac/tst/1D-mhd/athinput.rj1b
+./athenac/tst/1D-mhd/athinput.rj2a
+./athenac/tst/1D-mhd/athinput.rj2b
+./athenac/tst/1D-mhd/athinput.rj3a
+./athenac/tst/1D-mhd/athinput.rj3b
+./athenac/tst/1D-mhd/athinput.rj4a
+./athenac/tst/1D-mhd/athinput.rj4b
+./athenac/tst/1D-mhd/athinput.rj4c
+./athenac/tst/1D-mhd/athinput.rj4d
+./athenac/tst/1D-mhd/athinput.torrilhon
+./athenac/tst/1D-sr-hydro/athinput.mb1
+./athenac/tst/1D-sr-hydro/athinput.mb2
+./athenac/tst/1D-sr-hydro/athinput.mb3
+./athenac/tst/1D-sr-hydro/athinput.mb4
+./athenac/tst/1D-sr-mhd/athinput.brio-wu
+./athenac/tst/1D-sr-mhd/athinput.FastShk1
+./athenac/tst/1D-sr-mhd/athinput.FastShk2
+./athenac/tst/1D-sr-mhd/athinput.FastShk3
+./athenac/tst/1D-sr-mhd/athinput.K99sod1
+./athenac/tst/1D-sr-mhd/athinput.K99sod2
+./athenac/tst/1D-sr-mhd/athinput.mub1
+./athenac/tst/1D-sr-mhd/athinput.mub2
+./athenac/tst/1D-sr-mhd/athinput.mub3
+./athenac/tst/1D-sr-mhd/athinput.mub4
+./athenac/tst/1D-sr-mhd/athinput.mubcontact
+./athenac/tst/1D-sr-mhd/athinput.mubrot
+./athenac/tst/1D-sr-mhd/athinput.SlowShock
+./athenac/tst/1D-sr-mhd/athinput.SWoffFRF
+./athenac/tst/1D-sr-mhd/athinput.SWonSRF
+./athenac/tst/2D-hydro/athinput.blast
+./athenac/tst/2D-hydro/athinput.carbuncle
+./athenac/tst/2D-hydro/athinput.dmr
+./athenac/tst/2D-hydro/athinput.jeans
+./athenac/tst/2D-hydro/athinput.kh
+./athenac/tst/2D-hydro/athinput.linear_wave2d
+./athenac/tst/2D-hydro/athinput.linear_wave2d-3lev1
+./athenac/tst/2D-hydro/athinput.lw_implode
+./athenac/tst/2D-hydro/athinput.nl-shwave
+./athenac/tst/2D-hydro/athinput.noh
+./athenac/tst/2D-hydro/athinput.pgflow
+./athenac/tst/2D-hydro/athinput.rt
+./athenac/tst/2D-hydro/athinput.shk_cloud
+./athenac/tst/2D-hydro/athinput.sod
+./athenac/tst/2D-mhd/athinput.blast_B1
+./athenac/tst/2D-mhd/athinput.blast_B10
+./athenac/tst/2D-mhd/athinput.cpaw2d
+./athenac/tst/2D-mhd/athinput.field_loop
+./athenac/tst/2D-mhd/athinput.hall_drift
+./athenac/tst/2D-mhd/athinput.hb3
+./athenac/tst/2D-mhd/athinput.kh
+./athenac/tst/2D-mhd/athinput.linear_wave2d
+./athenac/tst/2D-mhd/athinput.linear_wave2d-3lev1
+./athenac/tst/2D-mhd/athinput.orszag-tang
+./athenac/tst/2D-mhd/athinput.rj2a
+./athenac/tst/2D-mhd/athinput.rotor
+./athenac/tst/2D-mhd/athinput.rt
+./athenac/tst/2D-mhd/athinput.Tconduct
+./athenac/tst/2D-sr-hydro/athinput.blast
+./athenac/tst/2D-sr-hydro/athinput.jet
+./athenac/tst/2D-sr-mhd/athinput.blast
+./athenac/tst/2D-sr-mhd/athinput.brio-wu
+./athenac/tst/2D-sr-mhd/athinput.current-sheet
+./athenac/tst/2D-sr-mhd/athinput.jet
+./athenac/tst/3D-hydro/athinput.blast
+./athenac/tst/3D-hydro/athinput.carbuncle
+./athenac/tst/3D-hydro/athinput.fft_test
+./athenac/tst/3D-hydro/athinput.fp-wave
+./athenac/tst/3D-hydro/athinput.linear_wave3d
+./athenac/tst/3D-hydro/athinput.linear_wave3d-3lev1
+./athenac/tst/3D-hydro/athinput.nl-shwave
+./athenac/tst/3D-hydro/athinput.noh
+./athenac/tst/3D-hydro/athinput.pgflow
+./athenac/tst/3D-hydro/athinput.shk_cloud
+./athenac/tst/3D-hydro/athinput.shwave
+./athenac/tst/3D-hydro/athinput.sod
+./athenac/tst/3D-hydro/athinput.ti_test
+./athenac/tst/3D-mhd/athinput.blast_B1
+./athenac/tst/3D-mhd/athinput.blast_B10
+./athenac/tst/3D-mhd/athinput.cpaw3d
+./athenac/tst/3D-mhd/athinput.field_loop
+./athenac/tst/3D-mhd/athinput.field_loop4
+./athenac/tst/3D-mhd/athinput.hgb
+./athenac/tst/3D-mhd/athinput.linear_wave3d
+./athenac/tst/3D-mhd/athinput.linear_wave3d-3lev1
+./athenac/tst/3D-mhd/athinput.msa
+./athenac/tst/3D-mhd/athinput.rj2a
+./athenac/tst/3D-mhd/athinput.rt
+./athenac/tst/3D-mhd/athinput.strat
+./athenac/tst/3D-mhd/athinput.Tconduct
+./athenac/tst/3D-sr-hydro/athinput.jet
+./athenac/tst/3D-sr-mhd/athinput.blast
+./athenac/tst/3D-sr-mhd/athinput.jet
+./athenac/tst/cylindrical/athinput.cyladvect-2D
+./athenac/tst/cylindrical/athinput.cyladvect-3D
+./athenac/tst/cylindrical/athinput.cylblast_B0-2D
+./athenac/tst/cylindrical/athinput.cylblast_B0-3D
+./athenac/tst/cylindrical/athinput.cylblast_B10-2D
+./athenac/tst/cylindrical/athinput.cylblast_B10-3D
+./athenac/tst/cylindrical/athinput.cylblast_B1-2D
+./athenac/tst/cylindrical/athinput.cylblast_B1-3D
+./athenac/tst/cylindrical/athinput.cylbphi-1D
+./athenac/tst/cylindrical/athinput.cylbphi-2D
+./athenac/tst/cylindrical/athinput.cylbphi-3D
+./athenac/tst/cylindrical/athinput.cylbr-2D
+./athenac/tst/cylindrical/athinput.cylbr-3D
+./athenac/tst/cylindrical/athinput.cyldiff
+./athenac/tst/cylindrical/athinput.cylfieldloop-2D
+./athenac/tst/cylindrical/athinput.cylfieldloop-3D
+./athenac/tst/cylindrical/athinput.cylnewtmri
+./athenac/tst/cylindrical/athinput.cylrayleigh-2D
+./athenac/tst/cylindrical/athinput.cylrayleigh-3D
+./athenac/tst/cylindrical/athinput.cylspiral-2D
+./athenac/tst/cylindrical/athinput.cylwind-1D
+./athenac/tst/cylindrical/athinput.cylwind-2D
+./athenac/tst/cylindrical/athinput.cylwind-3D
+./athenac/tst/cylindrical/athinput.cylwindrot-1D
+./athenac/tst/cylindrical/athinput.cylwindrot-2D
+./athenac/tst/cylindrical/athinput.cylwindrot-3D
+./athenac/tst/cylindrical/athinput.cylwindrotb-1D
+./athenac/tst/cylindrical/athinput.cylwindrotb-2D
+./athenac/tst/cylindrical/athinput.cylwindrotb-3D
+./athenac/tst/cylindrical/athinput.hkdisk-3D
+./athenac/tst/particle/athinput.par_circ
+./athenac/tst/particle/athinput.par_collision
+./athenac/tst/particle/athinput.par_epicycle
+./athenac/tst/particle/athinput.par_friction
+./athenac/tst/particle/athinput.par_linearwave1d
+./athenac/tst/particle/athinput.par_linearwave2d
+./athenac/tst/particle/athinput.par_shwave1d
+./athenac/tst/particle/athinput.par_shwave2d
+./athenac/tst/particle/athinput.par_strat2d
+./athenac/tst/particle/athinput.par_strat3d
+./athenac/tst/particle/athinput.streaming2d_multi
+./athenac/tst/particle/athinput.streaming2d_single
+./athenac/tst/particle/athinput.streaming3d_multi
+./athenac/tst/particle/athinput.streaming3d_single
+./athena/inputs/cosmic_ray/athinput.cr_diffusion
 ./athena/inputs/hydro/athinput.binary_gravity
 ./athena/inputs/hydro/athinput.blast
 ./athena/inputs/hydro/athinput.blast_cyl
@@ -16,7 +173,7 @@
 ./athena/inputs/hydro/athinput.kh-shear
 ./athena/inputs/hydro/athinput.kh-shear-lecoanet
 ./athena/inputs/hydro/athinput.kh-slip
-./athena/inputs/hydro/athinput.linear_wave1d                           TEST1
+./athena/inputs/hydro/athinput.linear_wave1d
 ./athena/inputs/hydro/athinput.linear_wave2d
 ./athena/inputs/hydro/athinput.linear_wave3d
 ./athena/inputs/hydro/athinput.lw_implode
@@ -81,14 +238,18 @@
 ./athena/inputs/mhd_sr/athinput.mub_2
 ./athena/inputs/mhd_sr/athinput.mub_3
 ./athena/inputs/mhd_sr/athinput.mub_4
+./athena/inputs/radiation/athinput.rad_linearwave
+./athena/inputs/radiation/athinput.rad_linearwave_amr
+./athena/inputs/radiation/athinput.thermal_multigroup
+./athena/inputs/radiation/athinput.thermal_relaxation
 ./athenak/inputs/grhydro/gr_fm_torus_sane_uniform.athinput
 ./athenak/inputs/grmhd/blast_grmhd_amr.athinput
 ./athenak/inputs/grmhd/gr_chakrabarti_torus_sane_8_4.athinput
 ./athenak/inputs/grmhd/gr_fm_torus_mad_8_4.athinput
 ./athenak/inputs/grmhd/gr_fm_torus_sane_8_4.athinput
 ./athenak/inputs/grmhd/mub1-gr.athinput
-./athenak/inputs/hydro/blast_hydro.athinput
 ./athenak/inputs/hydro/blast_hydro_amr.athinput
+./athenak/inputs/hydro/blast_hydro.athinput
 ./athenak/inputs/hydro/kh2d-lecoanet.athinput
 ./athenak/inputs/hydro/lw_implode.athinput
 ./athenak/inputs/hydro/rt2d.athinput
@@ -98,10 +259,10 @@
 ./athenak/inputs/hydro/sod.athinput
 ./athenak/inputs/hydro/turb.athinput
 ./athenak/inputs/hydro/viscosity.athinput
-./athenak/inputs/ion-neutral/blast_2fluid.athinput
 ./athenak/inputs/ion-neutral/blast_2fluid_amr.athinput
-./athenak/inputs/mhd/blast_mhd.athinput
+./athenak/inputs/ion-neutral/blast_2fluid.athinput
 ./athenak/inputs/mhd/blast_mhd_amr.athinput
+./athenak/inputs/mhd/blast_mhd.athinput
 ./athenak/inputs/mhd/bw.athinput
 ./athenak/inputs/mhd/current_sheet.athinput
 ./athenak/inputs/mhd/kh2d-lecoanet-mhd.athinput
@@ -134,11 +295,11 @@
 ./athenak/inputs/tests/cpaw3d.athinput
 ./athenak/inputs/tests/cpaw3d_smr.athinput
 ./athenak/inputs/tests/hohlraum_1d.athinput
-./athenak/inputs/tests/linear_wave_hydro.athinput                      TEST2
 ./athenak/inputs/tests/linear_wave_hydro_amr.athinput
+./athenak/inputs/tests/linear_wave_hydro.athinput
 ./athenak/inputs/tests/linear_wave_hydro_smr.athinput
-./athenak/inputs/tests/linear_wave_mhd.athinput
 ./athenak/inputs/tests/linear_wave_mhd_amr.athinput
+./athenak/inputs/tests/linear_wave_mhd.athinput
 ./athenak/inputs/tests/linear_wave_mhd_smr.athinput
 ./athenak/inputs/tests/linear_wave_z4c.athinput
 ./athenak/inputs/tests/monopole.athinput
diff --git a/linear_wave_hydro.athinput b/linear_wave_hydro.athinput
index 5daf2cd..a8a7293 100644
--- a/linear_wave_hydro.athinput
+++ b/linear_wave_hydro.athinput
@@ -9,19 +9,19 @@ basename  = LinWave    # problem ID: basename of output filenames
 
 <mesh>
 nghost    = 2          # Number of ghost cells
-nx1       = 64         # Number of zones in X1-direction    #> SCALE 16:512:16
+nx1       = 64         # Number of zones in X1-direction    #> RADIO 64,128,256,512,1024,2048
 x1min     = 0.0        # minimum value of X1
-x1max     = 3.0        # maximum value of X1
+x1max     = 1.0        # maximum value of X1
 ix1_bc    = periodic   # inner-X1 boundary flag
 ox1_bc    = periodic   # outer-X1 boundary flag
 
-nx2       = 32         # Number of zones in X2-direction    #> RADIO 1,16,32,64,128,256
+nx2       = 1          # Number of zones in X2-direction
 x2min     = 0.0        # minimum value of X2
 x2max     = 1.5        # maximum value of X2
 ix2_bc    = periodic   # inner-X2 boundary flag
 ox2_bc    = periodic   # outer-X2 boundary flag
 
-nx3       = 32         # Number of zones in X3-direction    #> RADIO 1,16,32,64,128,256
+nx3       = 1          # Number of zones in X3-direction
 x3min     = 0.0        # minimum value of X3
 x3max     = 1.5        # maximum value of X3
 ix3_bc    = periodic   # inner-X3 boundary flag
@@ -29,8 +29,8 @@ ox3_bc    = periodic   # outer-X3 boundary flag
 
 <meshblock>
 nx1       = 64         # Number of cells in each MeshBlock, X1-dir
-nx2       = 32         # Number of cells in each MeshBlock, X2-dir
-nx3       = 32         # Number of cells in each MeshBlock, X3-dir
+nx2       = 1          # Number of cells in each MeshBlock, X2-dir
+nx3       = 1          # Number of cells in each MeshBlock, X3-dir
 
 <time>
 evolution  = dynamic   # dynamic/kinematic/static
@@ -48,9 +48,9 @@ gamma       = 1.66666666667   # gamma = C_p/C_v
 
 <problem>
 pgen_name = linear_wave # problem generator name
-wave_flag = 0           # Wave family number ([0-4] for adiabatic hydro, [0-6] for MHD)
-amp       = 1.0e-3      # Wave Amplitude
-vflow     = 0.0         # background flow velocity
+wave_flag = 0           # Wave family number ([0-4] for adiabatic hydro, [0-6] for MHD)   #> RADIO  0,1,2,3,4
+amp       = 1e-3        # Wave Amplitude                                                  #> RADIO  1e-4,1e-3,1e-2,0.1,0.2,0.3,0.4,0.5
+vflow     = 0.0         # background flow velocity                                        #> SCALE  0:1:0.05
 along_x1  = false       # set to 'true' for wave along x1-axis
 along_x2  = false       # set to 'true' for wave along x2-axis
 along_x3  = false       # set to 'true' for wave along x3-axis
diff --git a/orszag_tang.athinput b/orszag_tang.athinput
new file mode 100644
index 0000000..e6a189e
--- /dev/null
+++ b/orszag_tang.athinput
@@ -0,0 +1,71 @@
+# AthenaXXX input file for Orszag-Tang MHD vortex test
+
+<comment>
+problem   = Orszag-Tang vortex
+reference = Orszag,S. & Tang,W., J. Fluid Mech., 90, 129 (1998)
+
+<job>
+basename   = OrszagTang   # problem ID: basename of output filenames
+
+<mesh>
+nghost    = 3         # Number of ghost cells
+nx1       = 200       # Number of zones in X1-direction     #> SCALE  50:200:50
+x1min     = -0.5      # minimum value of X1
+x1max     = 0.5       # maximum value of X1
+ix1_bc    = periodic  # inner-X1 boundary flag
+ox1_bc    = periodic  # outer-X1 boundary flag
+
+nx2       = 200       # Number of zones in X2-direction     #> SCALE 50:200:50
+x2min     = -0.5      # minimum value of X2
+x2max     = 0.5       # maximum value of X2
+ix2_bc    = periodic  # inner-X2 boundary flag
+ox2_bc    = periodic  # outer-X2 boundary flag
+
+nx3       = 1         # Number of zones in X3-direction
+x3min     = -0.5      # minimum value of X3
+x3max     = 0.5       # maximum value of X3
+ix3_bc    = periodic  # inner-X3 boundary flag
+ox3_bc    = periodic  # outer-X3 boundary flag
+
+<meshblock>
+nx1       = 50       # Number of cells in each MeshBlock, X1-dir
+nx2       = 50       # Number of cells in each MeshBlock, X2-dir
+nx3       = 1         # Number of cells in each MeshBlock, X3-dir
+
+<time>
+evolution  = dynamic   # dynamic/kinematic/static
+integrator = rk3       # time integration algorithm
+cfl_number = 0.4       # The Courant, Friedrichs, & Lewy (CFL) Number         #> SCALE 0:1.2:0.1
+nlim       = -1        # cycle limit
+tlim       = 1.0       # time limit                                           #> SCALE 1:100:1
+ndiag      = 1         # cycles between diagostic output
+
+<mhd>
+eos         = ideal     # EOS type
+reconstruct = ppm4      # spatial reconstruction method
+rsolver     = hlld      # Riemann-solver to be used
+gamma       = 1.666666667     # gamma = C_p/C_v                               #> SCALE 0.1:2.0:0.05
+
+# Note: OT pgen does not read any parameters from input file
+<problem>
+pgen_name   = orszag_tang     # problem generator name
+
+<output1>
+file_type   = hst      # History data dump
+data_format = %12.5e   # optional data format string
+dt          = 0.01     # time increment between outputs
+
+<output2>
+file_type   = tab       # Tabular data dump
+variable    = mhd_w_bcc # variables to be output
+data_format = %12.5e    # Optional data format string
+dt          = 0.01      # time increment between outputs
+slice_x2    = 0.0       # slice in x2                                         #> SCALE -0.5:0.5:0.1
+slice_x3    = 0.0       # slice in x3
+ghost_zones = false     # switch to output ghost cells
+
+<output3>
+file_type  = bin       # binary data dump
+variable   = mhd_w_bcc # variables to be output
+dt         = 0.01      # time increment between outputs
+
diff --git a/plot1d.py b/plot1d.py
index b6d965e..b9c503a 100755
--- a/plot1d.py
+++ b/plot1d.py
@@ -1,33 +1,64 @@
 #! /usr/bin/env python
 import numpy as np
 import matplotlib.pyplot as plt
-from matplotlib.widgets import RadioButtons, Button, Slider
+from matplotlib.widgets import RadioButtons, Button, Slider, CheckButtons, TextBox
 from argparse import ArgumentParser
 import glob
+import os
+import matplotlib.style as mplstyle
+mplstyle.use(['ggplot', 'fast'])
 
-# IMPORTING FROM ANIMATE2
+# TODO list
+# round buttons
+# round check boxes
+# nonlinear (logarithmic?) slider
 
+# IMPORTING FROM ANIMATE2
 # function that draws each frame of the animation
 def animate(i):
-    global xcol, ycol, current_frame
+    global xcol, ycol, current_frame, xlim, ylim
     # print(f[i])
     d = np.loadtxt(f[i]).T
     x = d[ixcol]
     y = d[iycol]
-    file = open(f[i]) # open file to retreive time information
-    # first line is target
-    # terribly lazy but it works, maybe just use regex
-    time = file.readline().split('=')[1].split(' ')[0]
-    file.close()
+    if not args.hst:
+        with open(f[i]) as file:
+            # first line is target
+            # terribly lazy but it works, maybe just use regex
+            time = file.readline().split('=')[1].split(' ')[0]
     ax.clear()
+    if xlim:
+        ax.set_xlim(xlim)
+        ax.set_ylim(ylim)
     ax.plot(x, y)
-    #ax.set_xlim([0,20])
-    #ax.set_ylim([0,10])
-    ax.set_title(f'Frame: {current_frame + 1} / {length}\nTime: {time}')
+    if not xlim and args.fix: # just need to check one since its either both or none
+        xlim = ax.get_xlim()
+        ylim = ax.get_ylim()
+    if not args.hst:
+        ax.set_title(f'Time: {float(time)}', loc='left')
+    else:
+        ax.set_title(f'History', loc='left')
     ax.set_xlabel(xcol)
-    ax.set_ylabel(ycol)  
+    ax.set_ylabel(ycol)
 # END IMPORT
 
+# hard-pauses the animation
+# that is, the only way to unpause is by using the play or restart button
+def hpause(self=None):
+    global hard_paused, is_playing
+    hard_paused = True
+    is_playing = False
+    #bpause.color = '0.5'
+    bplay.label.set_text('$\u25B6$')
+    pause()
+
+def play(self=None):
+    global is_playing
+    if is_playing:
+        hpause()
+    else:
+        resume()
+
 # pauses the animation
 def pause(self=None):
     global is_playing, fig
@@ -36,15 +67,20 @@ def pause(self=None):
         is_playing = False
 
 # plays the animation (either starts or resumes)
-def play(self=None):
-    global is_playing, current_frame, ax, length
+def resume(self=None):
+    global is_playing, current_frame, ax, length, frame_sliding, hard_paused
     if not is_playing:
+        bplay.label.set_text('$\u25A0$')
         is_playing = True
+        hard_paused = False
+        #bpause.color = '0.85'
         while current_frame < length and is_playing:
             animate(current_frame)
             current_frame += 1
             fig.canvas.draw_idle()
             fig.canvas.start_event_loop(delay)
+            frame_sliding = False
+            fslider.set_val(current_frame)
         is_playing = False
         if loop and current_frame == length:
             restart()
@@ -55,27 +91,38 @@ def loopf(self=None):
     if loop:
         bloop.color = '0.85' # this is the default color
     else:
-        bloop.color = 'cyan' # highlighted color
+        bloop.color = '0.5' # highlighted color
     loop = not loop
 
 # restarts the animation from the beginning
 def restart(self=None):
-    global current_frame
+    global current_frame, xlim
+    xlim = None
     pause()
     current_frame=0
-    play()
+    resume()
 
 # select the horizontal variable
 def select_h(label):
-    global current_frame, ycol
+    global current_frame, ycol, xlim
     update_cols(label, ycol)
-    restart()
+    if not hard_paused:
+        restart()
+    else:
+        xlim = None
+        animate(current_frame)
+        fig.canvas.draw_idle()
 
 # select the verticle variable
 def select_v(label):
-    global current_frame, xcol
+    global current_frame, xcol, xlim
     update_cols(xcol, label)
-    restart()
+    if not hard_paused:
+        restart()
+    else:
+        xlim = None
+        animate(current_frame)
+        fig.canvas.draw_idle()
 
 def update_cols(x, y):
     global xcol, ycol, ixcol, iycol
@@ -88,12 +135,42 @@ def update_delay(x):
     global delay
     delay = x / 1000
 
+def update_fslider(n):
+    global frame_sliding, current_frame
+    current_frame = n
+    animate(current_frame - 1)
+    fig.canvas.draw_idle()
+
+'''def fix_axes(v):
+    global xlim, ylim
+    if v == 'Fix X':
+        xlim = ax.get_xlim() if not xlim else None
+    else:
+        ylim = ax.get_ylim() if not ylim else None'''
+
+def mouse_moved(e):
+    if e.inaxes == fax:
+        pause()
+    elif not hard_paused:
+        resume()
+
 argparser = ArgumentParser(description='plots the athena tab files specified')
-argparser.add_argument('-d', '--dir', help='the directory containing the tab files')
+argparser.add_argument('-d', '--dir', help='the athena run directory containing tab/ or *.tab files', required=True)
+argparser.add_argument('--hst', action='store_true', help='plots the hst file rather animating the tab files')
+argparser.add_argument('-n', '--name', help='name of the problem being plotted') # primarily just used by the other gui
+argparser.add_argument('-f', '--fix', action='store_true', help='fixes the x and y axes of the animation based on the animation\'s first frame')
 args = argparser.parse_args()
 
 # fnames='run1/tab/LinWave*tab'
-f = glob.glob(args.dir + '/*tab')
+if args.hst:
+    f = glob.glob(args.dir + '/*.hst')
+else:
+    if os.path.exists(args.dir + '/tab'):
+        # athena++/athenak style
+        f = glob.glob(args.dir + '/tab/*.tab')
+    else:
+        # athenac style
+        f = glob.glob(args.dir + '/*.tab')
 f.sort()
 length = len(f)
 #print('DEBUG: %s has %d files' % (fnames,len(f)))
@@ -101,16 +178,43 @@ def update_delay(x):
 # global vars
 current_frame = 0
 is_playing = False
+hard_paused = True
 loop = False
+frame_sliding = False
+xlim = None
+ylim = None
+
+# plot settings
+left = 0.34
+bottom = 0.25
+top = 0.85
+
+# change plot settings if plotting a hst file
+if args.hst:
+    top = 0.9
+    bottom = 0.1
 
 # the time in seconds between frames
-delay= 100 / 1000
+delay = 100 / 1000
 
 # getting the variable names
-file = open(f[0]) # just use the first file
-file.readline()
-variables = file.readline().split()[2:]
-file.close()
+with open(f[0]) as file:
+    file.readline()
+    # regular tab file have as 2nd line
+    # i       x1v         rho ...               for athena
+    # gid   i       x1v         dens ...        for athenak
+    line2 = file.readline()
+    variables = line2.split()[1:]
+
+    # history files have as 2nd line
+    # [1]=time      [2]=dt       [3]=mass ...
+    # @todo  AthenaC has spaces in the column names, would need a different parsers
+    if args.hst:
+        print("DEBUG hst",line2)
+        variables = [v.split('=')[1] for v in variables]
+    print("tab variables detected:",variables)
+
+var_len = len(variables)
 
 # 0-based, change from animate2
 xcol=variables[0]
@@ -120,45 +224,135 @@ def update_delay(x):
 
 # plotting configuration
 fig, ax = plt.subplots()
-fig.subplots_adjust(left=0.34, bottom=0.34)
+fig.subplots_adjust(left=left, bottom=bottom, top=top) # old bottom was 0.34
+# plt.rcParams['font.family'] = 'Arial'
 # pause on close otherwise we might freeze
-# i wonder if this actually works
 fig.canvas.mpl_connect('close_event', pause)
+# fig.set_size_inches(10, 10)
 
-rax = fig.add_axes([0.05, 0.7, 0.15, 0.15])
-radio = RadioButtons(rax, tuple(variables))
-rax.text(-0.055, 0.07, 'Horizontal Axis')
-    
+plt.get_current_fig_manager().set_window_title(args.name if args.name else f[0].split('.')[0])
+
+rheight = var_len / 25
+rwidth = 0.045
+rdleft = 0.03
+rbot = (bottom + top - rheight) / 2
+
+rax = fig.add_axes([rdleft, rbot, rwidth, rheight])
+
+# @todo   label_props and radio_props don't appear until python 3.10.x 
+
+radio = RadioButtons(rax, 
+                     tuple(variables), 
+                     label_props={'color': ['white' for _ in variables]},
+                     radio_props={'color': ['#1f77b4' for _ in variables], 'edgecolor': ['black' for _ in variables]}
+                     )
+rax.axis('off') # removes the border around the radio buttons
 radio.on_clicked(select_h)
-rax = fig.add_axes([0.05, 0.4, 0.15, 0.15])
 
-radio2 = RadioButtons(rax, tuple(variables))
-rax.text(-0.055, 0.07, 'Vertical Axis')
+# use same axes to add text in order to make it easier to adjust
+rax.text(-0.055, 0.05, 'X')
+rax.text(0.055, 0.05, 'Y')
+
+rax = fig.add_axes([rdleft + 0.015, rbot, 0.25, rheight])
+radio2 = RadioButtons(rax, 
+                      tuple(variables), 
+                      radio_props={'color': ['#1f77b4' for _ in variables], 'edgecolor': ['black' for _ in variables]}
+                      )
+rax.axis('off')
 radio2.on_clicked(select_v)
 
-# button shift
-lshift = 0.65
+if not args.hst:
+
+    bwidth = 0.04
+    bheight = 0.05
+    bspace = 0.02
+    bstart = 0.05
+
+    brestart = Button(fig.add_axes([bstart, 0.125, bwidth, bheight]), '$\u21A9$')
+    brestart.on_clicked(restart)
+
+    bplay = Button(fig.add_axes([bstart + bwidth + bspace, 0.125, bwidth, bheight]), '$\u25B6$')
+    bplay.on_clicked(play)
+
+    bloop = Button(fig.add_axes([bstart + 2 * bwidth + 2 * bspace, 0.125, bwidth, bheight]), '$\u27F3$')
+    bloop.on_clicked(loopf)
+
+    # make slider nonlinear
+    delay_slider = Slider(
+        ax=fig.add_axes([0.18, 0.05, 0.65, 0.03]),
+        label='Delay (ms)',
+        valmin=0,
+        valmax=20,
+        valinit=5,
+    )
+
+    delay_slider.on_changed(update_delay)
+
+    fax = fig.add_axes([0.18, 0.95, 0.65, 0.03])
+    fslider = Slider(
+        ax=fax,
+        label='Frame',
+        valmin=1,
+        valmax=length,
+        valinit=1,
+        valstep=1
+    )
+
+    fslider.on_changed(update_fslider)
+
+    '''cbax = fig.add_axes([bstart + 3 * bwidth + 3 * bspace, 0.09, 0.1, 0.125])
+    fix_cbox = CheckButtons(
+    ax=cbax,
+    labels=[' Fix X', ' Fix Y']
+    )
+    cbax.axis('off')
+
+    fix_cbox.on_clicked(fix_axes)'''
+
+    '''twidth = 0.1
+    theight = 0.04
+    txstart=0.35
+    tspace = 0.075
+    tystart1 = 0.11
+    tystart2 = tystart1 + 0.05
+    
+    xmin_ax = fig.add_axes([txstart, tystart1, twidth, theight])
+    xmin_box = TextBox(
+        ax=xmin_ax,
+        label='min '
+    )
+
+    xmin_ax.text(-0.9, 0.25, 'X:')
+
+    xmax_box = TextBox(
+        ax=fig.add_axes([txstart + twidth + tspace, tystart1, twidth, theight]),
+        label='max '
+    )
 
-bloop = Button(fig.add_axes([1.028 - lshift, 0.125, 0.1, 0.075]), 'Loop')
-bloop.on_clicked(loopf)
+    xscale_box = TextBox(
+        ax=fig.add_axes([txstart + 2*twidth + 2*tspace, tystart1, twidth, theight]),
+        label='scale '
+    )
 
-brestart = Button(fig.add_axes([0.919 - lshift, 0.125, 0.1, 0.075]), 'Restart')
-brestart.on_clicked(restart)
+    ymin_ax = fig.add_axes([txstart, tystart2, twidth, theight])
+    ymin_box = TextBox(
+        ax=ymin_ax,
+        label='min '
+    )
 
-bres = Button(fig.add_axes([0.81 - lshift, 0.125, 0.1, 0.075]), 'Play')
-bres.on_clicked(play)
+    ymin_ax.text(-0.9, 0.25, 'Y:')
 
-bpause = Button(fig.add_axes([0.7 - lshift, 0.125, 0.1, 0.075]), 'Pause')
-bpause.on_clicked(pause)
+    ymax_box = TextBox(
+        ax=fig.add_axes([txstart + twidth + tspace, tystart2, twidth, theight]),
+        label='max '
+    )
 
-amp_slider = Slider(
-    ax=fig.add_axes([0.18, 0.05, 0.65, 0.03]),
-    label='Delay (ms)',
-    valmin=1,
-    valmax=1000,
-    valinit=100,
-)
+    yscale_box = TextBox(
+        ax=fig.add_axes([txstart + 2*twidth + 2*tspace, tystart2, twidth, theight]),
+        label='scale '
+    )'''
 
-amp_slider.on_changed(update_delay)
+    # in order to pause the animation when using the frame slider
+    fig.canvas.mpl_connect('motion_notify_event', mouse_moved)
 
-plt.show()
\ No newline at end of file
+plt.show()
diff --git a/plot_hst.py b/plot_hst.py
new file mode 100755
index 0000000..54b7365
--- /dev/null
+++ b/plot_hst.py
@@ -0,0 +1,59 @@
+#! /usr/bin/env python
+
+# Script for plotting 1D data from Athena++ .hst files.
+
+# Run "plot_hst.py -h" for help.
+
+# Python modules
+import argparse
+
+# Athena++ modules
+import athena_read
+
+
+# Main function
+def main(**kwargs):
+
+    # get input file and read data
+    input_file = kwargs['input']
+    data = athena_read.hst(input_file)
+
+    # get variable names, check they are valid, and set x/y data
+    variables = kwargs['variables']
+    if variables not in data:
+        print('Invalid input variable name, valid names are:')
+        for key in data:
+            print(key)
+        raise RuntimeError
+
+    y_vals = data[variables]
+    x_vals = data["time"]
+
+    print(data)
+
+    # Load Python plotting modules
+    output_file = kwargs['output']
+    if output_file != 'show':
+        import matplotlib
+        matplotlib.use('agg')
+    import matplotlib.pyplot as plt
+
+    # Plot data
+    plt.figure()
+    plt.plot(x_vals, y_vals)
+    plt.show()
+
+
+# Execute main function
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-i', '--input',
+                        help='name of input (hst) file')
+    parser.add_argument('-o', '--output',
+                        default='show',
+                        help='image filename; omit to display to screen')
+    parser.add_argument('-v', '--variables',
+                        help='comma-separated list of variables to be plotted')
+
+    args = parser.parse_args()
+    main(**vars(args))
diff --git a/plot_mesh.py b/plot_mesh.py
new file mode 100755
index 0000000..53762c3
--- /dev/null
+++ b/plot_mesh.py
@@ -0,0 +1,70 @@
+#! /usr/bin/env python
+
+# Script for plotting mesh structure in mesh_structure.dat (default name) file
+# produced by running Athena++ with "-m" argument.
+
+# Can optionally specify "-i <input_file>" and/or "-o <output_file>". If -o
+# argument is omitted, output defaults to display on screen rather than
+# saving to file.
+
+# Run "plot_mesh.py -h" for help.
+
+# Python modules
+import argparse
+
+
+# Main function
+def main(**kwargs):
+
+    # Extract inputs
+    input_file = kwargs['input']
+    output_file = kwargs['output']
+
+    # Load Python plotting modules
+    if output_file != 'show':
+        import matplotlib
+        matplotlib.use('agg')
+    import matplotlib.pyplot as plt
+    # not used explicitly, but required for 3D projections
+    from mpl_toolkits.mplot3d import Axes3D  # noqa
+
+    # Read and plot block edges
+    fig = plt.figure()
+    ax = fig.gca(projection='3d')
+    x = []
+    y = []
+    z = []
+    with open(input_file) as f:
+        for line in f:
+            if line[0] != '\n' and line[0] != '#':
+                numbers_str = line.split()
+                x.append(float(numbers_str[0]))
+                y.append(float(numbers_str[1]))
+                # append zero if 2D
+                if (len(numbers_str) > 2):
+                    z.append(float(numbers_str[2]))
+                else:
+                    z.append(0.0)
+            if line[0] == '\n' and len(x) != 0:
+                ax.plot(x, y, z, 'k-')
+                x = []
+                y = []
+                z = []
+    if output_file == 'show':
+        plt.show()
+    else:
+        plt.savefig(output_file, bbox_inches='tight')
+
+
+# Execute main function
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-i', '--input',
+                        default='mesh_structure.dat',
+                        help='name of input (mesh structure) file')
+    parser.add_argument('-o',
+                        '--output',
+                        default='show',
+                        help='image filename; omit to display to screen')
+    args = parser.parse_args()
+    main(**vars(args))
diff --git a/plot_slice.py b/plot_slice.py
new file mode 100755
index 0000000..3f4e0b8
--- /dev/null
+++ b/plot_slice.py
@@ -0,0 +1,1018 @@
+#! /usr/bin/env python3
+
+"""
+Script for plotting a 2D slice from a 2D or 3D AthenaK data dump.
+
+Usage:
+[python3] plot_slice.py <input_file> <quantity_to_plot> <output_file> [options]
+
+Example:
+~/athenak/vis/python/plot_slice.py basename.prim.00100.bin dens image.png
+
+<input_file> can be any standard AthenaK .bin data dump. <output_file> can have
+any extension recognized by Matplotlib (e.g., .png). If <output_file> is simply
+"show", the script will open a live Matplotlib viewing window.
+
+Available quantities include anything found in the input file (e.g., dens, velx,
+eint, bcc1, r00_ff). If an invalid quantity is requested (e.g.,
+"plot_slice.py <input_file> ? show"), the error message will list all available
+quantities in the file.
+
+Additional derived quantities can be computed as well. These are identified by
+prefixing with "derived:". An invalid request (e.g.,
+"plot_slice.py <input_file> derived:? show") will list available options.
+Currently, these include the following:
+  - Quantities related to gas pressure:
+    - pgas: gas pressure
+    - pgas_rho: gas pressure divided by density
+    - T: temperature
+  - Non-relativistic quantities related to magnetic pressure:
+    - pmag_nr: (magnetic pressure) = B^2 / 2
+    - beta_inv_nr: 1 / (plasma beta) = (magnetic pressure) / (gas pressure)
+    - sigma_nr: (plasma sigma) = B^2 / rho
+  - Relativistic quantities related to magnetic pressure:
+    - pmag_rel: (magnetic pressure) = (B^2 - E^2) / 2
+    - beta_inv_rel: 1 / (plasma beta) = (magnetic pressure) / (gas pressure)
+    - sigma_rel: (plasma sigma) = (B^2 - E^2) / rho
+  - Relativistic quantities related to radiation:
+    - prad: (radiation pressure) = (fluid-frame radiation energy density) / 3
+    - prad_pgas: (radiation pressure) / (gas pressure)
+    - pmag_prad: (magnetic pressure) / (radiation pressure)
+  - Relativistic quantities related to velocity:
+    - uut: normal-frame Lorentz factor u^{t'} = tilde{u}^t
+    - ut, ux, uy, uz: contravariant coordinate-frame 4-velocity components u^mu
+    - vx, vy, vz: coordinate-frame 3-velocity components u^i / u^t
+  - Non-relativistic conserved quantities
+    - cons_hydro_nr_t: pure hydrodynamical energy density
+    - cons_hydro_nr_x, cons_hydro_nr_y, cons_hydro_nr_z: momentum density
+    - cons_em_nr_t: pure electromagnetic energy density
+    - cons_mhd_nr_t: MHD energy density
+    - cons_mhd_nr_x, cons_mhd_nr_y, cons_mhd_nr_z: MHD momentum density
+  - Relativistic conserved quantities
+    - cons_hydro_rel_t, : (T_hydro)^t_t
+    - cons_hydro_rel_x, cons_hydro_rel_y, cons_hydro_rel_z: (T_hydro)^t_i
+    - cons_em_rel_t, : (T_EM)^t_t
+    - cons_em_rel_x, cons_em_rel_y, cons_em_rel_z: (T_EM)^t_i
+    - cons_mhd_rel_t, : (T_MHD)^t_t
+    - cons_mhd_rel_x, cons_mhd_rel_y, cons_mhd_rel_z: (T_MHD)^t_i
+
+Only temperature T is in physical units (K); all others are in code units.
+
+Optional inputs include:
+  -d: direction orthogonal to slice of 3D data
+  -l: location of slice of 3D data if not 0
+  --x1_min, --x1_max, --x2_min, --x2_max: horizontal and vertical limits of plot
+  -c: colormap recognized by Matplotlib
+  -n: colormap normalization (e.g., "-n log") if not linear
+  --vmin, --vmax: limits of colorbar if not the full range of data
+  --notex: flag to disable Latex typesetting of labels
+  --horizon: flag for outlining outer event horizon of GR simulation
+  --horizon_mask: flag for covering black hole of GR simulation
+  --ergosphere: flag for outlining boundary of ergosphere in GR simulation
+  --horizon_color, --horizon_mask_color, --ergosphere_color: color choices
+
+Run "plot_slice.py -h" to see a full description of inputs.
+"""
+
+# Python standard modules
+import argparse
+import struct
+import warnings
+
+# Numerical modules
+import numpy as np
+
+# Load plotting modules
+import matplotlib
+
+
+# Main function
+def main(**kwargs):
+
+    # Load additional numerical modules
+    if kwargs['ergosphere']:
+        from scipy.optimize import brentq
+
+    # Load additional plotting modules
+    if kwargs['output_file'] != 'show':
+        matplotlib.use('agg')
+    if not kwargs['notex']:
+        matplotlib.rc('text', usetex=True)
+    import matplotlib.colors as colors
+    import matplotlib.patches as patches
+    import matplotlib.pyplot as plt
+
+    # Plotting parameters
+    horizon_line_style = '-'
+    horizon_line_width = 1.0
+    ergosphere_num_points = 129
+    ergosphere_line_style = '-'
+    ergosphere_line_width = 1.0
+    x1_labelpad = 2.0
+    x2_labelpad = 2.0
+    dpi = 300
+
+    # Adjust user inputs
+    if kwargs['dimension'] == '1':
+        kwargs['dimension'] = 'x'
+    if kwargs['dimension'] == '2':
+        kwargs['dimension'] = 'y'
+    if kwargs['dimension'] == '3':
+        kwargs['dimension'] = 'z'
+
+    # Set physical units
+    c_cgs = 2.99792458e10
+    kb_cgs = 1.380649e-16
+    mp_cgs = 1.67262192369e-24
+    gg_msun_cgs = 1.32712440018e26
+
+    # Set derived dependencies
+    derived_dependencies = {}
+    derived_dependencies['pgas'] = ('eint',)
+    derived_dependencies['pgas_rho'] = ('dens', 'eint')
+    derived_dependencies['T'] = ('dens', 'eint')
+    derived_dependencies['pmag_nr'] = ('bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['pmag_rel'] = ('velx', 'vely', 'velz', 'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['beta_inv_nr'] = ('eint', 'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['beta_inv_rel'] = ('eint', 'velx', 'vely', 'velz',
+                                            'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['sigma_nr'] = ('dens', 'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['sigma_rel'] = ('dens', 'velx', 'vely', 'velz',
+                                         'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['prad'] = ('r00_ff',)
+    derived_dependencies['prad_pgas'] = ('eint', 'r00_ff')
+    derived_dependencies['pmag_prad'] = ('velx', 'vely', 'velz',
+                                         'bcc1', 'bcc2', 'bcc3', 'r00_ff')
+    derived_dependencies['uut'] = ('velx', 'vely', 'velz')
+    derived_dependencies['ut'] = ('velx', 'vely', 'velz')
+    derived_dependencies['ux'] = ('velx', 'vely', 'velz')
+    derived_dependencies['uy'] = ('velx', 'vely', 'velz')
+    derived_dependencies['uz'] = ('velx', 'vely', 'velz')
+    derived_dependencies['vx'] = ('velx', 'vely', 'velz')
+    derived_dependencies['vy'] = ('velx', 'vely', 'velz')
+    derived_dependencies['vz'] = ('velx', 'vely', 'velz')
+    derived_dependencies['cons_hydro_nr_t'] = ('dens', 'eint', 'velx', 'vely', 'velz')
+    derived_dependencies['cons_hydro_nr_x'] = ('dens', 'velx')
+    derived_dependencies['cons_hydro_nr_y'] = ('dens', 'vely')
+    derived_dependencies['cons_hydro_nr_z'] = ('dens', 'velz')
+    derived_dependencies['cons_em_nr_t'] = ('bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_mhd_nr_t'] = ('dens', 'eint', 'velx', 'vely', 'velz',
+                                             'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_mhd_nr_x'] = ('dens', 'velx')
+    derived_dependencies['cons_mhd_nr_y'] = ('dens', 'vely')
+    derived_dependencies['cons_mhd_nr_z'] = ('dens', 'velz')
+    derived_dependencies['cons_hydro_rel_t'] = ('dens', 'eint', 'velx', 'vely', 'velz')
+    derived_dependencies['cons_hydro_rel_x'] = ('dens', 'eint', 'velx', 'vely', 'velz')
+    derived_dependencies['cons_hydro_rel_y'] = ('dens', 'eint', 'velx', 'vely', 'velz')
+    derived_dependencies['cons_hydro_rel_z'] = ('dens', 'eint', 'velx', 'vely', 'velz')
+    derived_dependencies['cons_em_rel_t'] = ('velx', 'vely', 'velz',
+                                             'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_em_rel_x'] = ('velx', 'vely', 'velz',
+                                             'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_em_rel_y'] = ('velx', 'vely', 'velz',
+                                             'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_em_rel_z'] = ('velx', 'vely', 'velz',
+                                             'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_mhd_rel_t'] = ('dens', 'eint', 'velx', 'vely', 'velz',
+                                              'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_mhd_rel_x'] = ('dens', 'eint', 'velx', 'vely', 'velz',
+                                              'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_mhd_rel_y'] = ('dens', 'eint', 'velx', 'vely', 'velz',
+                                              'bcc1', 'bcc2', 'bcc3')
+    derived_dependencies['cons_mhd_rel_z'] = ('dens', 'eint', 'velx', 'vely', 'velz',
+                                              'bcc1', 'bcc2', 'bcc3')
+
+    # Read data
+    with open(kwargs['data_file'], 'rb') as f:
+
+        # Get file size
+        f.seek(0, 2)
+        file_size = f.tell()
+        f.seek(0, 0)
+
+        # Read header metadata
+        line = f.readline().decode('ascii')
+        if line != 'Athena binary output version=1.1\n':
+            raise RuntimeError('Unrecognized data file format.')
+        next(f)
+        next(f)
+        next(f)
+        line = f.readline().decode('ascii')
+        if line[:19] != '  size of location=':
+            raise RuntimeError('Could not read location size.')
+        location_size = int(line[19:])
+        line = f.readline().decode('ascii')
+        if line[:19] != '  size of variable=':
+            raise RuntimeError('Could not read variable size.')
+        variable_size = int(line[19:])
+        next(f)
+        line = f.readline().decode('ascii')
+        if line[:12] != '  variables:':
+            raise RuntimeError('Could not read variable names.')
+        variable_names_base = line[12:].split()
+        line = f.readline().decode('ascii')
+        if line[:16] != '  header offset=':
+            raise RuntimeError('Could not read header offset.')
+        header_offset = int(line[16:])
+
+        # Process header metadata
+        if location_size not in (4, 8):
+            raise RuntimeError('Only 4- and 8-byte integer types supported for '
+                               'location data.')
+        location_format = 'f' if location_size == 4 else 'd'
+        if variable_size not in (4, 8):
+            raise RuntimeError('Only 4- and 8-byte integer types supported for cell '
+                               'data.')
+        variable_format = 'f' if variable_size == 4 else 'd'
+        num_variables_base = len(variable_names_base)
+        if kwargs['variable'][:8] == 'derived:':
+            variable_name = kwargs['variable'][8:]
+            if variable_name not in derived_dependencies:
+                raise RuntimeError('Derived variable "{0}" not valid; options are " \
+                        "{{{1}}}.'.format(variable_name,
+                                          ', '.join(derived_dependencies.keys())))
+            variable_names = []
+            variable_inds = []
+            for dependency in derived_dependencies[variable_name]:
+                if dependency not in variable_names_base:
+                    raise RuntimeError('Requirement "{0}" for "{1}" not found.'
+                                       .format(dependency, variable_name))
+                variable_names.append(dependency)
+                variable_ind = 0
+                while variable_names_base[variable_ind] != dependency:
+                    variable_ind += 1
+                variable_inds.append(variable_ind)
+        elif kwargs['variable'] == 'level':
+            variable_name = kwargs['variable']
+            variable_names = [variable_name]
+            variable_inds = [-1]
+        else:
+            variable_name = kwargs['variable']
+            if variable_name not in variable_names_base:
+                raise RuntimeError('Variable "{0}" not found; options are {{{1}}}.'
+                                   .format(variable_name,
+                                           ', '.join(variable_names_base)))
+            variable_names = [variable_name]
+            variable_ind = 0
+            while variable_names_base[variable_ind] != variable_name:
+                variable_ind += 1
+            variable_inds = [variable_ind]
+        variable_names_sorted = \
+            [name for _, name in sorted(zip(variable_inds, variable_names))]
+        variable_inds_sorted = \
+            [ind for ind, _ in sorted(zip(variable_inds, variable_names))]
+
+        # Read input file metadata
+        input_data = {}
+        start_of_data = f.tell() + header_offset
+        while f.tell() < start_of_data:
+            line = f.readline().decode('ascii')
+            if line[0] == '#':
+                continue
+            if line[0] == '<':
+                section_name = line[1:-2]
+                input_data[section_name] = {}
+                continue
+            key, val = line.split('=', 1)
+            input_data[section_name][key.strip()] = val.split('#', 1)[0].strip()
+
+        # Extract number of ghost cells from input file metadata
+        try:
+            num_ghost = int(input_data['mesh']['nghost'])
+        except:  # noqa: E722
+            raise RuntimeError('Unable to find number of ghost cells in input file.')
+
+        # Extract adiabatic index from input file metadata
+        if kwargs['variable'] in \
+                ['derived:' + name for name in ('pgas', 'pgas_rho', 'T', 'prad_pgas')] \
+                + ['derived:cons_hydro_rel_' + name for name in ('t', 'x', 'y', 'z')]:
+            try:
+                gamma_adi = float(input_data['hydro']['gamma'])
+            except:  # noqa: E722
+                try:
+                    gamma_adi = float(input_data['mhd']['gamma'])
+                except:  # noqa: E722
+                    raise RuntimeError('Unable to find adiabatic index in input file.')
+        if kwargs['variable'] in \
+                ['derived:' + name for name in ('beta_inv_nr', 'beta_inv_rel')] \
+                + ['derived:cons_mhd_rel_' + name for name in ('t', 'x', 'y', 'z')]:
+            try:
+                gamma_adi = float(input_data['mhd']['gamma'])
+            except:  # noqa: E722
+                raise RuntimeError('Unable to find adiabatic index in input file.')
+
+        # Extract units from input file metadata
+        if kwargs['variable'] == 'derived:T':
+            if input_data['coord']['general_rel'] == 'true':
+                try:
+                    length_cgs = float(input_data['units']['bhmass_msun']) * gg_msun_cgs \
+                            / c_cgs ** 2
+                except:  # noqa: E722
+                    raise RuntimeError('Unable to find black hole mass in input file.')
+                time_cgs = length_cgs / c_cgs
+            else:
+                try:
+                    length_cgs = float(input_data['units']['length_cgs'])
+                except:  # noqa: E722
+                    raise RuntimeError('Unable to find length unit in input file.')
+                try:
+                    time_cgs = float(input_data['units']['time_cgs'])
+                except:  # noqa: E722
+                    raise RuntimeError('Unable to find time unit in input file.')
+            try:
+                mu = float(input_data['units']['mu'])
+            except:  # noqa: E722
+                raise RuntimeError('Unable to find molecular weight in input file.')
+
+        # Check input file metadata for relativity
+        if kwargs['variable'] in \
+                ['derived:' + name for name in ('pmag_nr', 'beta_inv_nr', 'sigma_nr')] \
+                + ['derived:cons_hydro_nr_' + name for name in ('t', 'x', 'y', 'z')] \
+                + ['derived:cons_em_nr_t'] \
+                + ['derived:cons_mhd_nr_' + name for name in ('t', 'x', 'y', 'z')]:
+            assert input_data['coord']['general_rel'] == 'false', \
+                    '"{0}" is only defined for non-GR data.'.format(variable_name)
+        if kwargs['variable'] in \
+                ['derived:' + name for name in
+                 ('pmag_rel', 'beta_inv_rel', 'sigma_rel', 'pmag_prad')] \
+                + ['derived:' + name for name in
+                   ('uut', 'ut', 'ux', 'uy', 'uz', 'vx', 'vy', 'vz')] \
+                + ['derived:cons_hydro_rel_' + name for name in ('t', 'x', 'y', 'z')] \
+                + ['derived:cons_em_rel_' + name for name in ('t', 'x', 'y', 'z')] \
+                + ['derived:cons_mhd_rel_' + name for name in ('t', 'x', 'y', 'z')]:
+            assert input_data['coord']['general_rel'] == 'true', \
+                    '"{0}" is only defined for GR data.'.format(variable_name)
+        if kwargs['horizon'] or kwargs['horizon_mask'] or kwargs['ergosphere']:
+            assert input_data['coord']['general_rel'] == 'true', '"horizon", ' \
+                    '"horizon_mask", and "ergosphere" options only pertain to GR data.'
+
+        # Extract black hole spin from input file metadata
+        if kwargs['variable'] in \
+                ['derived:' + name for name in
+                 ('pmag_rel', 'beta_inv_rel', 'sigma_rel', 'pmag_prad')] \
+                + ['derived:' + name for name in
+                   ('uut', 'ut', 'ux', 'uy', 'uz', 'vx', 'vy', 'vz')] \
+                + ['derived:cons_hydro_rel_' + name for name in ('t', 'x', 'y', 'z')] \
+                + ['derived:cons_em_rel_' + name for name in ('t', 'x', 'y', 'z')] \
+                + ['derived:cons_mhd_rel_' + name for name in ('t', 'x', 'y', 'z')]:
+            try:
+                bh_a = float(input_data['coord']['a'])
+            except:  # noqa: E722
+                raise RuntimeError('Unable to find black hole spin in input file.')
+        if kwargs['horizon'] or kwargs['horizon_mask'] or kwargs['ergosphere']:
+            try:
+                bh_a = float(input_data['coord']['a'])
+            except:  # noqa: E722
+                raise RuntimeError('Unable to find black hole spin in input file.')
+
+        # Prepare lists to hold results
+        max_level_calculated = -1
+        block_loc_for_level = []
+        block_ind_for_level = []
+        num_blocks_used = 0
+        extents = []
+        quantities = {}
+        for name in variable_names_sorted:
+            quantities[name] = []
+
+        # Go through blocks
+        first_time = True
+        while f.tell() < file_size:
+
+            # Read grid structure data
+            block_indices = np.array(struct.unpack('@6i', f.read(24))) - num_ghost
+            block_i, block_j, block_k, block_level = struct.unpack('@4i', f.read(16))
+
+            # Process grid structure data
+            if first_time:
+                block_nx = block_indices[1] - block_indices[0] + 1
+                block_ny = block_indices[3] - block_indices[2] + 1
+                block_nz = block_indices[5] - block_indices[4] + 1
+                cells_per_block = block_nz * block_ny * block_nx
+                block_cell_format = '=' + str(cells_per_block) + variable_format
+                variable_data_size = cells_per_block * variable_size
+                if kwargs['dimension'] is None:
+                    if block_nx > 1 and block_ny > 1 and block_nz > 1:
+                        kwargs['dimension'] = 'z'
+                    elif block_nx > 1 and block_ny > 1:
+                        kwargs['dimension'] = 'z'
+                    elif block_nx > 1 and block_nz > 1:
+                        kwargs['dimension'] = 'y'
+                    elif block_ny > 1 and block_nz > 1:
+                        kwargs['dimension'] = 'x'
+                    else:
+                        raise RuntimeError('Input file only contains 1D data.')
+                if kwargs['dimension'] == 'x':
+                    if block_ny == 1:
+                        raise RuntimeError('Data in file has no extent in y-direction.')
+                    if block_nz == 1:
+                        raise RuntimeError('Data in file has no extent in z-direction.')
+                    block_nx1 = block_ny
+                    block_nx2 = block_nz
+                    slice_block_n = block_nx
+                    slice_location_min = float(input_data['mesh']['x1min'])
+                    slice_location_max = float(input_data['mesh']['x1max'])
+                    slice_root_blocks = (int(input_data['mesh']['nx1'])
+                                         // int(input_data['meshblock']['nx1']))
+                if kwargs['dimension'] == 'y':
+                    if block_nx == 1:
+                        raise RuntimeError('Data in file has no extent in x-direction.')
+                    if block_nz == 1:
+                        raise RuntimeError('Data in file has no extent in z-direction.')
+                    block_nx1 = block_nx
+                    block_nx2 = block_nz
+                    slice_block_n = block_ny
+                    slice_location_min = float(input_data['mesh']['x2min'])
+                    slice_location_max = float(input_data['mesh']['x2max'])
+                    slice_root_blocks = (int(input_data['mesh']['nx2'])
+                                         // int(input_data['meshblock']['nx2']))
+                if kwargs['dimension'] == 'z':
+                    if block_nx == 1:
+                        raise RuntimeError('Data in file has no extent in x-direction.')
+                    if block_ny == 1:
+                        raise RuntimeError('Data in file has no extent in y-direction.')
+                    block_nx1 = block_nx
+                    block_nx2 = block_ny
+                    slice_block_n = block_nz
+                    slice_location_min = float(input_data['mesh']['x3min'])
+                    slice_location_max = float(input_data['mesh']['x3max'])
+                    slice_root_blocks = (int(input_data['mesh']['nx3'])
+                                         // int(input_data['meshblock']['nx3']))
+                slice_normalized_coord = (kwargs['location'] - slice_location_min) \
+                    / (slice_location_max - slice_location_min)
+                first_time = False
+
+            # Determine if block is needed
+            if block_level > max_level_calculated:
+                for level in range(max_level_calculated + 1, block_level + 1):
+                    if kwargs['location'] <= slice_location_min:
+                        block_loc_for_level.append(0)
+                        block_ind_for_level.append(0)
+                    elif kwargs['location'] >= slice_location_max:
+                        block_loc_for_level.append(slice_root_blocks - 1)
+                        block_ind_for_level.append(slice_block_n - 1)
+                    else:
+                        slice_mesh_n = slice_block_n * slice_root_blocks * 2 ** level
+                        mesh_ind = int(slice_normalized_coord * slice_mesh_n)
+                        block_loc_for_level.append(mesh_ind // slice_block_n)
+                        block_ind_for_level.append(mesh_ind - slice_block_n
+                                                   * block_loc_for_level[-1])
+                max_level_calculated = block_level
+            if kwargs['dimension'] == 'x' and block_i != block_loc_for_level[block_level]:
+                f.seek(6 * location_size + num_variables_base * variable_data_size, 1)
+                continue
+            if kwargs['dimension'] == 'y' and block_j != block_loc_for_level[block_level]:
+                f.seek(6 * location_size + num_variables_base * variable_data_size, 1)
+                continue
+            if kwargs['dimension'] == 'z' and block_k != block_loc_for_level[block_level]:
+                f.seek(6 * location_size + num_variables_base * variable_data_size, 1)
+                continue
+            num_blocks_used += 1
+
+            # Read coordinate data
+            block_lims = struct.unpack('=6' + location_format, f.read(6 * location_size))
+            if kwargs['dimension'] == 'x':
+                extents.append((block_lims[2], block_lims[3], block_lims[4],
+                                block_lims[5]))
+            if kwargs['dimension'] == 'y':
+                extents.append((block_lims[0], block_lims[1], block_lims[4],
+                                block_lims[5]))
+            if kwargs['dimension'] == 'z':
+                extents.append((block_lims[0], block_lims[1], block_lims[2],
+                                block_lims[3]))
+
+            # Read cell data
+            cell_data_start = f.tell()
+            for ind, name in zip(variable_inds_sorted, variable_names_sorted):
+                if ind == -1:
+                    if kwargs['dimension'] == 'x':
+                        quantities[name].append(np.full((block_nz, block_ny),
+                                                        block_level))
+                    if kwargs['dimension'] == 'y':
+                        quantities[name].append(np.full((block_nz, block_nx),
+                                                        block_level))
+                    if kwargs['dimension'] == 'z':
+                        quantities[name].append(np.full((block_ny, block_nx),
+                                                        block_level))
+                else:
+                    f.seek(cell_data_start + ind * variable_data_size, 0)
+                    cell_data = (np.array(struct.unpack(block_cell_format,
+                                                        f.read(variable_data_size)))
+                                 .reshape(block_nz, block_ny, block_nx))
+                    block_ind = block_ind_for_level[block_level]
+                    if kwargs['dimension'] == 'x':
+                        quantities[name].append(cell_data[:, :, block_ind])
+                    if kwargs['dimension'] == 'y':
+                        quantities[name].append(cell_data[:, block_ind, :])
+                    if kwargs['dimension'] == 'z':
+                        quantities[name].append(cell_data[block_ind, :, :])
+            f.seek((num_variables_base - ind - 1) * variable_data_size, 1)
+
+    # Prepare to calculate derived quantity
+    for name in variable_names_sorted:
+        quantities[name] = np.array(quantities[name])
+
+    # Calculate derived quantity related to gas pressure
+    if kwargs['variable'] in \
+            ['derived:' + name for name in ('pgas', 'pgas_rho', 'T', 'prad_pgas')]:
+        pgas = (gamma_adi - 1.0) * quantities['eint']
+        if kwargs['variable'] == 'derived:pgas':
+            quantity = pgas
+        elif kwargs['variable'] == 'derived:pgas_rho':
+            quantity = pgas / quantities['dens']
+        elif kwargs['variable'] == 'derived:T':
+            quantity = (mu * mp_cgs / kb_cgs * (length_cgs / time_cgs) ** 2 * pgas
+                        / quantities['dens'])
+        else:
+            prad = quantities['r00_ff'] / 3.0
+            quantity = prad / pgas
+
+    # Calculate derived quantity related to radiation pressure
+    elif kwargs['variable'] == 'derived:prad':
+        quantity = quantities['r00_ff'] / 3.0
+
+    # Calculate derived quantity related to non-relativistic magnetic pressure
+    elif kwargs['variable'] in \
+            ['derived:' + name for name in ('pmag_nr', 'beta_inv_nr', 'sigma_nr')]:
+        bbx = quantities['bcc1']
+        bby = quantities['bcc2']
+        bbz = quantities['bcc3']
+        pmag = 0.5 * (bbx ** 2 + bby ** 2 + bbz ** 2)
+        if kwargs['variable'] == 'derived:pmag_nr':
+            quantity = pmag
+        elif kwargs['variable'] == 'derived:beta_inv_nr':
+            pgas = (gamma_adi - 1.0) * quantities['eint']
+            quantity = pmag / pgas
+        else:
+            quantity = 2.0 * pmag / quantities['dens']
+
+    # Calculate derived quantity related to relativistic magnetic pressure
+    elif kwargs['variable'] in ['derived:' + name for name in
+                                ('pmag_rel', 'beta_inv_rel', 'sigma_rel', 'pmag_prad')]:
+        x, y, z = xyz(num_blocks_used, block_nx1, block_nx2, extents,
+                      kwargs['dimension'], kwargs['location'])
+        alpha, betax, betay, betaz, g_tt, g_tx, g_ty, g_tz, g_xx, g_xy, g_xz, g_yy, \
+            g_yz, g_zz = cks_geometry(bh_a, x, y, z)
+        uux = quantities['velx']
+        uuy = quantities['vely']
+        uuz = quantities['velz']
+        uut = normal_lorentz(uux, uuy, uuz, g_xx, g_xy, g_xz, g_yy, g_yz, g_zz)
+        ut, ux, uy, uz = norm_to_coord(uut, uux, uuy, uuz, alpha, betax, betay, betaz)
+        u_t, u_x, u_y, u_z = lower_vector(ut, ux, uy, uz, g_tt, g_tx, g_ty, g_tz, g_xx,
+                                          g_xy, g_xz, g_yy, g_yz, g_zz)
+        bbx = quantities['bcc1']
+        bby = quantities['bcc2']
+        bbz = quantities['bcc3']
+        bt, bx, by, bz = three_field_to_four_field(bbx, bby, bbz,
+                                                   ut, ux, uy, uz, u_x, u_y, u_z)
+        b_t, b_x, b_y, b_z = lower_vector(bt, bx, by, bz, g_tt, g_tx, g_ty, g_tz, g_xx,
+                                          g_xy, g_xz, g_yy, g_yz, g_zz)
+        pmag = 0.5 * (b_t * bt + b_x * bx + b_y * by + b_z * bz)
+        if kwargs['variable'] == 'derived:pmag_rel':
+            quantity = pmag
+        elif kwargs['variable'] == 'derived:beta_inv_rel':
+            pgas = (gamma_adi - 1.0) * quantities['eint']
+            quantity = pmag / pgas
+        elif kwargs['variable'] == 'derived:sigma_rel':
+            quantity = 2.0 * pmag / quantities['dens']
+        else:
+            prad = quantities['r00_ff'] / 3.0
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore',
+                                        message=('divide by zero '
+                                                 'encountered in true_divide'),
+                                        category=RuntimeWarning)
+                quantity = pmag / prad
+
+    # Calculate derived quantity related to relativistic velocity
+    elif kwargs['variable'] in ['derived:' + name for name in
+                                ('uut', 'ut', 'ux', 'uy', 'uz', 'vx', 'vy', 'vz')]:
+        x, y, z = xyz(num_blocks_used, block_nx1, block_nx2, extents,
+                      kwargs['dimension'], kwargs['location'])
+        alpha, betax, betay, betaz, g_tt, g_tx, g_ty, g_tz, g_xx, g_xy, g_xz, g_yy, \
+            g_yz, g_zz = cks_geometry(bh_a, x, y, z)
+        uux = quantities['velx']
+        uuy = quantities['vely']
+        uuz = quantities['velz']
+        uut = normal_lorentz(uux, uuy, uuz, g_xx, g_xy, g_xz, g_yy, g_yz, g_zz)
+        ut, ux, uy, uz = norm_to_coord(uut, uux, uuy, uuz, alpha, betax, betay, betaz)
+        if kwargs['variable'] == 'derived:uut':
+            quantity = uut
+        elif kwargs['variable'] == 'derived:ut':
+            quantity = ut
+        elif kwargs['variable'] == 'derived:ux':
+            quantity = ux
+        elif kwargs['variable'] == 'derived:uy':
+            quantity = uy
+        elif kwargs['variable'] == 'derived:uz':
+            quantity = uz
+        elif kwargs['variable'] == 'derived:vx':
+            quantity = ux / ut
+        elif kwargs['variable'] == 'derived:vy':
+            quantity = uy / ut
+        else:
+            quantity = uz / ut
+
+    # Calculate derived quantity related to non-relativistic conserved variables
+    elif kwargs['variable'] in \
+            ['derived:cons_hydro_nr_' + name for name in ('t', 'x', 'y', 'z')] \
+            + ['derived:cons_em_nr_t'] \
+            + ['derived:cons_mhd_nr_' + name for name in ('t', 'x', 'y', 'z')]:
+        if kwargs['variable'] in \
+                ['derived:cons_' + name + '_nr_t' for name in ('hydro', 'mhd')]:
+            rho = quantities['dens']
+            ugas = quantities['eint']
+            vx = quantities['velx']
+            vy = quantities['vely']
+            vz = quantities['velz']
+            quantity = 0.5 * rho * (vx ** 2 + vy ** 2 + vz ** 2) + ugas
+        elif kwargs['variable'] in \
+                ['derived:cons_' + name + '_nr_x' for name in ('hydro', 'mhd')]:
+            rho = quantities['dens']
+            vx = quantities['velx']
+            quantity = rho * vx
+        elif kwargs['variable'] in \
+                ['derived:cons_' + name + '_nr_y' for name in ('hydro', 'mhd')]:
+            rho = quantities['dens']
+            vy = quantities['vely']
+            quantity = rho * vy
+        elif kwargs['variable'] in \
+                ['derived:cons_' + name + '_nr_z' for name in ('hydro', 'mhd')]:
+            rho = quantities['dens']
+            vz = quantities['velz']
+            quantity = rho * vz
+        else:
+            quantity = 0.0
+        if kwargs['variable'] in \
+                ['derived:cons_' + name + '_nr_t' for name in ('em', 'mhd')]:
+            bbx = quantities['bcc1']
+            bby = quantities['bcc2']
+            bbz = quantities['bcc3']
+            quantity += 0.5 * (bbx ** 2 + bby ** 2 + bbz ** 2)
+
+    # Calculate derived quantity related to relativistic conserved variables
+    elif kwargs['variable'] in \
+            ['derived:cons_hydro_rel_' + name for name in ('t', 'x', 'y', 'z')] \
+            + ['derived:cons_em_rel_' + name for name in ('t', 'x', 'y', 'z')] \
+            + ['derived:cons_mhd_rel_' + name for name in ('t', 'x', 'y', 'z')]:
+        x, y, z = xyz(num_blocks_used, block_nx1, block_nx2, extents,
+                      kwargs['dimension'], kwargs['location'])
+        alpha, betax, betay, betaz, g_tt, g_tx, g_ty, g_tz, g_xx, g_xy, g_xz, g_yy, \
+            g_yz, g_zz = cks_geometry(bh_a, x, y, z)
+        uux = quantities['velx']
+        uuy = quantities['vely']
+        uuz = quantities['velz']
+        uut = normal_lorentz(uux, uuy, uuz, g_xx, g_xy, g_xz, g_yy, g_yz, g_zz)
+        ut, ux, uy, uz = norm_to_coord(uut, uux, uuy, uuz, alpha, betax, betay, betaz)
+        u_t, u_x, u_y, u_z = lower_vector(ut, ux, uy, uz, g_tt, g_tx, g_ty, g_tz, g_xx,
+                                          g_xy, g_xz, g_yy, g_yz, g_zz)
+        if kwargs['variable'] in \
+                ['derived:cons_hydro_rel_' + name for name in ('t', 'x', 'y', 'z')] \
+                + ['derived:cons_mhd_rel_' + name for name in ('t', 'x', 'y', 'z')]:
+            rho = quantities['dens']
+            ugas = quantities['eint']
+            pgas = (gamma_adi - 1.0) * ugas
+            wgas = rho + ugas + pgas
+            if kwargs['variable'] in \
+                    ['derived:cons_' + name + '_rel_t' for name in ('hydro', 'mhd')]:
+                quantity = wgas * ut * u_t + pgas
+            elif kwargs['variable'] in \
+                    ['derived:cons_' + name + '_rel_x' for name in ('hydro', 'mhd')]:
+                quantity = wgas * ut * u_x
+            elif kwargs['variable'] in \
+                    ['derived:cons_' + name + '_rel_y' for name in ('hydro', 'mhd')]:
+                quantity = wgas * ut * u_y
+            else:
+                quantity = wgas * ut * u_z
+        else:
+            quantity = 0.0
+        if kwargs['variable'] in \
+                ['derived:cons_em_rel_' + name for name in ('t', 'x', 'y', 'z')] \
+                + ['derived:cons_mhd_rel_' + name for name in ('t', 'x', 'y', 'z')]:
+            bbx = quantities['bcc1']
+            bby = quantities['bcc2']
+            bbz = quantities['bcc3']
+            bt, bx, by, bz = three_field_to_four_field(bbx, bby, bbz, ut, ux, uy, uz,
+                                                       u_x, u_y, u_z)
+            b_t, b_x, b_y, b_z = lower_vector(bt, bx, by, bz, g_tt, g_tx, g_ty, g_tz,
+                                              g_xx, g_xy, g_xz, g_yy, g_yz, g_zz)
+            umag = 0.5 * (b_t * bt + b_x * bx + b_y * by + b_z * bz)
+            pmag = umag
+            if kwargs['variable'] in \
+                    ['derived:cons_' + name + '_rel_t' for name in ('em', 'mhd')]:
+                quantity += (umag + pmag) * ut * u_t + pmag - bt * b_t
+            elif kwargs['variable'] in \
+                    ['derived:cons_' + name + '_rel_x' for name in ('em', 'mhd')]:
+                quantity += (umag + pmag) * ut * u_x - bt * b_x
+            elif kwargs['variable'] in \
+                    ['derived:cons_' + name + '_rel_y' for name in ('em', 'mhd')]:
+                quantity += (umag + pmag) * ut * u_y - bt * b_y
+            else:
+                quantity += (umag + pmag) * ut * u_z - bt * b_z
+
+    # Extract quantity without derivation
+    else:
+        quantity = quantities[variable_name]
+
+    # Calculate colors
+    if kwargs['vmin'] is None:
+        vmin = np.nanmin(quantity)
+    else:
+        vmin = kwargs['vmin']
+    if kwargs['vmax'] is None:
+        vmax = np.nanmax(quantity)
+    else:
+        vmax = kwargs['vmax']
+
+    # Choose colormap norm
+    if kwargs['norm'] == 'linear':
+        norm = colors.Normalize(vmin, vmax)
+        vmin = None
+        vmax = None
+    elif kwargs['norm'] == 'log':
+        norm = colors.LogNorm(vmin, vmax)
+        vmin = None
+        vmax = None
+    else:
+        norm = kwargs['norm']
+
+    # Prepare figure
+    plt.figure()
+    
+    # Plot data
+    for block_num in range(num_blocks_used):
+        plt.imshow(quantity[block_num], cmap=kwargs['cmap'], norm=norm, vmin=vmin,
+                   vmax=vmax, interpolation='none', origin='lower',
+                   extent=extents[block_num])
+    # Make colorbar
+    plt.colorbar()
+
+    # Mark and/or mask horizon
+    if kwargs['horizon'] or kwargs['horizon_mask']:
+        r_hor = 1.0 + (1.0 - bh_a ** 2) ** 0.5
+        if kwargs['dimension'] in ('x', 'y') \
+                and kwargs['location'] ** 2 < r_hor ** 2 + bh_a ** 2:
+            full_width = 2.0 * (r_hor ** 2 + bh_a ** 2 - kwargs['location'] ** 2) ** 0.5
+            full_height = 2.0 * ((r_hor ** 2 + bh_a ** 2 - kwargs['location'] ** 2)
+                                 / (1.0 + bh_a ** 2 / r_hor ** 2)) ** 0.5
+            if kwargs['horizon_mask']:
+                horizon_mask = patches.Ellipse((0.0, 0.0), full_width, full_height,
+                                               facecolor=kwargs['horizon_mask_color'],
+                                               edgecolor='none')
+                plt.gca().add_artist(horizon_mask)
+            if kwargs['horizon']:
+                horizon = patches.Ellipse((0.0, 0.0), full_width, full_height,
+                                          linestyle=horizon_line_style,
+                                          linewidth=horizon_line_width,
+                                          facecolor='none',
+                                          edgecolor=kwargs['horizon_color'])
+                plt.gca().add_artist(horizon)
+        if kwargs['dimension'] == 'z' and abs(kwargs['location']) < r_hor:
+            radius = ((r_hor ** 2 + bh_a ** 2)
+                      * (1.0 - kwargs['location'] ** 2 / r_hor ** 2)) ** 0.5
+            if kwargs['horizon_mask']:
+                horizon_mask = patches.Circle((0.0, 0.0), radius=radius,
+                                              facecolor=kwargs['horizon_mask_color'],
+                                              edgecolor='none')
+                plt.gca().add_artist(horizon_mask)
+            if kwargs['horizon']:
+                horizon = patches.Circle((0.0, 0.0), radius=radius,
+                                         linestyle=horizon_line_style,
+                                         linewidth=horizon_line_width,
+                                         facecolor='none',
+                                         edgecolor=kwargs['horizon_color'])
+                plt.gca().add_artist(horizon)
+
+    # Mark ergosphere
+    if kwargs['ergosphere']:
+        r_hor = 1.0 + (1.0 - bh_a ** 2) ** 0.5
+        if kwargs['dimension'] in ('x', 'y') \
+                and kwargs['location'] ** 2 < 4.0 + bh_a ** 2:
+            w = np.linspace(abs(kwargs['location']), (4.0 + bh_a ** 2) ** 0.5,
+                            ergosphere_num_points)
+            z = np.empty_like(w)
+            for ind, w_val in enumerate(w):
+                def residual_hor(z_val):
+                    rr2 = w_val ** 2 + z_val ** 2
+                    r2 = 0.5 * (rr2 - bh_a ** 2 + ((rr2 - bh_a ** 2) ** 2
+                                + 4.0 * bh_a ** 2 * z_val ** 2) ** 0.5)
+                    return r2 - r_hor ** 2
+                if residual_hor(0.0) < 0.0:
+                    z_min = brentq(residual_hor, 0.0, 2.0)
+                else:
+                    z_min = 0.0
+
+                def residual_ergo(z_val):
+                    rr2 = w_val ** 2 + z_val ** 2
+                    r2 = 0.5 * (rr2 - bh_a ** 2 + ((rr2 - bh_a ** 2) ** 2
+                                + 4.0 * bh_a ** 2 * z_val ** 2) ** 0.5)
+                    return r2 ** 2 - 2.0 * r2 ** 1.5 + bh_a ** 2 * z_val ** 2
+                if residual_ergo(z_min) <= 0.0:
+                    z[ind] = brentq(residual_ergo, z_min, 2.0)
+                else:
+                    z[ind] = 0.0
+            xy_plot = np.sqrt(w ** 2 - kwargs['location'] ** 2)
+            xy_plot = np.concatenate((-xy_plot[::-1], xy_plot))
+            xy_plot = np.concatenate((xy_plot, xy_plot[::-1]))
+            z_plot = np.concatenate((z[::-1], z))
+            z_plot = np.concatenate((z_plot, -z_plot[::-1]))
+            plt.plot(xy_plot, z_plot, linestyle=ergosphere_line_style,
+                     linewidth=ergosphere_line_width, color=kwargs['ergosphere_color'],
+                     zorder=0)
+        if kwargs['dimension'] == 'z' and abs(kwargs['location']) < r_hor:
+            def residual_ergo(r):
+                return r ** 4 - 2.0 * r ** 3 + bh_a ** 2 * kwargs['location'] ** 2
+            r_ergo = brentq(residual_ergo, r_hor, 2.0)
+            radius = ((r_ergo ** 2 + bh_a ** 2)
+                      * (1.0 - kwargs['location'] ** 2 / r_ergo ** 2)) ** 0.5
+            ergosphere = patches.Circle((0.0, 0.0), radius=radius,
+                                        linestyle=ergosphere_line_style,
+                                        linewidth=ergosphere_line_width,
+                                        facecolor='none',
+                                        edgecolor=kwargs['ergosphere_color'])
+            plt.gca().add_artist(ergosphere)
+
+    # Adjust axes
+    if kwargs['dimension'] == 'x':
+        x1_min = float(input_data['mesh']['x2min'])
+        x1_max = float(input_data['mesh']['x2max'])
+        x2_min = float(input_data['mesh']['x3min'])
+        x2_max = float(input_data['mesh']['x3max'])
+    if kwargs['dimension'] == 'y':
+        x1_min = float(input_data['mesh']['x1min'])
+        x1_max = float(input_data['mesh']['x1max'])
+        x2_min = float(input_data['mesh']['x3min'])
+        x2_max = float(input_data['mesh']['x3max'])
+    if kwargs['dimension'] == 'z':
+        x1_min = float(input_data['mesh']['x1min'])
+        x1_max = float(input_data['mesh']['x1max'])
+        x2_min = float(input_data['mesh']['x2min'])
+        x2_max = float(input_data['mesh']['x2max'])
+    if kwargs['x1_min'] is not None:
+        x1_min = kwargs['x1_min']
+    if kwargs['x1_max'] is not None:
+        x1_max = kwargs['x1_max']
+    if kwargs['x2_min'] is not None:
+        x2_min = kwargs['x2_min']
+    if kwargs['x2_max'] is not None:
+        x2_max = kwargs['x2_max']
+    plt.xlim((x1_min, x1_max))
+    plt.ylim((x2_min, x2_max))
+    if kwargs['dimension'] == 'x':
+        plt.xlabel('$y$', labelpad=x1_labelpad)
+        plt.ylabel('$z$', labelpad=x2_labelpad)
+    if kwargs['dimension'] == 'y':
+        plt.xlabel('$x$', labelpad=x1_labelpad)
+        plt.ylabel('$z$', labelpad=x2_labelpad)
+    if kwargs['dimension'] == 'z':
+        plt.xlabel('$x$', labelpad=x1_labelpad)
+        plt.ylabel('$y$', labelpad=x2_labelpad)
+    
+    # Adjust layout
+    plt.tight_layout()
+
+    # Save or display figure
+    if kwargs['output_file'] != 'show':
+        plt.savefig(kwargs['output_file'], dpi=dpi)
+    else:
+        plt.show()
+
+
+# Function for calculating cell coordinates
+def xyz(num_blocks_used, block_nx1, block_nx2, extents, dimension, location):
+    x1 = np.empty((num_blocks_used, block_nx2, block_nx1))
+    x2 = np.empty((num_blocks_used, block_nx2, block_nx1))
+    for block_ind in range(len(extents)):
+        x1f = np.linspace(extents[block_ind][0], extents[block_ind][1], block_nx1 + 1)
+        x1v = 0.5 * (x1f[:-1] + x1f[1:])
+        x1[block_ind, :, :] = x1v[None, :]
+        x2f = np.linspace(extents[block_ind][2], extents[block_ind][3], block_nx2 + 1)
+        x2v = 0.5 * (x2f[:-1] + x2f[1:])
+        x2[block_ind, :, :] = x2v[:, None]
+    if dimension == 'x':
+        x = np.full((num_blocks_used, block_nx2, block_nx1), location)
+        y = x1
+        z = x2
+    if dimension == 'y':
+        y = np.full((num_blocks_used, block_nx2, block_nx1), location)
+        x = x1
+        z = x2
+    if dimension == 'z':
+        z = np.full((num_blocks_used, block_nx2, block_nx1), location)
+        x = x1
+        y = x2
+    return x, y, z
+
+
+# Function for calculating quantities related to CKS metric
+def cks_geometry(a, x, y, z):
+    a2 = a ** 2
+    z2 = z ** 2
+    rr2 = x ** 2 + y ** 2 + z2
+    r2 = 0.5 * (rr2 - a2 + np.sqrt((rr2 - a2) ** 2 + 4.0 * a2 * z2))
+    r = np.sqrt(r2)
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore',
+                                message='invalid value encountered in true_divide',
+                                category=RuntimeWarning)
+        f = 2.0 * r2 * r / (r2 ** 2 + a2 * z2)
+        lx = (r * x + a * y) / (r2 + a2)
+        ly = (r * y - a * x) / (r2 + a2)
+        lz = z / r
+    gtt = -1.0 - f
+    alpha2 = -1.0 / gtt
+    alpha = np.sqrt(alpha2)
+    betax = alpha2 * f * lx
+    betay = alpha2 * f * ly
+    betaz = alpha2 * f * lz
+    g_tt = -1.0 + f
+    g_tx = f * lx
+    g_ty = f * ly
+    g_tz = f * lz
+    g_xx = 1.0 + f * lx ** 2
+    g_xy = f * lx * ly
+    g_xz = f * lx * lz
+    g_yy = 1.0 + f * ly ** 2
+    g_yz = f * ly * lz
+    g_zz = 1.0 + f * lz ** 2
+    return alpha, betax, betay, betaz, g_tt, g_tx, g_ty, g_tz, g_xx, g_xy, g_xz, g_yy, \
+        g_yz, g_zz
+
+
+# Function for calculating normal-frame Lorentz factor
+def normal_lorentz(uux, uuy, uuz, g_xx, g_xy, g_xz, g_yy, g_yz, g_zz):
+    uut = np.sqrt(1.0 + g_xx * uux ** 2 + 2.0 * g_xy * uux * uuy
+                  + 2.0 * g_xz * uux * uuz + g_yy * uuy ** 2 + 2.0 * g_yz * uuy * uuz
+                  + g_zz * uuz ** 2)
+    return uut
+
+
+# Function for transforming velocity from normal frame to coordinate frame
+def norm_to_coord(uut, uux, uuy, uuz, alpha, betax, betay, betaz):
+    ut = uut / alpha
+    ux = uux - betax * ut
+    uy = uuy - betay * ut
+    uz = uuz - betaz * ut
+    return ut, ux, uy, uz
+
+
+# Function for transforming vector from contravariant to covariant components
+def lower_vector(at, ax, ay, az,
+                 g_tt, g_tx, g_ty, g_tz, g_xx, g_xy, g_xz, g_yy, g_yz, g_zz):
+    a_t = g_tt * at + g_tx * ax + g_ty * ay + g_tz * az
+    a_x = g_tx * at + g_xx * ax + g_xy * ay + g_xz * az
+    a_y = g_ty * at + g_xy * ax + g_yy * ay + g_yz * az
+    a_z = g_tz * at + g_xz * ax + g_yz * ay + g_zz * az
+    return a_t, a_x, a_y, a_z
+
+
+# Function for converting 3-magnetic field to 4-magnetic field
+def three_field_to_four_field(bbx, bby, bbz, ut, ux, uy, uz, u_x, u_y, u_z):
+    bt = u_x * bbx + u_y * bby + u_z * bbz
+    bx = (bbx + bt * ux) / ut
+    by = (bby + bt * uy) / ut
+    bz = (bbz + bt * uz) / ut
+    return bt, bx, by, bz
+
+
+# Parse inputs and execute main function
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('data_file', help='name of input file, possibly including path')
+    parser.add_argument('variable', help='name of variable to be plotted, any valid'
+                                         'derived quantity prefaced by "derived:"')
+    parser.add_argument('output_file', help='name of output to be (over)written; use '
+                        '"show" to show interactive plot instead')
+    parser.add_argument('-d', '--dimension', choices=('x', 'y', 'z', '1', '2', '3'),
+                        help='dimension orthogonal to slice for 3D data')
+    parser.add_argument('-l', '--location', type=float, default=0.0,
+                        help='coordinate value along which slice is to be taken '
+                             '(default: 0)')
+    parser.add_argument('--x1_min', type=float,
+                        help='horizontal coordinate of left edge of plot')
+    parser.add_argument('--x1_max', type=float,
+                        help='horizontal coordinate of right edge of plot')
+    parser.add_argument('--x2_min', type=float,
+                        help='vertical coordinate of bottom edge of plot')
+    parser.add_argument('--x2_max', type=float,
+                        help='vertical coordinate of top edge of plot')
+    parser.add_argument('-c', '--cmap', help='name of Matplotlib colormap to use')
+    parser.add_argument('-n', '--norm', help='name of Matplotlib norm to use')
+    parser.add_argument('--vmin', type=float, help='colormap minimum')
+    parser.add_argument('--vmax', type=float, help='colormap maximum')
+    parser.add_argument('--notex', action='store_true',
+                        help='flag indicating LaTeX integration is not to be used')
+    parser.add_argument('--horizon', action='store_true',
+                        help='flag indicating black hole event horizon should be marked')
+    parser.add_argument('--horizon_color', default='k',
+                        help='color string for event horizon marker')
+    parser.add_argument('--horizon_mask', action='store_true',
+                        help='flag indicating black hole event horizon should be masked')
+    parser.add_argument('--horizon_mask_color', default='k',
+                        help='color string for event horizon mask')
+    parser.add_argument('--ergosphere', action='store_true',
+                        help='flag indicating black hole ergosphere should be marked')
+    parser.add_argument('--ergosphere_color', default='gray',
+                        help='color string for ergosphere marker')
+    args = parser.parse_args()
+    main(**vars(args))
diff --git a/plot_tab.py b/plot_tab.py
new file mode 100755
index 0000000..343da04
--- /dev/null
+++ b/plot_tab.py
@@ -0,0 +1,242 @@
+#! /usr/bin/env python
+
+# Script for plotting and animating 1D data from Athena++ .tab files.
+# Example make a single plot for one .tab file use:
+
+# Example to animate a sequentially numbered list of .tab files use:
+
+# Run "plot_tab.py -h" for help.
+
+# Python modules
+import argparse
+import matplotlib.widgets as mwidgets
+from matplotlib.animation import FuncAnimation
+import matplotlib as mpl
+import mpl_toolkits.axes_grid1
+import athena_read
+mpl.rcParams['animation.embed_limit'] = 2**32
+
+
+# custom animation class Player
+# is derived class of FuncAnimation
+class Player(FuncAnimation):
+    def __init__(self, fig, func, frames=None, init_func=None,
+                 fargs=None, save_count=None, mini=0, maxi=100,
+                 pos=(0.125, 0.94), **kwargs):
+        self.i = 0
+        self.min = mini
+        self.max = maxi
+        self.runs = True
+        self.forwards = True
+        self.fig = fig
+        self.func = func
+        self.setup(pos)
+        FuncAnimation.__init__(self, self.fig, self.update,
+                               frames=self.play(), init_func=init_func,
+                               fargs=None, save_count=None,
+                               interval=200, cache_frame_data=False, **kwargs)
+
+    # version that stops when reaching end of plot list
+    # def play(self):
+    #    while self.runs:
+    #        if self.i > self.min and self.i < self.max:
+    #            self.i = self.i+self.forwards-(not self.forwards)
+    #            yield self.i
+    #        elif self.i == self.min and self.forwards:
+    #            self.i+=1
+    #            yield self.i
+    #        elif self.i == self.max and not self.forwards:
+    #            self.i-=1
+    #            yield self.i
+    #        else:
+    #            self.stop()
+    #            yield self.i
+
+    # version that loops forever
+    def play(self):
+        while self.runs:
+            self.i = self.i+self.forwards-(not self.forwards)
+            if self.i > self.max:
+                self.i = self.min
+            if self.i < self.min:
+                self.i = self.max
+            yield self.i
+
+    def start(self):
+        self.runs = True
+        self.event_source.start()
+
+    def stop(self, event=None):
+        self.runs = False
+        self.event_source.stop()
+
+    def forward(self, event=None):
+        self.event_source.interval = 200
+        self.forwards = True
+        self.start()
+
+    def fastforward(self, event=None):
+        self.event_source.interval = 100
+        self.forwards = True
+        self.start()
+
+    def backward(self, event=None):
+        self.event_source.interval = 200
+        self.forwards = False
+        self.start()
+
+    def fastbackward(self, event=None):
+        self.event_source.interval = 100
+        self.forwards = False
+        self.start()
+
+    def oneforward(self, event=None):
+        self.forwards = True
+        self.onestep()
+
+    def onebackward(self, event=None):
+        self.forwards = False
+        self.onestep()
+
+    def onestep(self):
+        if self.i > self.min and self.i < self.max:
+            self.i = self.i+self.forwards-(not self.forwards)
+        elif self.i == self.min and self.forwards:
+            self.i += 1
+        elif self.i == self.max and not self.forwards:
+            self.i -= 1
+        self.func(self.i)
+        self.slider.set_val(self.i)
+        self.fig.canvas.draw_idle()
+
+    def setup(self, pos):
+        playerax = self.fig.add_axes([pos[0], pos[1], 0.64, 0.04])
+        divider = mpl_toolkits.axes_grid1.make_axes_locatable(playerax)
+        fbax = divider.append_axes("right", size="80%", pad=0.05)
+        bax = divider.append_axes("right", size="80%", pad=0.05)
+        sax = divider.append_axes("right", size="80%", pad=0.05)
+        fax = divider.append_axes("right", size="80%", pad=0.05)
+        ffax = divider.append_axes("right", size="80%", pad=0.05)
+        ofax = divider.append_axes("right", size="100%", pad=0.05)
+        sliderax = divider.append_axes("right", size="500%", pad=0.07)
+        self.button_oneback = mwidgets.Button(playerax, label='$\u29CF$')
+        self.button_fastback = mwidgets.Button(fbax, label='$\u25C0\u25C0$')
+        self.button_back = mwidgets.Button(bax, label='$\u25C0$')
+        self.button_stop = mwidgets.Button(sax, label='$\u25A0$')
+        self.button_forward = mwidgets.Button(fax, label='$\u25B6$')
+        self.button_fastforward = mwidgets.Button(ffax, label='$\u25B6\u25B6$')
+        self.button_oneforward = mwidgets.Button(ofax, label='$\u29D0$')
+        self.button_oneback.on_clicked(self.onebackward)
+        self.button_fastback.on_clicked(self.fastbackward)
+        self.button_back.on_clicked(self.backward)
+        self.button_stop.on_clicked(self.stop)
+        self.button_forward.on_clicked(self.forward)
+        self.button_fastforward.on_clicked(self.fastforward)
+        self.button_oneforward.on_clicked(self.oneforward)
+        self.slider = mwidgets.Slider(sliderax, '', self.min, self.max,
+                                      valinit=self.i, valfmt='%0.0f',
+                                      valstep=1)
+        self.slider.on_changed(self.set_pos)
+
+    def set_pos(self, i):
+        self.i = int(self.slider.val)
+        self.func(self.i)
+
+    def update(self, i):
+        self.slider.set_val(i)
+
+
+# Main function
+def main(**kwargs):
+
+    # Load Python plotting modules
+    output_file = kwargs['output']
+    if output_file != 'show':
+        import matplotlib
+        matplotlib.use('agg')
+    import matplotlib.pyplot as plt
+
+    # get input filename
+    input_file = kwargs['input']
+    nfiles = int(kwargs['nfiles'])
+
+    fprefix = input_file[:-9]
+    fnumber = int(input_file[-9:-4])
+    fnames = [fprefix+str(fnumber+i).zfill(5)+'.tab' for i in range(nfiles)]
+    data = []
+    for n in range(nfiles):
+        data.append(athena_read.tab(fnames[n]))
+
+    # read data, get variable names and check they are valid
+    yvar = kwargs['variables']
+    if yvar not in data[0]:
+        print('Invalid input variable name, valid names are:')
+        for key in data[0]:
+            print(key)
+        raise RuntimeError
+    # set x/y data
+    y_vals = []
+    x_vals = []
+    for n in range(nfiles):
+        y_vals.append(data[n][yvar])
+    if 'x1v' in data[0]:
+        xvar = 'x1v'
+    if 'x2v' in data[0]:
+        xvar = 'x2v'
+    if 'x3v' in data[0]:
+        xvar = 'x3v'
+    for n in range(nfiles):
+        x_vals.append(data[n][xvar])
+
+    # print(xvar)
+    # print(data)
+    # print(y_vals)
+    # print(x_vals)
+
+    # make single plot
+    if (nfiles == 1):
+        # Plot data
+        plt.figure()
+        plt.plot(x_vals[0], y_vals[0], '.')
+        plt.show()
+
+    # make animation with multiple files
+    else:
+        fig = plt.figure()
+        ax = fig.add_subplot(1, 1, 1)
+
+        def update_func(i):
+            ax.clear()
+            ax.plot(x_vals[i], y_vals[i], '.')
+            # if xlim != (None,None):
+            #     ax.set_xlim(xlim)
+            # if ylim != (None,None):
+            #     ax.set_ylim(ylim)
+            ax.set_title('Time=%f'%data[i]['time'])  # noqa
+            ax.set_xlabel(xvar)
+            ax.set_ylabel(yvar)
+        Player(fig, update_func, maxi=(nfiles-1))
+        plt.show()
+        # to save movie as mp4 use following instead of 'Player'
+        # anim=FuncAnimation(fig, update_func)
+        # plt.show()
+        # FFwriter = animation.FFMpegWriter(fps=20)
+        # anim.save('./animation.mp4', writer = FFwriter)
+
+
+# Execute main function
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-i', '--input',
+                        help='name of input (tab) file')
+    parser.add_argument('-o', '--output',
+                        default='show',
+                        help='image filename; omit to display to screen')
+    parser.add_argument('-v', '--variables',
+                        help='comma-separated list of variables to be plotted')
+    parser.add_argument('-n', '--nfiles',
+                        default=1,
+                        help='number of files to be plotted for animations')
+
+    args = parser.parse_args()
+    main(**vars(args))
diff --git a/pyqt_menu.py b/pyqt_menu.py
new file mode 100755
index 0000000..87fc79a
--- /dev/null
+++ b/pyqt_menu.py
@@ -0,0 +1,245 @@
+#! /usr/bin/env python
+from PyQt5 import QtWidgets as qw, QtGui as qg
+from argparse import ArgumentParser
+from json import load
+from subprocess import Popen, PIPE
+from re import match
+from sys import argv
+from os import path
+
+# parse arguments
+argparser = ArgumentParser(description='Runs the GUI for configuring an athinput file')
+argparser.add_argument('--tk', 
+                       action='store_true', 
+                       help='uses PYSimpleGUI (tkinter) instead of PySimpleGUIQt', 
+                       default=False)
+argparser.add_argument('-r', '--run',
+                       action='store_true',
+                       help='executes the athena command and plots the tab files on run',
+                       default=False)
+args = argparser.parse_args()
+
+# building gui
+with open('athena_problems.json') as problems_json:
+    problems = load(problems_json)
+
+athena_problems = list(problems['athena'])
+athenac_problems = list(problems['athenac'])
+athenak_problems = list(problems['athenak'])
+
+class MainWindow(qw.QMainWindow):
+    def __init__(self):
+        super().__init__()
+
+        self.radio_groups = []
+        self.windows = []
+
+        page_layout = qw.QVBoxLayout()
+        radio_layout = qw.QHBoxLayout()
+        exe_layout = qw.QHBoxLayout()
+        load_layout = qw.QHBoxLayout()
+        predef_layout = qw.QHBoxLayout()
+        self.current_athena = 'athena'
+
+        toolbar = self.addToolBar('ToolBar')
+
+        launch_action = qw.QAction('Launch', self)
+        launch_action.setToolTip('Launch the parameter configurator')
+        launch_action.triggered.connect(self.launch)
+        toolbar.addAction(launch_action)
+        toolbar.addSeparator()
+
+        help_action = qw.QAction('Help', self)
+        help_action.setToolTip('Open help menu')
+        help_action.triggered.connect(self.help)
+        toolbar.addAction(help_action)
+        toolbar.addSeparator()
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Exit the program')
+        quit_action.triggered.connect(self.quit)
+        toolbar.addAction(quit_action)
+
+        label = qw.QLabel('Athena Version:')
+        radio_layout.addWidget(label)
+        label.setStyleSheet("font-weight: bold")
+        radio_layout.addStretch()
+        rbtn = qw.QRadioButton('Athena')
+        rbtn.setChecked(True)
+        rbtn.toggled.connect(lambda: self.switch('athena'))
+        radio_layout.addWidget(rbtn)
+        rbtn = qw.QRadioButton('AthenaK')
+        rbtn.toggled.connect(lambda: self.switch('athenak'))
+        radio_layout.addWidget(rbtn)
+        rbtn = qw.QRadioButton('AthenaC')
+        rbtn.toggled.connect(lambda: self.switch('athenac'))
+        radio_layout.addWidget(rbtn)
+
+        label = qw.QLabel('Athena Executable:')
+        exe_layout.addWidget(label)
+        label.setStyleSheet("font-weight: bold")
+        btn = qw.QPushButton(self)
+        btn.setText("browse")
+        def browse(t):
+            file = qw.QFileDialog.getOpenFileName(self, "Select File", "")[0]
+            t.setText(file)
+        self.exe = qw.QLineEdit(self)
+        btn.clicked.connect(lambda: browse(self.exe))
+        self.exe.setFixedWidth(250)
+        self.exe.setText('./athena/bin/athena')
+        exe_layout.addStretch()
+        exe_layout.addWidget(btn)
+        exe_layout.addWidget(self.exe)
+
+        btn_group = qw.QButtonGroup()
+
+        self.load_radio = qw.QRadioButton('Load Problem:')
+        self.load_radio.setStyleSheet('font-weight: bold')
+        self.load_radio.setChecked(True)
+        load_layout.addWidget(self.load_radio)
+        load_layout.addStretch()
+        btn = qw.QPushButton(self)
+        btn.setText("browse")
+        self.problem = qw.QLineEdit(self)
+        btn.clicked.connect(lambda: browse(self.problem))
+        self.problem.setFixedWidth(250)
+        self.problem.setText('./athinput.linear_wave1d')
+        load_layout.addWidget(btn)
+        load_layout.addWidget(self.problem)
+
+        self.predef_radio = qw.QRadioButton('Predefined Problem:')
+        self.predef_radio.setStyleSheet('font-weight: bold')
+        predef_layout.addWidget(self.predef_radio)
+        self.combo = qw.QComboBox()
+        self.combo.addItems(athena_problems)
+        predef_layout.addStretch()
+        predef_layout.addWidget(self.combo)
+
+        btn_group.addButton(self.load_radio)
+        btn_group.addButton(self.predef_radio)
+        self.radio_groups.append(btn_group)
+
+        page_layout.addLayout(radio_layout)
+        page_layout.addLayout(exe_layout)
+        page_layout.addLayout(load_layout)
+        page_layout.addLayout(predef_layout)
+        # checkbox
+
+        self.reconfig = qw.QCheckBox('Reconfigure Executable')
+        page_layout.addWidget(self.reconfig)
+
+        widget = qw.QWidget()
+        widget.setLayout(page_layout) 
+        scroll = qw.QScrollArea()    #add scrollbar
+        scroll.setWidgetResizable(True)
+        scroll.setWidget(widget)
+        self.resize(700, 300)
+        self.setCentralWidget(scroll)
+
+    def switch(self, type):
+        self.combo.clear()
+        if type == 'athena':
+            self.combo.addItems(athena_problems)
+            self.reconfig.setVisible(True)
+        elif type == 'athenak':
+            self.combo.addItems(athenak_problems)
+            self.reconfig.setVisible(False)
+        else:
+            self.combo.addItems(athenac_problems)
+            self.reconfig.setVisible(True)
+        self.current_athena = type
+
+    def rebuild(self, problem):
+        config = None
+        with open(problem) as file:
+            line = file.readline()
+            while line:
+                m = match('config[^=]+=(.+)', line)
+                if m:
+                    config = m.group(1)
+                    break
+                line = file.readline()
+        w = ConfigWindow(config)
+        w.show()
+        w.run()
+        w.close()
+
+    def launch(self):
+        problem = problems[self.current_athena][self.combo.currentText()] if self.predef_radio.isChecked() else self.problem.text()
+        cmd = './pyqt_run.py %s -x %s %s %s' % (problem, 
+                                                self.exe.text(),
+                                                '-r' if args.run else '',
+                                                '--tk' if args.tk else '') 
+        print(cmd)
+        try:
+            if self.reconfig.isChecked():
+                if self.current_athena == 'athenac':
+                    raise Exception('Athena C reconfigure not yet implemented')
+                # otherwise it is athena++
+                print(problem)
+                self.rebuild(problem)
+            if not path.exists(problem):
+                raise FileNotFoundError
+            Popen(cmd.split())
+        except Exception as e:
+            print(e)
+
+    def help(self):
+        w = HelpWindow()
+        self.windows.append(w)
+        w.show()
+
+    def quit(self):
+        self.close()
+
+class ConfigWindow(qw.QWidget):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.setWindowTitle('Rebuilding Executable')
+        self.main_layout = qw.QVBoxLayout()
+        bash_label = qw.QLabel('./reconfig.sh ' + self.config)
+        bash_label.setStyleSheet('font-weight: bold')
+        bash_label.setFont(qg.QFont('Courier New', 10))
+        self.main_layout.addWidget(bash_label)
+        self.txt = qw.QLabel()
+        self.txt.setFont(qg.QFont('Courier New', 10))
+        self.main_layout.addWidget(self.txt)
+        self.setLayout(self.main_layout)
+
+    def run(self):
+        p = Popen(['./reconfig.sh', self.config], stdout=PIPE)
+        line = p.stdout.readline()
+        while line:
+            self.txt.setText(line.decode())
+            qg.QGuiApplication.processEvents()
+            line = p.stdout.readline()
+
+class HelpWindow(qw.QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle('Help')
+        self.main_layout = qw.QVBoxLayout()
+        self.add_label('Athena Version:', '\tThe version of Athena (must match the version of the executable) to be used')
+        self.add_label('Athena Executable:', '\tEither the path or the name of the Athena executable. If only a name is given, then it is assumed that the executable is in /usr/bin.')
+        self.add_label('Selecting Problems:', '\tA problem can either be selected from the list of predefined problems or a custom problem can be chosen. Use the radio buttons to choose which method to use.')
+        self.setLayout(self.main_layout)
+
+    def add_label(self, s1, s2):
+        txt = qw.QLabel(s1)
+        txt.setStyleSheet('font-weight: bold')
+        self.main_layout.addWidget(txt)
+        self.main_layout.addWidget(qw.QLabel(s2))
+
+
+app = qw.QApplication(argv)
+
+main = MainWindow()
+main.show()
+
+try:
+    #print('opening window')
+    exit(app.exec())
+except:
+    #print('closing window')
+    pass
\ No newline at end of file
diff --git a/pyqt_menu_minik.py b/pyqt_menu_minik.py
new file mode 100755
index 0000000..158e5f4
--- /dev/null
+++ b/pyqt_menu_minik.py
@@ -0,0 +1,253 @@
+#! /usr/bin/env python
+from PyQt5 import QtWidgets as qw, QtGui as qg
+from argparse import ArgumentParser
+from json import load
+from subprocess import Popen, PIPE
+from re import match
+from sys import argv
+from os import path
+
+# parse arguments
+argparser = ArgumentParser(description='Runs the GUI for configuring an athinput file')
+argparser.add_argument('--tk', 
+                       action='store_true', 
+                       help='uses PYSimpleGUI (tkinter) instead of PySimpleGUIQt', 
+                       default=False)
+argparser.add_argument('-r', '--run',
+                       action='store_true',
+                       help='executes the athena command and plots the tab files on run',
+                       default=False)
+args = argparser.parse_args()
+
+# building gui
+with open('athena_problems.json') as problems_json:
+    problems = load(problems_json)
+
+
+athena_problems = list([])
+athenac_problems = list([])
+athenak_problems = list([])
+if 'athena' in problems:
+    athena_problems = list(problems['athena'])
+if 'athenac' in problems:
+    athenac_problems = list(problems['athenac'])
+if 'athenak' in problems:    
+    athenak_problems = list(problems['athenak'])
+
+class MainWindow(qw.QMainWindow):
+    def __init__(self):
+        super().__init__()
+
+        self.radio_groups = []
+        self.windows = []
+
+        page_layout = qw.QVBoxLayout()
+        radio_layout = qw.QHBoxLayout()
+        exe_layout = qw.QHBoxLayout()
+        load_layout = qw.QHBoxLayout()
+        predef_layout = qw.QHBoxLayout()
+        self.current_athena = 'athena'
+
+        toolbar = self.addToolBar('ToolBar')
+
+        launch_action = qw.QAction('Launch', self)
+        launch_action.setToolTip('Launch the parameter configurator')
+        launch_action.triggered.connect(self.launch)
+        toolbar.addAction(launch_action)
+        toolbar.addSeparator()
+
+        help_action = qw.QAction('Help', self)
+        help_action.setToolTip('Open help menu')
+        help_action.triggered.connect(self.help)
+        toolbar.addAction(help_action)
+        toolbar.addSeparator()
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Exit the program')
+        quit_action.triggered.connect(self.quit)
+        toolbar.addAction(quit_action)
+
+        label = qw.QLabel('Athena Version: [deprecating]')
+        radio_layout.addWidget(label)
+        label.setStyleSheet("font-weight: bold")
+        radio_layout.addStretch()
+        rbtn = qw.QRadioButton('Athena')
+        #rbtn.setChecked(True)
+        rbtn.toggled.connect(lambda: self.switch('athena'))
+        radio_layout.addWidget(rbtn)
+        rbtn = qw.QRadioButton('AthenaK')
+        rbtn.setChecked(True)        
+        rbtn.toggled.connect(lambda: self.switch('athenak'))
+        radio_layout.addWidget(rbtn)
+        rbtn = qw.QRadioButton('AthenaC')
+        rbtn.toggled.connect(lambda: self.switch('athenac'))
+        radio_layout.addWidget(rbtn)
+
+        label = qw.QLabel('Athena Executable: [deprecating]')
+        exe_layout.addWidget(label)
+        label.setStyleSheet("font-weight: bold")
+        btn = qw.QPushButton(self)
+        btn.setText("browse")
+        def browse(t):
+            file = qw.QFileDialog.getOpenFileName(self, "Select File", "")[0]
+            t.setText(file)
+        self.exe = qw.QLineEdit(self)
+        btn.clicked.connect(lambda: browse(self.exe))
+        self.exe.setFixedWidth(250)
+        self.exe.setText('athenak/build/src/athena')
+        exe_layout.addStretch()
+        exe_layout.addWidget(btn)
+        exe_layout.addWidget(self.exe)
+
+        btn_group = qw.QButtonGroup()
+
+        self.load_radio = qw.QRadioButton('Load Problem:')
+        self.load_radio.setStyleSheet('font-weight: bold')
+        self.load_radio.setChecked(True)
+        load_layout.addWidget(self.load_radio)
+        load_layout.addStretch()
+        btn = qw.QPushButton(self)
+        btn.setText("browse")
+        self.problem = qw.QLineEdit(self)
+        btn.clicked.connect(lambda: browse(self.problem))
+        self.problem.setFixedWidth(250)
+        self.problem.setText('linear_wave_hydro.athinput')
+        load_layout.addWidget(btn)
+        load_layout.addWidget(self.problem)
+
+        self.predef_radio = qw.QRadioButton('Predefined Problem:')
+        self.predef_radio.setStyleSheet('font-weight: bold')
+        predef_layout.addWidget(self.predef_radio)
+        self.combo = qw.QComboBox()
+        self.combo.addItems(athena_problems)
+        predef_layout.addStretch()
+        predef_layout.addWidget(self.combo)
+
+        btn_group.addButton(self.load_radio)
+        btn_group.addButton(self.predef_radio)
+        self.radio_groups.append(btn_group)
+
+        page_layout.addLayout(radio_layout)
+        page_layout.addLayout(exe_layout)
+        page_layout.addLayout(load_layout)
+        page_layout.addLayout(predef_layout)
+        # checkbox
+
+        self.reconfig = qw.QCheckBox('Reconfigure Executable')
+        page_layout.addWidget(self.reconfig)
+
+        widget = qw.QWidget()
+        widget.setLayout(page_layout) 
+        scroll = qw.QScrollArea()    #add scrollbar
+        scroll.setWidgetResizable(True)
+        scroll.setWidget(widget)
+        self.resize(700, 300)
+        self.setCentralWidget(scroll)
+
+    def switch(self, type):
+        self.combo.clear()
+        if type == 'athena':
+            self.combo.addItems(athena_problems)
+            self.reconfig.setVisible(True)
+        elif type == 'athenak':
+            self.combo.addItems(athenak_problems)
+            self.reconfig.setVisible(False)
+        else:
+            self.combo.addItems(athenac_problems)
+            self.reconfig.setVisible(True)
+        self.current_athena = type
+
+    def rebuild(self, problem):
+        config = None
+        with open(problem) as file:
+            line = file.readline()
+            while line:
+                m = match('config[^=]+=(.+)', line)
+                if m:
+                    config = m.group(1)
+                    break
+                line = file.readline()
+        w = ConfigWindow(config)
+        w.show()
+        w.run()
+        w.close()
+
+    def launch(self):
+        problem = problems[self.current_athena][self.combo.currentText()] if self.predef_radio.isChecked() else self.problem.text()
+        cmd = './pyqt_run_minik.py %s -x %s %s %s' % (problem, 
+                                                      self.exe.text(),
+                                                      '-r' if args.run else '',
+                                                      '--tk' if args.tk else '') 
+        print(cmd)
+        try:
+            if self.reconfig.isChecked():
+                if self.current_athena == 'athenac':
+                    raise Exception('Athena C reconfigure not yet implemented')
+                # otherwise it is athena++
+                print(problem)
+                self.rebuild(problem)
+            if not path.exists(problem):
+                raise FileNotFoundError
+            Popen(cmd.split())
+        except Exception as e:
+            print(e)
+
+    def help(self):
+        w = HelpWindow()
+        self.windows.append(w)
+        w.show()
+
+    def quit(self):
+        self.close()
+
+class ConfigWindow(qw.QWidget):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.setWindowTitle('Rebuilding Executable')
+        self.main_layout = qw.QVBoxLayout()
+        bash_label = qw.QLabel('./reconfig.sh ' + self.config)
+        bash_label.setStyleSheet('font-weight: bold')
+        bash_label.setFont(qg.QFont('Courier New', 10))
+        self.main_layout.addWidget(bash_label)
+        self.txt = qw.QLabel()
+        self.txt.setFont(qg.QFont('Courier New', 10))
+        self.main_layout.addWidget(self.txt)
+        self.setLayout(self.main_layout)
+
+    def run(self):
+        p = Popen(['./reconfig.sh', self.config], stdout=PIPE)
+        line = p.stdout.readline()
+        while line:
+            self.txt.setText(line.decode())
+            qg.QGuiApplication.processEvents()
+            line = p.stdout.readline()
+
+class HelpWindow(qw.QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle('Help')
+        self.main_layout = qw.QVBoxLayout()
+        self.add_label('Athena Version:', '\tThe version of Athena (must match the version of the executable) to be used')
+        self.add_label('Athena Executable:', '\tEither the path or the name of the Athena executable. If only a name is given, then it is assumed that the executable is in /usr/bin.')
+        self.add_label('Selecting Problems:', '\tA problem can either be selected from the list of predefined problems or a custom problem can be chosen. Use the radio buttons to choose which method to use.')
+        self.setLayout(self.main_layout)
+
+    def add_label(self, s1, s2):
+        txt = qw.QLabel(s1)
+        txt.setStyleSheet('font-weight: bold')
+        self.main_layout.addWidget(txt)
+        self.main_layout.addWidget(qw.QLabel(s2))
+
+
+app = qw.QApplication(argv)
+
+main = MainWindow()
+main.show()
+
+try:
+    #print('opening window')
+    exit(app.exec())
+except:
+    #print('closing window')
+    pass
diff --git a/pyqt_run.py b/pyqt_run.py
new file mode 100755
index 0000000..8b2ccf4
--- /dev/null
+++ b/pyqt_run.py
@@ -0,0 +1,672 @@
+#! /usr/bin/env python
+from PyQt5 import QtCore as qc, QtWidgets as qw, QtGui as qg
+
+# utility imports
+from re import match
+from aparser import parse_s as parse
+from argparse import ArgumentParser
+from os import getcwd, remove, environ, path
+from subprocess import Popen, PIPE
+from glob import glob
+from sys import argv, exit
+
+class MainWindow(qw.QMainWindow):
+
+    def __init__(self, data, info):
+        super(MainWindow, self).__init__()
+
+        self.windows = []
+
+        self.data = data
+        self.info = info
+        self.radio_groups = []
+        self.sliders = {}
+        self.input={}
+
+        self.forced_slider = False
+
+        self.initUI()
+
+    # removes the trailing zeroes then the dot from a string float x, then returns an int
+    # utility function used by build_layout
+    def rm_dot(self, x):
+        # being too precise causes problems, but hopefully this is enough
+        s = '%.8g' % float(x)
+        dot_pos = s.rfind('.')
+        if dot_pos < 0:
+            return int(s)
+        s = s.replace('.', '')
+        return int(s)
+
+    def initUI(self):
+        self.pagelayout = qw.QVBoxLayout()       #page layout
+        self.dbtnlayout = qw.QHBoxLayout()       #layout for the default buttons
+        self.elmtlayout = qw.QVBoxLayout()   #layout for the added widgets, stacks elements
+        
+        self.problayout = qw.QHBoxLayout()
+        self.reflayout = qw.QHBoxLayout()
+        self.outdirlayout = qw.QHBoxLayout()
+
+        #run, save, load, quit, help buttons -> located in a toolbar
+        toolbar = self.addToolBar("ToolBar")
+
+        run_action = qw.QAction('Output', self)
+        run_action.setToolTip('Output the command the would be ran when plotted')
+
+        plot_action = qw.QAction('Plot', self)
+        plot_action.setToolTip('Plot the output of the command ran under these configurations')
+
+        edit_action = qw.QAction('Edit', self)
+        edit_action.setToolTip('Open the input file for editing')
+
+        help_action = qw.QAction('Help', self)
+        help_action.setToolTip('Display details about each configuration field')
+
+        reset_action = qw.QAction('Reset', self)
+        reset_action.setToolTip('Revert configuration options to default settings')
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Exits the application')
+
+        toolbar.addAction(run_action)
+        toolbar.addSeparator()
+        toolbar.addAction(plot_action)
+        toolbar.addSeparator()
+        toolbar.addAction(edit_action)
+        toolbar.addSeparator()
+        toolbar.addAction(help_action)
+        toolbar.addSeparator()
+        toolbar.addAction(reset_action)
+        toolbar.addSeparator()
+        toolbar.addAction(quit_action)
+
+        #add layouts to the page
+        #self.pagelayout.addLayout(self.infolayout)
+        self.pagelayout.addLayout(self.elmtlayout)
+        #elf.pagelayout.addStretch()
+        #self.pagelayout.addLayout(self.dbtnlayout) 
+
+        # to set bold
+        # self.label.setStyleSheet("font-weight: bold")
+
+        l1 = qw.QLabel('Problem:')
+        l1.setStyleSheet("font-weight: bold")
+        l2 = qw.QLabel(info['problem'])
+        self.problayout.addWidget(l1)
+        self.problayout.addStretch()
+        self.problayout.addWidget(l2)
+
+        reference = info['reference']
+        l1 = qw.QLabel('Layout:')
+        l1.setStyleSheet("font-weight: bold")
+        if reference:
+            l2 = qw.QLabel(reference)
+        else:
+            l2 = qw.QLabel('N/A')
+        self.reflayout.addWidget(l1)
+        self.reflayout.addStretch()
+        self.reflayout.addWidget(l2)
+
+        l1 = qw.QLabel('Output Directory:')
+        l1.setStyleSheet("font-weight: bold")
+        l1.setToolTip('The directory where the output file will be dumped')
+        self.outdirlayout.addWidget(l1)
+        self.outdirlayout.addStretch()
+        btn = qw.QPushButton(self)
+        btn.setText("browse")
+        def browse_dir(t):
+            file = qw.QFileDialog.getExistingDirectory(self, "Select Directory", "")
+            t.setText(file)
+        txt = qw.QLineEdit(self)
+        btn.clicked.connect(lambda: browse_dir(txt))
+        txt.setFixedWidth(250)
+        txt.setText(cwd)
+        self.outdirlayout.addWidget(btn)
+        self.outdirlayout.addWidget(txt)
+
+        self.elmtlayout.addLayout(self.problayout)
+        self.elmtlayout.addLayout(self.reflayout)
+        self.elmtlayout.addLayout(self.outdirlayout)
+
+        run_action.triggered.connect(lambda: self.run(txt, False))
+        plot_action.triggered.connect(lambda: self.run(txt, True))
+        edit_action.triggered.connect(self.view)
+        help_action.triggered.connect(self.help)
+        reset_action.triggered.connect(self.reset)
+        quit_action.triggered.connect(self.quit)
+
+        #run, save, load, quit, help button
+        '''btn = qw.QPushButton(self)
+        btn.setText("Run")
+        btn.clicked.connect(lambda: self.run(txt, args.run))
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("View File")
+        btn.clicked.connect(self.view)
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("Help")
+        btn.clicked.connect(self.help)
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("Reset")
+        btn.clicked.connect(self.reset)
+        self.dbtnlayout.addWidget(btn)
+        
+        btn = qw.QPushButton(self)
+        btn.setText("Quit")
+        btn.clicked.connect(self.quit)
+        self.dbtnlayout.addWidget(btn)'''
+
+        #set the main page layout
+        widget = qw.QWidget()
+        widget.setLayout(self.pagelayout) 
+        scroll = qw.QScrollArea()    #add scrollbar
+        scroll.setWidgetResizable(True)
+        scroll.setWidget(widget)
+        self.setGeometry(500, 100, 700, 500)
+        self.setCentralWidget(scroll)
+
+        self.createWidgetsFromGroups()
+    
+    def run(self, odir_input, plot):
+        #print('run')
+        cmd = f'{athena} -i {args.file} -d {odir_input.text()} output2/file_type=tab '
+
+        for k in self.data:
+            e = data[k]
+            t = e['gtype']
+
+            if t == 'RADIO':
+                for r in self.input[k]:
+                    if r.isChecked():
+                        cmd += f'{k}={r.text()} '
+                        break
+            elif t == 'CHECK' and self.input[k]:
+                cmd += f'{k}='
+                for c in self.input[k]:
+                    if c.isChecked():
+                        cmd += f'{c.text()},'
+                cmd = cmd[:-1] + ' '
+            else:
+                cmd += '%s=%s ' % (k, self.input[k].text())
+
+        print(cmd)
+        if plot:
+            if not path.exists(athena):
+                print('Athena not found\nExiting')
+            # open the plot in a subprocess
+            # remove the forward slash at the end if there is one
+            odir = odir_input.text()
+            if odir[-1] == '/':
+                odir = odir[:-1]
+            # remove the hst file since it always gets appended to
+            # intentional?
+            h = glob(odir + '/*.hst')
+            if len(h) > 0:
+                remove(h[0])
+            # will the tlim variable always be like this?
+            # display_pbar(cmd, values['time/tlim'])
+            '''p = Popen(cmd.split())
+            p.wait()'''
+            w = LoadingWindow(cmd, float(self.input['time/tlim'].text()))
+            self.windows.append(w)
+            w.show()
+            w.run()
+            w.close()
+            Popen(['python', 'plot1d.py', '-d', odir, '-n', info['problem']])
+            Popen(['python', 'plot1d.py', '-d', odir, '--hst', '-n', info['problem'] + ' history'])
+        else:
+            w = DisplayWindow(cmd)
+            self.windows.append(w)
+            w.show()
+
+    def view(self):
+        #print('view')
+        w = ViewerWindow()
+        self.windows.append(w)
+        w.show()
+    
+    def reset(self):
+        for k in self.data:
+            e = data[k]
+            t = e['gtype']
+
+            if t == 'RADIO':
+                for r in self.input[k]:
+                    if r.text() == e['value']:
+                        r.setChecked(True)
+                        break
+            elif t == 'CHECK' and self.input[k]:
+                defaults = e['value'].split(',')
+                for c in self.input[k]:
+                    c.setChecked(c.text() in defaults)
+            elif t == 'SCALE':
+                self.input[k].setText(str(e['value']))
+                self.sliders[k]['key'].setValue(int(self.sliders[k]['factor'] * float(e['value'])))
+            else:
+                self.input[k].setText(str(e['value']))
+
+    def quit(self):
+        self.close()
+        #print('quit')
+
+    def help(self):
+        #print('help')
+        w = HelpWindow(self.data)
+        size = w.main_layout.sizeHint()
+        size.setWidth(size.width() + 10)
+        size.setHeight(size.height() + 10)
+        self.windows.append(w)
+        w.show()
+
+    def createWidgetsFromGroups(self):
+        plabel = qw.QLabel('Parameters:')
+        plabel.setStyleSheet("font-weight: bold")
+        self.elmtlayout.addWidget(plabel)
+        #self.elmtlayout.setSpacing(10)
+        for k in data:
+            e = data[k]
+            t = e['gtype']
+            tooltip = e['help'][1:].strip()
+            if t == 'RADIO':
+                new_group = qw.QButtonGroup()
+                self.radio_groups.append(new_group)
+                self.input[k] = []
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+
+                for option in e['gparams'].split(','):
+                    # option = option.strip()
+                    radio_button = qw.QRadioButton(option)
+                    self.input[k].append(radio_button)
+                    new_group.addButton(radio_button)
+                    group_layout.addWidget(radio_button)
+                    if option == e['value']:
+                        radio_button.setChecked(True)
+                self.elmtlayout.addLayout(group_layout)
+
+            elif t == "IFILE" or t == "OFILE":
+                #print("browse files button created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                btn = qw.QPushButton(self)
+                btn.setText("browse")
+                txt = qw.QLineEdit(self)
+                def browse_file(t):
+                    file = qw.QFileDialog.getOpenFileName(self, "Select File", "")[0]
+                    t.setText(file)
+                btn.clicked.connect(lambda _, t=txt: browse_file(t))
+                txt.setFixedWidth(250)
+                txt.setText(e['value'])
+                group_layout.addWidget(btn)
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = txt
+
+            elif t == "IDIR" or t == 'ODIR':
+                #print("browse directories button created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                btn = qw.QPushButton(self)
+                btn.setText("browse")
+                def browse_dir(t):
+                    file = qw.QFileDialog.getExistingDirectory(self, "Select Directory", "")
+                    t.setText(file)
+                txt = qw.QLineEdit(self)
+                btn.clicked.connect(lambda _, t=txt: browse_dir(t))
+                txt.setFixedWidth(250)
+                txt.setText(e['value'])
+                group_layout.addWidget(btn)
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = txt
+
+            elif t == "CHECK":
+                #print("checkbox created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                values = e['value'].split(',')
+                self.input[k] = []
+                for option in e['gparams'].split(','):
+                    #option = option.strip()
+                    checkbox = qw.QCheckBox(option, self)
+                    self.input[k].append(checkbox)
+                    group_layout.addWidget(checkbox)
+                    if option in values:
+                        checkbox.setChecked(True)
+                self.elmtlayout.addLayout(group_layout)
+
+            
+            elif t == "ENTRY":
+                #print("textbox created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                txt = qw.QLineEdit(self)
+                txt.setText(e['value'])
+                txt.setFixedWidth(250)
+                self.input[k] = txt
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+
+            elif t == "SCALE":
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                params = e['gparams'].split(':')
+
+                #print("slider created")
+                #creates a horizontal slider
+                init = float(e['value'])
+                label_slider = qw.QLineEdit(str(int(init) if init.is_integer() else init))
+                label_slider.textEdited.connect(lambda value, key=k: self.update_slider(value, key))
+                label_slider.setAlignment(qc.Qt.AlignRight)
+                label_slider.setFixedWidth(85)
+                # the label slider is unique to this slider
+                # so we will use it to identify the slider
+                factor = max([1 if float(x) == 0 else round(self.rm_dot(x) / float(x)) for x in params])
+                slider = qw.QSlider(self)
+                self.sliders[k] = {
+                    'key':slider,
+                    'factor':factor
+                    #'is_int':params[0].isdigit() and params[1].isdigit() and params[2].isdigit()
+                }
+                [minimum, maximum, increment] = [float(x) for x in params]
+                slider.setOrientation(qc.Qt.Horizontal)
+                slider.setSingleStep(int(factor * increment))
+                slider.setPageStep(int(factor * increment))       #moves the slider when clicking or up/down
+                slider.setRange(int(factor * minimum), int(factor * maximum))
+                slider.setValue(int(factor * init))
+
+                slider.valueChanged.connect(lambda value, key=k, lbl=label_slider: self.updateLabel(key, lbl, value))
+                
+                slider.setFixedWidth(250)
+
+                group_layout.addWidget(label_slider)
+                group_layout.addWidget(slider)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = label_slider
+
+    def update_slider(self, value, key):
+        try:
+            slider_info = self.sliders[key]
+            slider = slider_info['key']
+            minimum = slider.minimum()
+            maximum = slider.maximum()
+            fvalue = float(value) * slider_info['factor']
+            if minimum <= fvalue <= maximum:
+                self.forced_slider = True
+                slider.setValue(int(fvalue))
+        except:
+            pass
+
+    def updateLabel(self, key, label, value):
+        if self.forced_slider:
+            self.forced_slider = False
+        else:
+            slider_info = self.sliders[key]
+            scaled = value/slider_info['factor']
+            label.setText(str(int(scaled) if scaled.is_integer() else scaled))
+
+class LoadingWindow(qw.QMainWindow):
+    def __init__(self, cmd, tlim):
+        super().__init__()
+
+        self.setWindowTitle('Loading')
+        self.cmd = cmd
+        self.tlim = tlim
+        self.pbar = qw.QProgressBar(self)
+        self.setCentralWidget(self.pbar)
+
+    def run(self):
+        p = Popen(self.cmd.split(), stdout=PIPE)
+
+        line = p.stdout.readline()
+
+        while line:
+            m = match('.*cycle=.* time=(.*) dt=.*', line.decode())
+            if m:
+                i = int(100 * float(m.group(1)) / self.tlim)
+                self.pbar.setValue(i)
+                # print(i, self.pbar.value())
+                qg.QGuiApplication.processEvents()
+            line = p.stdout.readline()
+
+class ConfirmWindow(qw.QWidget):
+    def __init__(self, parent):
+        super().__init__()
+
+        self.setWindowTitle('Confirm')
+
+        self.par = parent
+
+        layout = qw.QVBoxLayout()
+        btn_layout = qw.QHBoxLayout()
+
+        text = qw.QLabel('WARNING: You are about to override ' + args.file)
+        layout.addWidget(text)
+
+        btn = qw.QPushButton()
+        btn.setText('Ok')
+        btn.clicked.connect(self.ok)
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Cancel')
+        btn.clicked.connect(self.cancel)
+        btn_layout.addWidget(btn)
+
+        layout.addLayout(btn_layout)
+
+        self.setLayout(layout)
+
+    def ok(self):
+        self.par.ok = True
+        self.close()
+
+    def cancel(self):
+        self.par.ok = False
+        self.close()
+
+class ViewerWindow(qw.QMainWindow):
+    def __init__(self):
+        super().__init__()
+        global lines
+        self.ok = False
+        self.windows = []
+        self.setWindowTitle(args.file)
+        self.resize(750, 750)
+
+        toolbar = self.addToolBar('ToolBar')
+
+        load_action = qw.QAction('Load', self)
+        load_action.setToolTip('Reload the GUI with this file')
+        load_action.triggered.connect(self.load)
+        toolbar.addAction(load_action)
+        toolbar.addSeparator()
+
+        save_as_action = qw.QAction('Save As', self)
+        save_as_action.setToolTip('Save as a new file (Ctrl+Shift+s)')
+        save_as_action.triggered.connect(self.save_as)
+        save_as_action.setShortcut('Ctrl+Shift+s')
+        toolbar.addAction(save_as_action)
+        toolbar.addSeparator()
+
+        save_action = qw.QAction('Save', self)
+        save_action.setToolTip('Save changes to the original input file (Ctrl+s)')
+        save_action.triggered.connect(self.save)
+        save_action.setShortcut('Ctrl+s')
+        toolbar.addAction(save_action)
+        toolbar.addSeparator()
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Closes the editor')
+        quit_action.triggered.connect(self.quit)
+        toolbar.addAction(quit_action)
+        toolbar.addSeparator()
+
+        layout = qw.QVBoxLayout()
+        self.box = qw.QPlainTextEdit(''.join(lines), self)
+        self.box.resize(750, 700)
+        self.box.setFont(qg.QFont('Courier New', 10))
+        layout.addWidget(self.box)
+
+        #set the main page layout
+        widget = qw.QWidget()
+        widget.setLayout(layout) 
+        # self.setGeometry(500, 100, 700, 500)
+        self.setCentralWidget(widget)
+
+        '''btn_layout = qw.QHBoxLayout()
+
+        btn = qw.QPushButton()
+        btn.setText('Load')
+        btn.clicked.connect(self.load)
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Save As')
+        btn.clicked.connect(self.save_as)
+        btn.setShortcut('Ctrl+Shift+s')
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Save')
+        btn.clicked.connect(self.save)
+        btn.setShortcut('Ctrl+s')
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        
+        btn.setText('Quit')
+        btn.clicked.connect(self.quit)
+        btn_layout.addWidget(btn)
+    
+        layout.addLayout(btn_layout)'''
+
+    def load(self):
+        global data, info, lines, main
+        lines = [line + '\n' for line in self.box.toPlainText().split('\n')]
+        data, info, _ = parse(lines, silent=True)
+        main.close()
+        build_main(data, info)
+        self.close()
+
+    def save_as(self):
+        filename, _ = qw.QFileDialog.getSaveFileName(self,
+                                       'Save File',
+                                       '',
+                                       'All Files(*);;Text Files(*.txt);;AthenaK Input(*.athinput);;Athena Input(athinput.*)')
+        if filename:
+            with open(filename, 'w') as file:
+                file.write(self.box.toPlainText())
+
+    def save(self):
+        w = ConfirmWindow(self)
+        self.windows.append(w)
+        w.setAttribute(qc.Qt.WA_DeleteOnClose)
+        w.setWindowModality(qc.Qt.ApplicationModal)
+        w.show()
+        loop = qc.QEventLoop()
+        w.destroyed.connect(loop.quit)
+        loop.exec()
+        if self.ok:
+            with open(args.file, 'w') as file:
+                file.write(self.box.toPlainText())
+
+    def quit(self):
+        self.close()
+
+class DisplayWindow(qw.QWidget):
+    def __init__(self, cmd):
+        super().__init__()
+        self.setWindowTitle('Athena Output')
+        self.resize(500, 200)
+        layout = qw.QVBoxLayout()
+        line = qw.QPlainTextEdit(cmd, self)
+        line.setFont(qg.QFont('Courier New', 10))
+        layout.addWidget(line)
+        self.setLayout(layout)
+
+class HelpWindow(qw.QWidget):
+    def __init__(self, data):
+        super().__init__()
+        self.setWindowTitle('Help')
+        self.main_layout = qw.QVBoxLayout()
+        for k in data:
+            sublayout = qw.QHBoxLayout()
+            l1 = qw.QLabel(k + ': ')
+            l1.setStyleSheet("font-weight: bold")
+            l2 = qw.QLabel(data[k]['help'][1:].strip())
+            sublayout.addWidget(l1)
+            sublayout.addWidget(l2)
+            sublayout.addStretch()
+            self.main_layout.addLayout(sublayout)
+        self.setLayout(self.main_layout)
+
+# building the gui
+
+def build_main(data, info):
+    global main
+    main = MainWindow(data, info)
+
+    # additions to the hint are needed to prevent the scrollbar from showing up
+    size = main.pagelayout.sizeHint()
+    size.setWidth(size.width() + 100)
+    size.setHeight(size.height() + 50)
+
+    main.resize(size)
+    main.show()
+
+cwd = getcwd()
+
+# parse arguments
+argparser = ArgumentParser(description='Runs the GUI for configuring an athinput file')
+'''argparser.add_argument('-r', '--run',
+                       action='store_true',
+                       help='executes the athena command and plots the tab files on run',
+                       default=False)'''
+argparser.add_argument('-x', '--exe', help='the path to the athena executable')
+argparser.add_argument('file', help='the athinput file to configure')
+args = argparser.parse_args()
+
+athena = args.exe if args.exe else (environ['AGUI'] if 'AGUI' in environ else cwd) + '/athena/bin/athena'
+
+# parse the input files
+with open(args.file) as file:
+    lines = file.readlines()
+
+data, info, _ = parse(lines, silent=True)
+
+app = qw.QApplication(argv)
+
+main = None
+
+build_main(data, info)
+
+try:
+    #print('opening window')
+    exit(app.exec())
+except:
+    #print('closing window')
+    pass
\ No newline at end of file
diff --git a/pyqt_run_minik.py b/pyqt_run_minik.py
new file mode 100755
index 0000000..99adcf1
--- /dev/null
+++ b/pyqt_run_minik.py
@@ -0,0 +1,681 @@
+#! /usr/bin/env python
+from PyQt5 import QtCore as qc, QtWidgets as qw, QtGui as qg
+
+# utility imports
+from re import match
+from aparser import parse_s as parse
+from argparse import ArgumentParser
+from os import getcwd, remove, environ, path
+from subprocess import Popen, PIPE
+from glob import glob
+from sys import argv, exit
+
+class MainWindow(qw.QMainWindow):
+
+    def __init__(self, data, info):
+        super(MainWindow, self).__init__()
+
+        self.windows = []
+
+        self.data = data
+        self.info = info
+        self.radio_groups = []
+        self.sliders = {}
+        self.input={}
+
+        self.forced_slider = False
+
+        self.initUI()
+
+    # removes the trailing zeroes then the dot from a string float x, then returns an int
+    # utility function used by build_layout
+    def rm_dot(self, x):
+        # being too precise causes problems, but hopefully this is enough
+        s = '%.8g' % float(x)
+        dot_pos = s.rfind('.')
+        if dot_pos < 0:
+            return int(s)
+        s = s.replace('.', '')
+        return int(s)
+
+    def initUI(self):
+        self.pagelayout = qw.QVBoxLayout()       # page layout
+        self.dbtnlayout = qw.QHBoxLayout()       # layout for the default buttons
+        self.elmtlayout = qw.QVBoxLayout()       # layout for the added widgets, stacks elements
+        
+        self.problayout = qw.QHBoxLayout()
+        self.reflayout = qw.QHBoxLayout()
+        self.outdirlayout = qw.QHBoxLayout()
+
+        # run, save, load, quit, help buttons -> located in a toolbar
+        toolbar = self.addToolBar("ToolBar")
+
+        plot_action = qw.QAction('Run', self)
+        plot_action.setToolTip('Run minik and Plot the output of the command ran under these configurations')
+
+        run_action = qw.QAction('Dryrun', self)
+        run_action.setToolTip('Output the command the would be ran when run')
+
+        edit_action = qw.QAction('Edit', self)
+        edit_action.setToolTip('Open the input file for editing')
+
+        help_action = qw.QAction('Help', self)
+        help_action.setToolTip('Display details about each configuration field')
+
+        reset_action = qw.QAction('Reset', self)
+        reset_action.setToolTip('Revert configuration options to default settings')
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Exits the application')
+
+
+        toolbar.addAction(plot_action)
+        toolbar.addSeparator()
+        toolbar.addAction(run_action)        
+        toolbar.addSeparator()
+        toolbar.addAction(edit_action)
+        toolbar.addSeparator()
+        toolbar.addAction(help_action)
+        toolbar.addSeparator()
+        toolbar.addAction(reset_action)
+        toolbar.addSeparator()
+        toolbar.addAction(quit_action)
+
+        #add layouts to the page
+        #self.pagelayout.addLayout(self.infolayout)
+        self.pagelayout.addLayout(self.elmtlayout)
+        #elf.pagelayout.addStretch()
+        #self.pagelayout.addLayout(self.dbtnlayout) 
+
+        # to set bold
+        # self.label.setStyleSheet("font-weight: bold")
+
+        l1 = qw.QLabel('Problem:')
+        l1.setStyleSheet("font-weight: bold")
+        l2 = qw.QLabel(info['problem'])
+        self.problayout.addWidget(l1)
+        self.problayout.addStretch()
+        self.problayout.addWidget(l2)
+
+        reference = info['reference']
+        l1 = qw.QLabel('Layout:')
+        l1.setStyleSheet("font-weight: bold")
+        if reference:
+            l2 = qw.QLabel(reference)
+        else:
+            l2 = qw.QLabel('N/A')
+        self.reflayout.addWidget(l1)
+        self.reflayout.addStretch()
+        self.reflayout.addWidget(l2)
+
+        l1 = qw.QLabel('Output Directory:')
+        l1.setStyleSheet("font-weight: bold")
+        l1.setToolTip('The directory where the output file will be dumped')
+        self.outdirlayout.addWidget(l1)
+        self.outdirlayout.addStretch()
+        btn = qw.QPushButton(self)
+        btn.setText("browse")
+        def browse_dir(t):
+            file = qw.QFileDialog.getExistingDirectory(self, "Select Directory", "")
+            t.setText(file)
+        txt = qw.QLineEdit(self)
+        btn.clicked.connect(lambda: browse_dir(txt))
+        txt.setFixedWidth(250)
+        txt.setText(cwd)
+        self.outdirlayout.addWidget(btn)
+        self.outdirlayout.addWidget(txt)
+
+        self.elmtlayout.addLayout(self.problayout)
+        self.elmtlayout.addLayout(self.reflayout)
+        self.elmtlayout.addLayout(self.outdirlayout)
+
+        run_action.triggered.connect(lambda: self.run(txt, False))
+        plot_action.triggered.connect(lambda: self.run(txt, True))
+        edit_action.triggered.connect(self.view)
+        help_action.triggered.connect(self.help)
+        reset_action.triggered.connect(self.reset)
+        quit_action.triggered.connect(self.quit)
+
+        #run, save, load, quit, help button
+        '''btn = qw.QPushButton(self)
+        btn.setText("Run")
+        btn.clicked.connect(lambda: self.run(txt, args.run))
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("View File")
+        btn.clicked.connect(self.view)
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("Help")
+        btn.clicked.connect(self.help)
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("Reset")
+        btn.clicked.connect(self.reset)
+        self.dbtnlayout.addWidget(btn)
+        
+        btn = qw.QPushButton(self)
+        btn.setText("Quit")
+        btn.clicked.connect(self.quit)
+        self.dbtnlayout.addWidget(btn)'''
+
+        #set the main page layout
+        widget = qw.QWidget()
+        widget.setLayout(self.pagelayout) 
+        scroll = qw.QScrollArea()    #add scrollbar
+        scroll.setWidgetResizable(True)
+        scroll.setWidget(widget)
+        self.setGeometry(500, 100, 700, 500)
+        self.setCentralWidget(scroll)
+
+        self.createWidgetsFromGroups()
+    
+    def run(self, odir_input, plot):
+        #print('run')
+        #cmd = f'{athena} -i {args.file} -d {odir_input.text()} output2/file_type=tab '
+        cmd = f'{athena} -i {args.file} -d {odir_input.text()} '
+
+        for k in self.data:
+            e = data[k]
+            t = e['gtype']
+
+            if t == 'RADIO':
+                for r in self.input[k]:
+                    if r.isChecked():
+                        cmd += f'{k}={r.text()} '
+                        break
+            elif t == 'CHECK' and self.input[k]:
+                cmd += f'{k}='
+                for c in self.input[k]:
+                    if c.isChecked():
+                        cmd += f'{c.text()},'
+                cmd = cmd[:-1] + ' '
+            else:
+                cmd += '%s=%s ' % (k, self.input[k].text())
+
+        print(cmd)
+        if plot:
+            if not path.exists(athena):
+                print('Athena not found\nExiting')
+            # open the plot in a subprocess
+            # remove the forward slash at the end if there is one
+            odir = odir_input.text()
+            if odir[-1] == '/':
+                odir = odir[:-1]
+            # remove the hst file since it always gets appended to
+            # intentional?
+            h = glob(odir + '/*.hst')
+            if len(h) > 0:
+                remove(h[0])
+            # will the tlim variable always be like this?
+            # display_pbar(cmd, values['time/tlim'])
+            '''p = Popen(cmd.split())
+            p.wait()'''
+            w = LoadingWindow(cmd, float(self.input['time/tlim'].text()))
+            self.windows.append(w)
+            w.show()
+            w.run()
+            w.close()
+            # @todo     only if tab files, fix for tab/vtk
+            #Popen(['python', 'plot1d.py', '-d', odir+'/tab',           '-n', info['problem']])
+            #Popen(['python', 'plot1d.py', '-d', odir,         '--hst', '-n', info['problem'] + ' history'])
+            cmd1 = 'python plot1d.py  -d %s/tab' % (odir)
+            cmd2 = 'python plot1d.py  -d %s --hst' % (odir)
+            print(cmd1)
+            print(cmd2)
+            Popen(cmd1.split())
+            Popen(cmd2.split())
+        else:
+            w = DisplayWindow(cmd)
+            self.windows.append(w)
+            w.show()
+
+    def view(self):
+        #print('view')
+        w = ViewerWindow()
+        self.windows.append(w)
+        w.show()
+    
+    def reset(self):
+        for k in self.data:
+            e = data[k]
+            t = e['gtype']
+
+            if t == 'RADIO':
+                for r in self.input[k]:
+                    if r.text() == e['value']:
+                        r.setChecked(True)
+                        break
+            elif t == 'CHECK' and self.input[k]:
+                defaults = e['value'].split(',')
+                for c in self.input[k]:
+                    c.setChecked(c.text() in defaults)
+            elif t == 'SCALE':
+                self.input[k].setText(str(e['value']))
+                self.sliders[k]['key'].setValue(int(self.sliders[k]['factor'] * float(e['value'])))
+            else:
+                self.input[k].setText(str(e['value']))
+
+    def quit(self):
+        self.close()
+        #print('quit')
+
+    def help(self):
+        #print('help')
+        w = HelpWindow(self.data)
+        size = w.main_layout.sizeHint()
+        size.setWidth(size.width() + 10)
+        size.setHeight(size.height() + 10)
+        self.windows.append(w)
+        w.show()
+
+    def createWidgetsFromGroups(self):
+        plabel = qw.QLabel('Parameters:')
+        plabel.setStyleSheet("font-weight: bold")
+        self.elmtlayout.addWidget(plabel)
+        #self.elmtlayout.setSpacing(10)
+        for k in data:
+            e = data[k]
+            t = e['gtype']
+            tooltip = e['help'][1:].strip()
+            if t == 'RADIO':
+                new_group = qw.QButtonGroup()
+                self.radio_groups.append(new_group)
+                self.input[k] = []
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+
+                for option in e['gparams'].split(','):
+                    # option = option.strip()
+                    radio_button = qw.QRadioButton(option)
+                    self.input[k].append(radio_button)
+                    new_group.addButton(radio_button)
+                    group_layout.addWidget(radio_button)
+                    if option == e['value']:
+                        radio_button.setChecked(True)
+                self.elmtlayout.addLayout(group_layout)
+
+            elif t == "IFILE" or t == "OFILE":
+                #print("browse files button created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                btn = qw.QPushButton(self)
+                btn.setText("browse")
+                txt = qw.QLineEdit(self)
+                def browse_file(t):
+                    file = qw.QFileDialog.getOpenFileName(self, "Select File", "")[0]
+                    t.setText(file)
+                btn.clicked.connect(lambda _, t=txt: browse_file(t))
+                txt.setFixedWidth(250)
+                txt.setText(e['value'])
+                group_layout.addWidget(btn)
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = txt
+
+            elif t == "IDIR" or t == 'ODIR':
+                #print("browse directories button created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                btn = qw.QPushButton(self)
+                btn.setText("browse")
+                def browse_dir(t):
+                    file = qw.QFileDialog.getExistingDirectory(self, "Select Directory", "")
+                    t.setText(file)
+                txt = qw.QLineEdit(self)
+                btn.clicked.connect(lambda _, t=txt: browse_dir(t))
+                txt.setFixedWidth(250)
+                txt.setText(e['value'])
+                group_layout.addWidget(btn)
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = txt
+
+            elif t == "CHECK":
+                #print("checkbox created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                values = e['value'].split(',')
+                self.input[k] = []
+                for option in e['gparams'].split(','):
+                    #option = option.strip()
+                    checkbox = qw.QCheckBox(option, self)
+                    self.input[k].append(checkbox)
+                    group_layout.addWidget(checkbox)
+                    if option in values:
+                        checkbox.setChecked(True)
+                self.elmtlayout.addLayout(group_layout)
+
+            
+            elif t == "ENTRY":
+                #print("textbox created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                txt = qw.QLineEdit(self)
+                txt.setText(e['value'])
+                txt.setFixedWidth(250)
+                self.input[k] = txt
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+
+            elif t == "SCALE":
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                params = e['gparams'].split(':')
+
+                #print("slider created")
+                #creates a horizontal slider
+                init = float(e['value'])
+                label_slider = qw.QLineEdit(str(int(init) if init.is_integer() else init))
+                label_slider.textEdited.connect(lambda value, key=k: self.update_slider(value, key))
+                label_slider.setAlignment(qc.Qt.AlignRight)
+                label_slider.setFixedWidth(85)
+                # the label slider is unique to this slider
+                # so we will use it to identify the slider
+                factor = max([1 if float(x) == 0 else round(self.rm_dot(x) / float(x)) for x in params])
+                slider = qw.QSlider(self)
+                self.sliders[k] = {
+                    'key':slider,
+                    'factor':factor
+                    #'is_int':params[0].isdigit() and params[1].isdigit() and params[2].isdigit()
+                }
+                [minimum, maximum, increment] = [float(x) for x in params]
+                slider.setOrientation(qc.Qt.Horizontal)
+                slider.setSingleStep(int(factor * increment))
+                slider.setPageStep(int(factor * increment))       #moves the slider when clicking or up/down
+                slider.setRange(int(factor * minimum), int(factor * maximum))
+                slider.setValue(int(factor * init))
+
+                slider.valueChanged.connect(lambda value, key=k, lbl=label_slider: self.updateLabel(key, lbl, value))
+                
+                slider.setFixedWidth(250)
+
+                group_layout.addWidget(label_slider)
+                group_layout.addWidget(slider)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = label_slider
+
+    def update_slider(self, value, key):
+        try:
+            slider_info = self.sliders[key]
+            slider = slider_info['key']
+            minimum = slider.minimum()
+            maximum = slider.maximum()
+            fvalue = float(value) * slider_info['factor']
+            if minimum <= fvalue <= maximum:
+                self.forced_slider = True
+                slider.setValue(int(fvalue))
+        except:
+            pass
+
+    def updateLabel(self, key, label, value):
+        if self.forced_slider:
+            self.forced_slider = False
+        else:
+            slider_info = self.sliders[key]
+            scaled = value/slider_info['factor']
+            label.setText(str(int(scaled) if scaled.is_integer() else scaled))
+
+class LoadingWindow(qw.QMainWindow):
+    def __init__(self, cmd, tlim):
+        super().__init__()
+
+        self.setWindowTitle('Loading')
+        self.cmd = cmd
+        self.tlim = tlim
+        self.pbar = qw.QProgressBar(self)
+        self.setCentralWidget(self.pbar)
+
+    def run(self):
+        p = Popen(self.cmd.split(), stdout=PIPE)
+
+        line = p.stdout.readline()
+
+        while line:
+            m = match('.*cycle=.* time=(.*) dt=.*', line.decode())
+            if m:
+                i = int(100 * float(m.group(1)) / self.tlim)
+                self.pbar.setValue(i)
+                # print(i, self.pbar.value())
+                qg.QGuiApplication.processEvents()
+            line = p.stdout.readline()
+
+class ConfirmWindow(qw.QWidget):
+    def __init__(self, parent):
+        super().__init__()
+
+        self.setWindowTitle('Confirm')
+
+        self.par = parent
+
+        layout = qw.QVBoxLayout()
+        btn_layout = qw.QHBoxLayout()
+
+        text = qw.QLabel('WARNING: You are about to override ' + args.file)
+        layout.addWidget(text)
+
+        btn = qw.QPushButton()
+        btn.setText('Ok')
+        btn.clicked.connect(self.ok)
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Cancel')
+        btn.clicked.connect(self.cancel)
+        btn_layout.addWidget(btn)
+
+        layout.addLayout(btn_layout)
+
+        self.setLayout(layout)
+
+    def ok(self):
+        self.par.ok = True
+        self.close()
+
+    def cancel(self):
+        self.par.ok = False
+        self.close()
+
+class ViewerWindow(qw.QMainWindow):
+    def __init__(self):
+        super().__init__()
+        global lines
+        self.ok = False
+        self.windows = []
+        self.setWindowTitle(args.file)
+        self.resize(750, 750)
+
+        toolbar = self.addToolBar('ToolBar')
+
+        load_action = qw.QAction('Load', self)
+        load_action.setToolTip('Reload the GUI with this file')
+        load_action.triggered.connect(self.load)
+        toolbar.addAction(load_action)
+        toolbar.addSeparator()
+
+        save_as_action = qw.QAction('Save As', self)
+        save_as_action.setToolTip('Save as a new file (Ctrl+Shift+s)')
+        save_as_action.triggered.connect(self.save_as)
+        save_as_action.setShortcut('Ctrl+Shift+s')
+        toolbar.addAction(save_as_action)
+        toolbar.addSeparator()
+
+        save_action = qw.QAction('Save', self)
+        save_action.setToolTip('Save changes to the original input file (Ctrl+s)')
+        save_action.triggered.connect(self.save)
+        save_action.setShortcut('Ctrl+s')
+        toolbar.addAction(save_action)
+        toolbar.addSeparator()
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Closes the editor')
+        quit_action.triggered.connect(self.quit)
+        toolbar.addAction(quit_action)
+        toolbar.addSeparator()
+
+        layout = qw.QVBoxLayout()
+        self.box = qw.QPlainTextEdit(''.join(lines), self)
+        self.box.resize(750, 700)
+        self.box.setFont(qg.QFont('Courier New', 10))
+        layout.addWidget(self.box)
+
+        #set the main page layout
+        widget = qw.QWidget()
+        widget.setLayout(layout) 
+        # self.setGeometry(500, 100, 700, 500)
+        self.setCentralWidget(widget)
+
+        '''btn_layout = qw.QHBoxLayout()
+
+        btn = qw.QPushButton()
+        btn.setText('Load')
+        btn.clicked.connect(self.load)
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Save As')
+        btn.clicked.connect(self.save_as)
+        btn.setShortcut('Ctrl+Shift+s')
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Save')
+        btn.clicked.connect(self.save)
+        btn.setShortcut('Ctrl+s')
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        
+        btn.setText('Quit')
+        btn.clicked.connect(self.quit)
+        btn_layout.addWidget(btn)
+    
+        layout.addLayout(btn_layout)'''
+
+    def load(self):
+        global data, info, lines, main
+        lines = [line + '\n' for line in self.box.toPlainText().split('\n')]
+        data, info, _ = parse(lines, silent=True)
+        main.close()
+        build_main(data, info)
+        self.close()
+
+    def save_as(self):
+        filename, _ = qw.QFileDialog.getSaveFileName(self,
+                                       'Save File',
+                                       '',
+                                       'All Files(*);;Text Files(*.txt);;AthenaK Input(*.athinput);;Athena Input(athinput.*)')
+        if filename:
+            with open(filename, 'w') as file:
+                file.write(self.box.toPlainText())
+
+    def save(self):
+        w = ConfirmWindow(self)
+        self.windows.append(w)
+        w.setAttribute(qc.Qt.WA_DeleteOnClose)
+        w.setWindowModality(qc.Qt.ApplicationModal)
+        w.show()
+        loop = qc.QEventLoop()
+        w.destroyed.connect(loop.quit)
+        loop.exec()
+        if self.ok:
+            with open(args.file, 'w') as file:
+                file.write(self.box.toPlainText())
+
+    def quit(self):
+        self.close()
+
+class DisplayWindow(qw.QWidget):
+    def __init__(self, cmd):
+        super().__init__()
+        self.setWindowTitle('Athena Output')
+        self.resize(500, 200)
+        layout = qw.QVBoxLayout()
+        line = qw.QPlainTextEdit(cmd, self)
+        line.setFont(qg.QFont('Courier New', 10))
+        layout.addWidget(line)
+        self.setLayout(layout)
+
+class HelpWindow(qw.QWidget):
+    def __init__(self, data):
+        super().__init__()
+        self.setWindowTitle('Help')
+        self.main_layout = qw.QVBoxLayout()
+        for k in data:
+            sublayout = qw.QHBoxLayout()
+            l1 = qw.QLabel(k + ': ')
+            l1.setStyleSheet("font-weight: bold")
+            l2 = qw.QLabel(data[k]['help'][1:].strip())
+            sublayout.addWidget(l1)
+            sublayout.addWidget(l2)
+            sublayout.addStretch()
+            self.main_layout.addLayout(sublayout)
+        self.setLayout(self.main_layout)
+
+# building the gui
+
+def build_main(data, info):
+    global main
+    main = MainWindow(data, info)
+
+    # additions to the hint are needed to prevent the scrollbar from showing up
+    size = main.pagelayout.sizeHint()
+    size.setWidth(size.width() + 100)
+    size.setHeight(size.height() + 50)
+
+    main.resize(size)
+    main.show()
+
+cwd = getcwd()
+
+# parse arguments
+argparser = ArgumentParser(description='Runs the GUI for configuring an athinput file')
+'''argparser.add_argument('-r', '--run',
+                       action='store_true',
+                       help='executes the athena command and plots the tab files on run',
+                       default=False)'''
+argparser.add_argument('-x', '--exe', help='the path to the athena executable')
+argparser.add_argument('file', help='the athinput file to configure')
+args = argparser.parse_args()
+
+athena = args.exe if args.exe else (environ['AGUI'] if 'AGUI' in environ else cwd) + '/athena/bin/athena'
+
+# parse the input files
+with open(args.file) as file:
+    lines = file.readlines()
+
+data, info, _ = parse(lines, silent=True)
+
+app = qw.QApplication(argv)
+
+main = None
+
+build_main(data, info)
+
+try:
+    #print('opening window')
+    exit(app.exec())
+except:
+    #print('closing window')
+    pass
diff --git a/pysg_menu.py b/pysg_menu.py
old mode 100644
new mode 100755
index 8a81288..ed58334
--- a/pysg_menu.py
+++ b/pysg_menu.py
@@ -1,50 +1,190 @@
-import PySimpleGUI as sg
-
-problems = [['Linear wave propagation', 1],
-            ['Riemann problems', 1],
-            ['Rayleigh–Taylor instability', 1],
-            ['Kelvin–Helmholtz instability', 1]]
-
-def new_problem_tab():
-    global problems
-    # find which of the problems was selected
-    for p in problems:
-        if values[p[0]] == True:
+#! /usr/bin/env python
+from argparse import ArgumentParser
+from importlib import import_module
+from json import load
+from subprocess import Popen, PIPE
+from re import match
+from os import path
+
+# parse arguments
+argparser = ArgumentParser(description='Runs the GUI for configuring an athinput file')
+argparser.add_argument('--tk', 
+                       action='store_true', 
+                       help='uses PYSimpleGUI (tkinter) instead of PySimpleGUIQt', 
+                       default=False)
+argparser.add_argument('-r', '--run',
+                       action='store_true',
+                       help='executes the athena command and plots the tab files on run',
+                       default=False)
+args = argparser.parse_args()
+
+# import a version of PySimpleGUI
+# if the selected one doesn't work, try the other
+primary = 'PySimpleGUIQt'
+backup = 'PySimpleGUI'
+
+fstd_bold = ('Helvetica', 10, 'bold')
+
+using_tk = args.tk
+
+if using_tk:
+    primary = 'PySimpleGUI'
+    backup = 'PySimpleGUIQt'
+
+try:
+    sg = import_module(primary)
+except:
+    print(f'Falied to import {primary}. Falling back to {backup}')
+    using_tk = not using_tk
+    sg = import_module(backup)
+
+# builds and displays a new window containing the help information
+def display_help():
+    layout = [
+        [ 
+            sg.Text('Athena Version:', font=fstd_bold)
+        ],
+        [
+            sg.Text('\tThe version of Athena (must match the version of the executable) to be used.')
+        ],
+        [
+            sg.Text('Athena Executable:', font=fstd_bold)
+        ],
+        [
+            sg.Text('\tEither the path or the name of the Athena executable. \
+if only a name is given, then it is assumed that the executable is in /usr/bin.')
+        ],
+        [
+            sg.Text('Selecting Problems:', font=fstd_bold)
+        ],
+        [
+            sg.Text('\tA problem can either be selected from the list of predefined problems \
+or a custom problem can be chosen. Use the radio buttons to choose which method to use.')
+        ]
+    ]
+    window = sg.Window('Help', layout)
+    while True:
+        event, _ = window.read()
+        if event == sg.WIN_CLOSED:
             break
-    tab_id = f'{p[0]} {p[1]}'
-    new_tab = sg.Tab(tab_id, [[sg.Text(f'This is a problem tab for {tab_id}')]], key=tab_id)
-    # prase, fill the tab, etc, here
-    window['tabs'].add_tab(new_tab)
-    # auto-select new tab
-    p[1] += 1
-    window[tab_id].select()
-
-# returns the main tab
-def mainTab():
-    elements = [[sg.Text('Choose a problem to run:')]]
-    for p in problems:
-        elements.append([sg.Radio(p[0], 'problems', key=p[0])])
-    elements.append([sg.Button('Configure')])
-    return sg.Tab('Choose Problem', elements)
-
-# just for aesthetics
-sg.theme('DarkBlue13')
-
-# format is as follows:
-# [[row1Stuff, moreRow1Stuff], [row2Stuff, moreRow2Stuff], [row3Stuff, ,preRow3Stuff]]
-layout = [[
-    sg.TabGroup([[mainTab()]], key='tabs', size=(500, 500)) # everything happens in this tab group
-]]
+    window.close()
 
-# create the main window
-window = sg.Window('pysg test', layout, size=(500, 500))
+# currently only designed to check athena++ executables
+def get_config(path):
+    with open(path) as file:
+        line = file.readline()
+        while line:
+            m = match('config[^=]+=(.+)', line)
+            if m:
+                return m.group(1)
+            line = file.readline()
+    return None
 
+def rebuild(problem):
+    config = get_config(problem)
+    window = sg.Window('Rebuilding Executable',
+                       [[sg.Text('./reconfig.sh ' + config)], [sg.Text(key='out')]])
+    p = Popen(['./reconfig.sh', config], stdout=PIPE)
+    line = p.stdout.readline()
+    while True:
+        event, _ = window.Read(timeout=10)
+        window['out'].update(value=line.decode())
+        line = p.stdout.readline()
+        if event == sg.WIN_CLOSED or not line:
+            p.kill()
+            break
+    window.close()
+    if line:
+        print('rebuild interrupted')
+    else:
+        print('rebuild complete')
+
+# building gui
+with open('athena_problems.json') as problems_json:
+    problems = load(problems_json)
+
+athena_problems = list(problems['athena'])
+athenac_problems = list(problems['athenac'])
+athenak_problems = list(problems['athenak'])
+
+current_athena = 'athena'
+
+sg.theme('Default1')
+
+layout = [
+    [
+        sg.Text('Athena Version:', font=fstd_bold),
+        sg.Stretch(), 
+        sg.Radio('Athena', 'versions', default=True, key='athena', enable_events=True), 
+        sg.Radio('AthenaK', 'versions', key='athenak', enable_events=True), 
+        sg.Radio('AthenaC', 'versions', key='athenac', enable_events=True)
+    ],
+    [
+        sg.Text('Athena Executable:', font=fstd_bold), 
+        sg.Stretch(), 
+        sg.Input(size=(17.5, 0.75) if not using_tk else (25, 1), default_text='./athena/bin/athena', key='exe'), 
+        sg.FileBrowse(size = (6, 1) if using_tk else (125, 25))
+    ],
+    [
+        sg.Radio('Load Problem:', 'origin', key='load_radio', font=fstd_bold, default=True),
+        sg.Stretch(),
+        sg.Input(size=(17.5, 0.75) if not using_tk else (25, 1), key='load', default_text='./athinput.linear_wave1d'),
+        sg.FileBrowse(size = (6, 1) if using_tk else (125, 25))
+    ],
+    [
+        sg.Radio('Predefined Problem:', 'origin', key='predefined_radio', font=fstd_bold),
+        sg.Stretch(), 
+        sg.Combo(list(problems['athena']), default_value='linear wave 1d (TEST)', size=(30, 0.75) if not using_tk else (35, 1), key='predefined_dropdown')
+    ],
+    [sg.Checkbox('Reconfigure Executable', key='rebuild')], # issue is, we would have to know where athena is
+    [sg.Text()], # buffer
+    [
+        sg.Button('Launch'), 
+        sg.Button('Quit'), 
+        sg.Button('Help')
+    ]
+]
+
+# create the main window
+window = sg.Window('pysg menu', layout)
 # primary event loop
 while True:
     event, values = window.read()
-    if event == 'Configure':
-        new_problem_tab()
-    if event == sg.WIN_CLOSED:
+    if event == sg.WIN_CLOSED or event == 'Quit':
         break
+    elif event == 'Launch':
+        problem = problems[current_athena][values['predefined_dropdown']] if values['predefined_radio'] else values['load']
+        cmd = './pysg_run.py %s -x %s %s %s' % (problem, 
+                                                        values['exe'],
+                                                        '-r' if args.run else '',
+                                                        '--tk' if args.tk else '') 
+        print(cmd)
+        try:
+            if values['rebuild']:
+                if current_athena == 'athenac':
+                    raise Exception('Athena C reconfigure not yet implemented')
+                # otherwise it is athena++
+                print(problem)
+                rebuild(problem)
+            if not path.exists(problem):
+                raise FileNotFoundError
+            Popen(cmd.split())
+        except Exception as e:
+            print(e)
+    elif event == 'Help':
+        print('help')
+        display_help()
+    elif event == 'athena':
+        window['rebuild'].update(visible=True)
+        current_athena = event
+        window['predefined_dropdown'].update(value=athena_problems[0], values=athena_problems)
+    elif event == 'athenac':
+        window['rebuild'].update(visible=True)
+        current_athena = event
+        window['predefined_dropdown'].update(value=athenac_problems[0], values=athenac_problems)
+    elif event == 'athenak':
+        window['rebuild'].update(visible=False)
+        current_athena = event
+        window['predefined_dropdown'].update(value=athenak_problems[0], values=athenak_problems)
 
 window.close()
\ No newline at end of file
diff --git a/pysg_run.py b/pysg_run.py
index 4439762..523559f 100755
--- a/pysg_run.py
+++ b/pysg_run.py
@@ -1,10 +1,11 @@
 #! /usr/bin/env python
 from re import match
-from aparser import parse_generic as parse
+from aparser import parse_s as parse
 from argparse import ArgumentParser
-from os import getcwd, mkdir, environ, path
+from os import getcwd, remove, mkdir, environ, path
 from subprocess import Popen, PIPE
 from importlib import import_module
+from glob import glob
 
 cwd = getcwd()
 
@@ -12,13 +13,10 @@
 fstd = ('Helvetica', 10)
 fstd_bold = ('Helvetica', 10, 'bold')
 
-# background colors used in the GUI
-bgstd = '#2a2e32'
-bgstd2 = '#23272b'
-
 sliders = {}
+checks = {}
 
-athena = (environ['AGUI'] if 'AGUI' in environ else cwd) + '/athena/bin/athena'
+plots = []
 
 # parse arguments
 argparser = ArgumentParser(description='Runs the GUI for configuring an athinput file')
@@ -31,14 +29,22 @@
                        help='executes the athena command and plots the tab files on run',
                        default=False)
 argparser.add_argument('file', help='the athinput file to configure')
+argparser.add_argument('-x', '--exe', help='the path to the athena executable')
 args = argparser.parse_args()
 
+if args.exe:
+    athena = args.exe
+else:
+    athena = (environ['AGUI'] if 'AGUI' in environ else cwd) + '/athena/bin/athena'
+
 # import a version of PySimpleGUI
 # if the selected one doesn't work, try the other
 primary = 'PySimpleGUIQt'
 backup = 'PySimpleGUI'
 
-if args.tk:
+using_tk = args.tk
+
+if using_tk:
     primary = 'PySimpleGUI'
     backup = 'PySimpleGUIQt'
 
@@ -46,15 +52,12 @@
     sg = import_module(primary)
 except:
     print(f'Falied to import {primary}. Falling back to {backup}')
-    if (args.tk):
-        args.tk = False
+    using_tk = not using_tk
     sg = import_module(backup)
 
 # removes the trailing zeroes then the dot from a string float x, then returns an int
-# utility function used by buidd_layout
+# utility function used by build_layout
 def rm_dot(x):
-    if args.tk:
-        return float(x)
     # being too precise causes problems, but hopefully this is enough
     s = '%.8g' % float(x)
     dot_pos = s.rfind('.')
@@ -63,66 +66,82 @@ def rm_dot(x):
     s = s.replace('.', '')
     return float(s)
 
+#>  IFILE   in=
+#>  OFILE   out=
+#>  IDIR    indir=
+#>  ODIR    odir=
+#>  ENTRY   eps=0.01
+#>  RADIO   mode=gauss              gauss,newton,leibniz
+#>  CHECK   options=mean,sigma      sum,mean,sigma,skewness,kurtosis
+#>  SCALE   n=3.141592              0:10:0.01
 def build_layout(data, info):
     global cwd
-    layout = [[sg.Text('Problem:', font=fstd_bold, background_color=bgstd), 
-               sg.Stretch(background_color=bgstd), 
-               sg.Text(info['problem'], background_color=bgstd)]]
+    menu = [
+        ['Run', ['Print Only', 'Plot']],
+        ['Options', ['Help', 'Reset']],
+        ['View', ['Input File']],
+        ['Exit', ['Close All Plots', 'Close']]
+    ]
+    '''[sg.Menu(menu, tearoff=True)],'''
+    layout = [ [sg.Menu(menu, tearoff=True)],[sg.Text('Problem:', font=fstd_bold), 
+               sg.Stretch(), 
+               sg.Text(info['problem'])]]
     reference = info['reference']
     if reference: # empty strings are falsy
         # in the future, go to the link and get the abstract if possible
-        layout.append([sg.Text('Reference:', font=fstd_bold, background_color=bgstd), 
-                       sg.Stretch(background_color=bgstd), 
-                       sg.Text(info['reference'], background_color=bgstd)])
+        layout.append([sg.Text('Reference:', font=fstd_bold), 
+                       sg.Stretch(), 
+                       sg.Text(info['reference'])])
     else:
-        layout.append([sg.Text('Reference:', font=fstd_bold, background_color=bgstd), 
-                       sg.Stretch(background_color=bgstd), 
-                       sg.Text('N/A', background_color=bgstd)])
+        layout.append([sg.Text('Reference:', font=fstd_bold), 
+                       sg.Stretch(), 
+                       sg.Text('N/A')])
     layout.extend([[sg.Text('Output directory:', 
                             font=fstd_bold, 
-                            tooltip='The directory where the output files will be dumped', 
-                            background_color=bgstd), 
+                            tooltip='The directory where the output files will be dumped'),
+                        sg.Stretch(),
                         sg.In(size=(25, 0.75), 
                             enable_events=True, 
                             default_text=cwd, 
-                            key='output-dir',
-                            background_color=bgstd2,
-                            text_color='white'),
-                        sg.FolderBrowse(initial_folder=cwd, button_color=('white', bgstd2))],
-                  [sg.Text('Parameters:', font=fstd_bold, background_color=bgstd)]])
+                            key='output-dir'),
+                        sg.FolderBrowse(initial_folder=cwd, size = (6, 1) if using_tk else (75, 25))],
+                  [sg.Text('Parameters:', font=fstd_bold)]])
     for k in data:
         e = data[k]
+        t = e['gtype']
         # use this if removing the prefix and underscore is desired
         # row = [sg.Text(match('.*_(.+)', k).group(1))] 
         # otherwise use
-        row = [sg.Text(k, tooltip=e['help'][1:].strip(), background_color=bgstd), 
-               sg.Stretch(background_color=bgstd)]
-        if e['gtype'] == 'SCALE':
+        row = [sg.Text(f'     {k}', tooltip=e['help'][1:].strip()), 
+               sg.Stretch()]
+        if t == 'SCALE': # TODO add textbox for custom values
             # getting scale params
-            # min:max:increment?
-            # (\d*\.?\d*) also accepts just dots, so beware
-            m = match('(\d*\.?\d*):(\d*\.?\d*):(\d*\.?\d*)', e['gparams'])
+            # min:max:increment
+            params = e['gparams'].split(':')
             # scale = slider
             # build sliders differently depending on whether tk or qt is used
-            scaled_default = rm_dot(e['value'])
-            if not args.tk:
-                # if using qt, we need to prepare our own number display since one is not available by default
-                sliders[k] = {
-                    'key':e['value']+'_display',
-                    'factor':round(scaled_default / float(e['value']))
-                }
-                row.append(sg.Text(float(e['value']), key=sliders[k]['key'], background_color=bgstd))
+            # if using qt, we need to prepare our own number display since one is not available by default
+            factor = max([1 if float(x) == 0 else round(rm_dot(x) / float(x)) for x in params])
+            sliders[k] = {
+                'key':k+'_display',
+                'factor':factor
+            }
+            #row.append(sg.Text(float(e['value']), key=sliders[k]['key'], background_color=bgstd))
+            [minimum, maximum, increment, init] = [float(x) for x in params + [e['value']]]
+            row.append(sg.InputText(default_text=int(init) if init.is_integer() else init, key=sliders[k]['key'], justification='right', size=(7, 0.75), enable_events=True))
             # rm_dot only does anything significant if we are using qt
-            row.append(sg.Slider(
-                range=(rm_dot(m.group(1)), rm_dot(m.group(2))),
-                resolution=rm_dot(m.group(3)),
-                default_value=scaled_default,
+            slider = sg.Slider(
+                range=(int(factor * minimum), int(factor * maximum)),
+                resolution=int(factor * increment),
+                default_value=int(factor * init),
                 enable_events=True,
                 key=k,
-                orientation='horizontal',
-                background_color=bgstd
-            ))
-        elif e['gtype'] == 'ENTRY':
+                orientation='horizontal'
+            )
+            if using_tk:
+                slider.DisableNumericDisplay = True
+            row.append(slider)
+        elif t == 'ENTRY':
             # entry = text box
             # size of textboxes seem ok by default when right justified
             # however, if changing the size is desired later, then remember that it is a pair not a single value like in the tkinter version
@@ -130,24 +149,54 @@ def build_layout(data, info):
                 e['value'], 
                 enable_events=True, 
                 key=k,
-                size=(20, 0.75),
-                background_color=bgstd2,
-                text_color='white'
+                size=(20, 0.75)
             ))
-        elif e['gtype'] == 'RADIO':
+        elif t == 'RADIO':
             # number of options is not predetermined, so can't use regex
             for o in e['gparams'].split(','):
-                row.append(sg.Radio(o, k, key=k+o, default= o == e['value'], background_color=bgstd))
+                row.append(sg.Radio(o, k, key=k+o, default= o == e['value']))
+        elif t == 'CHECK':
+            values = e['value'].split(',')
+            checks[k] = {}
+            for o in e['gparams'].split(','):
+                # default value?
+                key = k+o
+                checks[k][key] = o
+                row.append(sg.Checkbox(o, key=key, default= o in values))
+        elif t == 'IFILE' or t == 'OFILE':
+            row.extend([sg.In(size=(25, 0.75), 
+                            enable_events=True, 
+                            default_text=e['value'], 
+                            key=k),
+                        sg.FileBrowse(initial_folder=e['value'], size = (6, 1) if using_tk else (75, 25))])
+        elif t == 'IDIR' or t == 'ODIR':
+            row.extend([sg.In(size=(25, 0.75), 
+                            enable_events=True, 
+                            default_text=e['value'], 
+                            key=k),
+                        sg.FolderBrowse(initial_folder=e['value'], size = (6, 1) if using_tk else (75, 25))])
         else:
             print('GUI type %s not implemented' % e['gtype'])
             exit()
         layout.append(row)
+    
+    ''', 
+                   [
+                        sg.Button('Run'), 
+                        sg.Button('Quit'), 
+                        sg.Button('Help'),
+                        sg.Button('Reset'),
+                        sg.Button('View File')
+                    ]'''
     # add buttons to run/quit/help
-    layout.extend([[sg.Text(background_color=bgstd)], 
+    layout.extend([[sg.Text()], 
                    [
-                        sg.Button('Run', key='run', button_color=('white', bgstd2)), 
-                        sg.Button('Quit', key='quit', button_color=('white', bgstd2)), 
-                        sg.Button('Help', key='help', button_color=('white', bgstd2))
+                        sg.Button('Output'),
+                        sg.Button('Plot'), 
+                        sg.Button('View File'),
+                        sg.Button('Help'),
+                        sg.Button('Reset'),
+                        sg.Button('Quit')
                     ]])
     return layout
 
@@ -161,15 +210,23 @@ def run(input_file, output_dir, data, values):
     cmd = f'{athena} -i {input_file} -d {output_dir} output2/file_type=tab '
     for k in data:
         e = data[k]
+        t = e['gtype']
         # radio buttons are a special case
         # we have to loop through each button to see which is selected
-        if e['gtype'] == 'RADIO':
+        if t == 'RADIO':
             for o in e['gparams'].split(','):
                 if values[k+o]:
                     cmd += f'{k}={o} '
                     break
-        elif not args.tk and e['gtype'] == 'SCALE':
-            cmd += '%s=%s ' % (k, values[k] / sliders[k]['factor'])
+        elif not using_tk and e['gtype'] == 'SCALE':
+            cmd += '%s=%s ' % (k, values[sliders[k]['key']])
+        elif t == 'CHECK' and checks[k]:
+            cmd += f'{k}='
+            cs = checks[k]
+            for ck in cs:
+                if values[ck]:
+                    cmd += f'{cs[ck]},'
+            cmd = cmd[:-1] + ' '
         else:
             cmd += f'{k}={values[k]} '
     # also print it since its easier to copy the text that way
@@ -179,9 +236,8 @@ def run(input_file, output_dir, data, values):
 # builds and displays a new window containing only the athena command
 def display_cmd(s):
     window = sg.Window('Athena Output', 
-                        [[sg.Text(s, background_color=bgstd)]], 
-                        font=fstd, 
-                        background_color=bgstd)
+                        [[sg.Multiline(s, size=(100, round(len(s) / 100)), font=('Courier New', 10))]], 
+                        font=fstd)
     while True:
         event, _ = window.read()
         if event == sg.WIN_CLOSED:
@@ -190,10 +246,9 @@ def display_cmd(s):
 
 # builds and displays a new window with a progress bar tracking the process of athena's output
 def display_pbar(s, time):
-    window = sg.Window('Athena Output', 
+    window = sg.Window('Loading Plot', 
                         [[sg.ProgressBar(100, orientation='h', size=(20, 20), key='pbar')]], 
-                        font=fstd, 
-                        background_color=bgstd)
+                        font=fstd)
     p = Popen(s.split(), stdout=PIPE)
     while True:
         event, _ = window.Read(timeout=0)
@@ -208,16 +263,14 @@ def display_pbar(s, time):
 # builds and displays a new window containing the help information
 def display_help(data):
     layout = [[ sg.Text('Output directory:', 
-                        font=fstd_bold, 
-                        background_color=bgstd), 
-                sg.Text('The directory where the output files will be dumped', 
-                        background_color=bgstd), 
-                        sg.Stretch(background_color=bgstd)]]
+                        font=fstd_bold), 
+                sg.Stretch(),
+                sg.Text('The directory where the output files will be dumped')]]
     for k in data:
-        layout.append([sg.Text(k + ':', font=fstd_bold, background_color=bgstd), 
-                       sg.Text(data[k]['help'][1:].strip(), background_color=bgstd), 
-                       sg.Stretch(background_color=bgstd)])
-    window = sg.Window('Help', layout, font=fstd, background_color=bgstd)
+        layout.append([sg.Text(k + ':', font=fstd_bold), 
+                       sg.Stretch(),
+                       sg.Text(data[k]['help'][1:].strip())])
+    window = sg.Window('Help', layout, font=fstd)
     while True:
         event, _ = window.read()
         if event == sg.WIN_CLOSED:
@@ -225,9 +278,9 @@ def display_help(data):
     window.close()
 
 def display_conf_dir(dir_path):
-    layout = [[sg.Text(f'Directory {dir_path} does not exist. Create it?', background_color=bgstd)], 
-              [sg.Button('Yes', key='yes', button_color=('white', bgstd2)), sg.Button('No', key='no', button_color=('white', bgstd2))]]
-    window = sg.Window('Directory Not Found', layout, font=fstd, background_color=bgstd)
+    layout = [[sg.Text(f'Directory {dir_path} does not exist. Create it?')], 
+              [sg.Button('Yes', key='yes'), sg.Button('No', key='no')]]
+    window = sg.Window('Directory Not Found', layout, font=fstd)
     while True:
         event, _ = window.read()
         if event == 'no':
@@ -238,51 +291,175 @@ def display_conf_dir(dir_path):
     window.close()
     return event == 'yes'
 
-# parse the input files
-data, info, type = parse(args.file)
+def view_file():
+    global lines
+    dummy = sg.Input(visible=False, enable_events=True, key='dummy')
+    window = sg.Window(args.file, 
+        [[sg.Multiline(default_text=''.join(lines), size=(75, 35), key='text', font=('Courier New', 10))],
+            [sg.Text()], # buffer
+        [
+            sg.Button('Load'), dummy, 
+            sg.FileSaveAs('Save As', file_types=(('All Files', '*.*'), 
+                                                ('Text File', '*.txt'), 
+                                                ('Athena Input', 'athinput.*'), 
+                                                ('AthenaK Input', '*.athinput'))), 
+            sg.Button('Save'),
+            sg.Button('Quit')]], return_keyboard_events=True)
+    while True:
+        event, values = window.read()
+        if event == sg.WIN_CLOSED or event == 'Quit':
+            break
+        elif event == 'Load':
+            lines = [line + '\n' for line in values['text'].split('\n')]
+            break
+        elif event == 'dummy' and values['dummy']:
+            with open(values['dummy'], 'w') as dfile:
+                dfile.write(values['text'])
+        elif event == 'Save':
+            choice = sg.popup_ok_cancel('WARNING: You are about to override', args.file)
+            if choice == 'OK':
+                with open(args.file, 'w') as overriden_file:
+                    overriden_file.write(values['text'])
+    window.close()
 
-# start building gui
-inner_layout = build_layout(data, info)
-# pysgqt elements seem to be smaller than their tkinter counterparts, so it might be better to reduce the width scaling
-scale_factor = 30
-if args.tk:
-    scale_factor = 40
-win_size = (500, len(inner_layout) * scale_factor)
-layout = [[sg.Column(inner_layout, size=win_size, scrollable=False, background_color=bgstd)]]
+def update(dat, window):
+    for k in dat:
+        e = dat[k]
+        t = e['gtype']
+        if t == 'CHECK':
+            values = e['value'].split(',')
+            for o in e['gparams'].split(','):
+                window[k+o].update(value= o in values)
+        elif t == 'RADIO':
+            for o in e['gparams'].split(','):
+                if o == e['value']: # won't work otherwise
+                    #print(o)
+                    window[k+o].update(value=True)
+                    break
+        elif t == 'SCALE':
+            [m, M, _] = e['gparams'].split(':')
+            value = float(e['value'])
+            if float(m) < value < float(M): # only bother changing the slider if actually in range
+                window[k].update(value=int(sliders[k]['factor'] * value))
+            window[k+'_display'].update(value=str(int(value) if value.is_integer() else value))
+        else:
+            window[k].update(value=e['value'])
+
+with open(args.file) as file:
+    lines = file.readlines()
+
+while lines:
+    # parse the input files
+    data, info, type = parse(lines, silent=True)
 
-# only allow verticle scroll for the tk version, otherwise a horizontal scroll bar will show up
-#if args.tk:
-#    layout[0][0].VerticalScrollOnly = True
+    forced_slider = False
 
-# create the main window
-window = sg.Window('pysg_run', layout, size=win_size, font=fstd, background_color='#777777')
+    sg.theme('Default1')
+
+    sg.SetOptions(slider_border_width=0)
+
+    # start building gui
+    inner_layout = build_layout(data, info)
+    # pysgqt elements seem to be smaller than their tkinter counterparts, so it might be better to reduce the width scaling
+    scale_factor = 27
+    '''if using_tk:
+        scale_factor = 33'''
+    win_size = (550, len(inner_layout) * scale_factor)
+    #layout = [[sg.Column(inner_layout, size=win_size, scrollable=False, background_color=bgstd)]]
+    # only allow verticle scroll for the tk version, otherwise a horizontal scroll bar will show up
+    #if using_tk:
+    #    layout[0][0].VerticalScrollOnly = True
+    # create the main window '#777777'
+    # already resizable by default?
+    window = sg.Window('pysg run', inner_layout, size=win_size, font=fstd, resizable=True, grab_anywhere=False, return_keyboard_events=using_tk)
+    window.read(timeout=0)
+
+    if using_tk: # won't work in qt, though it doesn't need to
+        for slider in sliders:
+            window[slider].bind('<Enter>', '+c_etr')
+        window.bind('<Leave>', 'cursor leave')
+        focus = None
+        first = False
+        def update_tk_sliders(f):
+            # update the slider position
+            slider_key = focus.split('+')[0]
+            slider = window[slider_key]
+            raw_value = f(values[slider_key], slider.Resolution)
+            slider.update(raw_value)
+            m, M = slider.Range
+            if m <= raw_value <= M:
+                # update the slider display
+                slider_info = sliders[slider_key]
+                value = raw_value / slider_info['factor']
+                window[slider_info['key']].update(int(value) if value.is_integer() else value)
+
+    # primary event loop
+    while True:
+        event, values = window.read()
+        print(event)
+        if event == sg.WIN_CLOSED or event in ('Quit', 'Close', 'Close All Plots'):
+            if event == 'Close All Plots':
+                for plot in plots: # inefficient
+                    plot.kill()
+            lines = None
+            break
+        elif event in ('Output', 'Plot', 'Print Only'):
+            cmd = run(args.file, values['output-dir'], data, values)
+            if cmd and event == 'Plot':
+                if not path.exists(athena):
+                    print('Athena not found\nExiting')
+                    exit()
+                # open the plot in a subprocess
+                # remove the forward slash at the end if there is one
+                odir = values['output-dir']
+                if odir[-1] == '/':
+                    odir = odir[:-1]
+                # remove the hst file since it always gets appended to
+                # intentional?
+                h = glob(odir + '/*.hst')
+                if len(h) > 0:
+                    remove(h[0])
+                # will the tlim variable always be like this?
+                display_pbar(cmd, values['time/tlim'])
+                #print(info)
+                plots.append(Popen(['python', 'plot1d.py', '-d', values['output-dir'], '-n', info['problem']]))
+                plots.append(Popen(['python', 'plot1d.py', '-d', values['output-dir'], '--hst', '-n', info['problem'] + ' history']))
+            elif cmd:
+                display_cmd(cmd)
+        elif event == 'Help':
+            display_help(data)
+        # update slider displays if using qt
+        elif event in sliders:
+            slider_info = sliders[event]
+            value = values[event] / slider_info['factor']
+            window[slider_info['key']].update(int(value) if value.is_integer() else value)
+        elif '_display' in event:
+            try:
+                key = event[:-8]
+                slider = window[key]
+                value = float(values[event]) * sliders[key]['factor']
+                m, M = slider.Range
+                if m <= value <= M:
+                    forced_slider = True
+                    slider.update(int(value) if value.is_integer() else value)
+            except:
+                pass
+        elif event == 'View File':
+            view_file()
+            if lines:
+                break
+        elif event == 'Reset':
+            update(data, window)
 
-# primary event loop
-while True:
-    event, values = window.read()
-    if event == sg.WIN_CLOSED or event == 'quit':
-        break
-    elif event == 'run':
-        cmd = run(args.file, values['output-dir'], data, values)
-        if cmd and args.run:
-            if not path.exists(athena):
-                print('Athena not found\nExiting')
-                exit()
-            # will the tlim variable always be like this?
-            display_pbar(cmd, values['time/tlim'])
-            # open the plot in a subprocess
-            # remove the forward slash at the end if there is one
-            odir = values['output-dir']
-            if odir[-1] == '/':
-                odir = odir[:-1]
-            Popen(['python', 'plot1d.py', '-d', values['output-dir']])
-        elif cmd:
-            display_cmd(cmd)
-    elif event == 'help':
-        display_help(data)
-    # update slider displays if using qt
-    elif not args.tk and event in sliders:
-        info = sliders[event]
-        window[info['key']].update(values[event] / info['factor'])
+        # this allows the tk slider to work with the mouse wheel
+        if using_tk:
+            if '+c_etr' in event:
+                focus = event
+            elif event == 'cursor leave':
+                focus = None
+            elif event == 'MouseWheel:Up' and focus and 'c_etr' in focus:
+                update_tk_sliders(lambda x, y: x + y)
+            elif event == 'MouseWheel:Down' and focus and 'c_etr' in focus:
+                update_tk_sliders(lambda x, y: x - y)
 
-window.close()
+    window.close()
\ No newline at end of file
diff --git a/pythena.py b/pythena.py
new file mode 100755
index 0000000..54ac9b0
--- /dev/null
+++ b/pythena.py
@@ -0,0 +1,249 @@
+#! /usr/bin/env python
+#
+from PyQt5 import QtWidgets as qw, QtGui as qg
+from argparse import ArgumentParser
+from json import load
+from subprocess import Popen, PIPE
+from re import match
+from sys import argv
+from os import path
+
+# parse arguments
+argparser = ArgumentParser(description='Runs the GUI for configuring an athinput file')
+argparser.add_argument('-r', '--run',
+                       action='store_true',
+                       help='executes the athena command and plots the tab files on run',
+                       default=False)
+args = argparser.parse_args()
+
+# building gui
+with open('athena_problems.json') as problems_json:
+    problems = load(problems_json)
+
+
+athena_problems = list([])
+athena_problems = list(problems['athenak'])
+
+class MainWindow(qw.QMainWindow):
+    def __init__(self):
+        super().__init__()
+
+        self.radio_groups = []
+        self.windows = []
+
+        page_layout = qw.QVBoxLayout()
+        radio_layout = qw.QHBoxLayout()
+        exe_layout = qw.QHBoxLayout()
+        load_layout = qw.QHBoxLayout()
+        predef_layout = qw.QHBoxLayout()
+        self.current_athena = 'athena'
+
+        toolbar = self.addToolBar('ToolBar')
+
+        launch_action = qw.QAction('Launch', self)
+        launch_action.setToolTip('Launch the parameter configurator')
+        launch_action.triggered.connect(self.launch)
+        toolbar.addAction(launch_action)
+        toolbar.addSeparator()
+
+        help_action = qw.QAction('Help', self)
+        help_action.setToolTip('Open help menu')
+        help_action.triggered.connect(self.help)
+        toolbar.addAction(help_action)
+        toolbar.addSeparator()
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Exit the program')
+        quit_action.triggered.connect(self.quit)
+        toolbar.addAction(quit_action)
+
+        def browse(t):
+            file = qw.QFileDialog.getOpenFileName(self, "Select File", "")[0]
+            t.setText(file)
+
+        if False:
+            label = qw.QLabel('Athena Version: [deprecating]')
+            radio_layout.addWidget(label)
+            label.setStyleSheet("font-weight: bold")
+            radio_layout.addStretch()
+        
+            rbtn = qw.QRadioButton('Athena')
+            #rbtn.setChecked(True)
+            rbtn.toggled.connect(lambda: self.switch('athena'))
+            radio_layout.addWidget(rbtn)
+            rbtn = qw.QRadioButton('AthenaK')
+            rbtn.setChecked(True)        
+            rbtn.toggled.connect(lambda: self.switch('athenak'))
+            radio_layout.addWidget(rbtn)
+            rbtn = qw.QRadioButton('AthenaC')
+            rbtn.toggled.connect(lambda: self.switch('athenac'))
+            radio_layout.addWidget(rbtn)
+
+        if False:
+            label = qw.QLabel('Athena Executable: [deprecating]')
+            exe_layout.addWidget(label)
+            label.setStyleSheet("font-weight: bold")
+            btn = qw.QPushButton(self)
+            btn.setText("browse")
+            self.exe = qw.QLineEdit(self)
+            btn.clicked.connect(lambda: browse(self.exe))
+            self.exe.setFixedWidth(250)
+            self.exe.setText('athenak/build/src/athena')
+            exe_layout.addStretch()
+            exe_layout.addWidget(btn)
+            exe_layout.addWidget(self.exe)
+            self.athena = self.exe.text()
+        else:
+            self.athena = 'athenak/build/src/athena'
+        print("athena:",self.athena)
+
+        btn_group = qw.QButtonGroup()
+
+        self.load_radio = qw.QRadioButton('Load Problem:')
+        self.load_radio.setStyleSheet('font-weight: bold')
+        self.load_radio.setChecked(True)
+        load_layout.addWidget(self.load_radio)
+        load_layout.addStretch()
+        btn = qw.QPushButton(self)
+        btn.setText("browse")
+        self.problem = qw.QLineEdit(self)
+        btn.clicked.connect(lambda: browse(self.problem))
+        self.problem.setFixedWidth(250)
+        self.problem.setText('linear_wave_hydro.athinput')
+        load_layout.addWidget(btn)
+        load_layout.addWidget(self.problem)
+
+        self.predef_radio = qw.QRadioButton('Predefined Problem: [TBD]')
+        self.predef_radio.setStyleSheet('font-weight: bold')
+        predef_layout.addWidget(self.predef_radio)
+        self.combo = qw.QComboBox()
+        self.combo.addItems(athena_problems)
+        predef_layout.addStretch()
+        predef_layout.addWidget(self.combo)
+
+        btn_group.addButton(self.load_radio)
+        btn_group.addButton(self.predef_radio)
+        self.radio_groups.append(btn_group)
+
+        page_layout.addLayout(radio_layout)
+        page_layout.addLayout(exe_layout)
+        page_layout.addLayout(load_layout)
+        page_layout.addLayout(predef_layout)
+        # checkbox
+
+        if False:
+            self.reconfig = qw.QCheckBox('Reconfigure Executable')
+            page_layout.addWidget(self.reconfig)
+        else:
+            print("no reconfig needed for athenak")
+
+        widget = qw.QWidget()
+        widget.setLayout(page_layout) 
+        scroll = qw.QScrollArea()    #add scrollbar
+        scroll.setWidgetResizable(True)
+        scroll.setWidget(widget)
+        self.resize(700, 300)
+        self.setCentralWidget(scroll)
+
+    def switch(self, type):
+        self.combo.clear()
+        if type == 'athena':
+            self.combo.addItems(athena_problems)
+            self.reconfig.setVisible(True)
+        elif type == 'athenak':
+            self.combo.addItems(athenak_problems)
+            self.reconfig.setVisible(False)
+        else:
+            self.combo.addItems(athenac_problems)
+            self.reconfig.setVisible(True)
+        self.current_athena = type
+        print("Current athena:",type)
+
+    def rebuild(self, problem):
+        config = None
+        with open(problem) as file:
+            line = file.readline()
+            while line:
+                m = match('config[^=]+=(.+)', line)
+                if m:
+                    config = m.group(1)
+                    break
+                line = file.readline()
+        w = ConfigWindow(config)
+        w.show()
+        w.run()
+        w.close()
+
+    def launch(self):
+        problem = problems[self.current_athena][self.combo.currentText()] if self.predef_radio.isChecked() else self.problem.text()
+        cmd = './pythena_run.py %s -x %s %s' % (problem, 
+                                                self.athena,
+                                                '-r' if args.run else '')
+        print(cmd)
+        try:
+            if not path.exists(problem):
+                raise FileNotFoundError
+            Popen(cmd.split())
+        except Exception as e:
+            print(e)
+
+    def help(self):
+        w = HelpWindow()
+        self.windows.append(w)
+        w.show()
+
+    def quit(self):
+        self.close()
+
+# deprecate        
+class ConfigWindow(qw.QWidget):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.setWindowTitle('Rebuilding Executable')
+        self.main_layout = qw.QVBoxLayout()
+        bash_label = qw.QLabel('./reconfig.sh ' + self.config)
+        bash_label.setStyleSheet('font-weight: bold')
+        bash_label.setFont(qg.QFont('Courier New', 10))
+        self.main_layout.addWidget(bash_label)
+        self.txt = qw.QLabel()
+        self.txt.setFont(qg.QFont('Courier New', 10))
+        self.main_layout.addWidget(self.txt)
+        self.setLayout(self.main_layout)
+
+    def run(self):
+        p = Popen(['./reconfig.sh', self.config], stdout=PIPE)
+        line = p.stdout.readline()
+        while line:
+            self.txt.setText(line.decode())
+            qg.QGuiApplication.processEvents()
+            line = p.stdout.readline()
+
+class HelpWindow(qw.QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle('Help')
+        self.main_layout = qw.QVBoxLayout()
+        self.add_label('Athena Version:', '\tThe version of Athena (must match the version of the executable) to be used')
+        self.add_label('Athena Executable:', '\tEither the path or the name of the Athena executable. If only a name is given, then it is assumed that the executable is in /usr/bin.')
+        self.add_label('Selecting Problems:', '\tA problem can either be selected from the list of predefined problems or a custom problem can be chosen. Use the radio buttons to choose which method to use.')
+        self.setLayout(self.main_layout)
+
+    def add_label(self, s1, s2):
+        txt = qw.QLabel(s1)
+        txt.setStyleSheet('font-weight: bold')
+        self.main_layout.addWidget(txt)
+        self.main_layout.addWidget(qw.QLabel(s2))
+
+
+app = qw.QApplication(argv)
+
+main = MainWindow()
+main.show()
+
+try:
+    #print('opening window')
+    exit(app.exec())
+except:
+    #print('closing window')
+    pass
diff --git a/pythena_run.py b/pythena_run.py
new file mode 100755
index 0000000..725bc17
--- /dev/null
+++ b/pythena_run.py
@@ -0,0 +1,694 @@
+#! /usr/bin/env python
+#
+from PyQt5 import QtCore as qc, QtWidgets as qw, QtGui as qg
+
+# utility imports
+import os
+from re import match
+from aparser import parse_s as parse
+from argparse import ArgumentParser
+from os import getcwd, remove, environ, path
+from subprocess import Popen, PIPE
+from glob import glob
+from sys import argv, exit
+
+class MainWindow(qw.QMainWindow):
+
+    def __init__(self, data, info):
+        super(MainWindow, self).__init__()
+
+        self.windows = []
+
+        self.data = data
+        self.info = info
+        self.radio_groups = []
+        self.sliders = {}
+        self.input={}
+
+        self.forced_slider = False
+
+        self.initUI()
+
+    # removes the trailing zeroes then the dot from a string float x, then returns an int
+    # utility function used by build_layout
+    def rm_dot(self, x):
+        # being too precise causes problems, but hopefully this is enough
+        s = '%.8g' % float(x)
+        dot_pos = s.rfind('.')
+        if dot_pos < 0:
+            return int(s)
+        s = s.replace('.', '')
+        return int(s)
+
+    def initUI(self):
+        self.pagelayout = qw.QVBoxLayout()       # page layout
+        self.dbtnlayout = qw.QHBoxLayout()       # layout for the default buttons
+        self.elmtlayout = qw.QVBoxLayout()       # layout for the added widgets, stacks elements
+        
+        self.problayout = qw.QHBoxLayout()
+        self.reflayout = qw.QHBoxLayout()
+        self.outdirlayout = qw.QHBoxLayout()
+
+        # run, save, load, quit, help buttons -> located in a toolbar
+        toolbar = self.addToolBar("ToolBar")
+
+        plot_action = qw.QAction('Run', self)
+        plot_action.setToolTip('Run minik and Plot the output of the command ran under these configurations')
+
+        run_action = qw.QAction('Dryrun', self)
+        run_action.setToolTip('Output the command the would be ran when run')
+
+        edit_action = qw.QAction('Edit', self)
+        edit_action.setToolTip('Open the input file for editing')
+
+        help_action = qw.QAction('Help', self)
+        help_action.setToolTip('Display details about each configuration field')
+
+        reset_action = qw.QAction('Reset', self)
+        reset_action.setToolTip('Revert configuration options to default settings')
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Exits the application')
+
+
+        toolbar.addAction(plot_action)
+        toolbar.addSeparator()
+        toolbar.addAction(run_action)        
+        toolbar.addSeparator()
+        toolbar.addAction(edit_action)
+        toolbar.addSeparator()
+        toolbar.addAction(help_action)
+        toolbar.addSeparator()
+        toolbar.addAction(reset_action)
+        toolbar.addSeparator()
+        toolbar.addAction(quit_action)
+
+        #add layouts to the page
+        #self.pagelayout.addLayout(self.infolayout)
+        self.pagelayout.addLayout(self.elmtlayout)
+        #elf.pagelayout.addStretch()
+        #self.pagelayout.addLayout(self.dbtnlayout) 
+
+        # to set bold
+        # self.label.setStyleSheet("font-weight: bold")
+
+        l1 = qw.QLabel('Problem:')
+        l1.setStyleSheet("font-weight: bold")
+        l2 = qw.QLabel(info['problem'])
+        self.problayout.addWidget(l1)
+        self.problayout.addStretch()
+        self.problayout.addWidget(l2)
+
+        reference = info['reference']
+        l1 = qw.QLabel('Layout:')
+        l1.setStyleSheet("font-weight: bold")
+        if reference:
+            l2 = qw.QLabel(reference)
+        else:
+            l2 = qw.QLabel('N/A')
+        self.reflayout.addWidget(l1)
+        self.reflayout.addStretch()
+        self.reflayout.addWidget(l2)
+
+        l1 = qw.QLabel('Output Directory:')
+        l1.setStyleSheet("font-weight: bold")
+        l1.setToolTip('The directory where the output file will be dumped')
+        self.outdirlayout.addWidget(l1)
+        self.outdirlayout.addStretch()
+        btn = qw.QPushButton(self)
+        btn.setText("browse")
+        def browse_dir(t):
+            file = qw.QFileDialog.getExistingDirectory(self, "Select Directory", "")
+            t.setText(file)
+        txt = qw.QLineEdit(self)
+        btn.clicked.connect(lambda: browse_dir(txt))
+        txt.setFixedWidth(250)
+        txt.setText(cwd)
+        self.outdirlayout.addWidget(btn)
+        self.outdirlayout.addWidget(txt)
+
+        self.elmtlayout.addLayout(self.problayout)
+        self.elmtlayout.addLayout(self.reflayout)
+        self.elmtlayout.addLayout(self.outdirlayout)
+
+        run_action.triggered.connect(lambda: self.run(txt, False))
+        plot_action.triggered.connect(lambda: self.run(txt, True))
+        edit_action.triggered.connect(self.view)
+        help_action.triggered.connect(self.help)
+        reset_action.triggered.connect(self.reset)
+        quit_action.triggered.connect(self.quit)
+
+        #run, save, load, quit, help button
+        '''btn = qw.QPushButton(self)
+        btn.setText("Run")
+        btn.clicked.connect(lambda: self.run(txt, args.run))
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("View File")
+        btn.clicked.connect(self.view)
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("Help")
+        btn.clicked.connect(self.help)
+        self.dbtnlayout.addWidget(btn)
+
+        btn = qw.QPushButton(self)
+        btn.setText("Reset")
+        btn.clicked.connect(self.reset)
+        self.dbtnlayout.addWidget(btn)
+        
+        btn = qw.QPushButton(self)
+        btn.setText("Quit")
+        btn.clicked.connect(self.quit)
+        self.dbtnlayout.addWidget(btn)'''
+
+        #set the main page layout
+        widget = qw.QWidget()
+        widget.setLayout(self.pagelayout) 
+        scroll = qw.QScrollArea()    #add scrollbar
+        scroll.setWidgetResizable(True)
+        scroll.setWidget(widget)
+        self.setGeometry(500, 100, 700, 500)
+        self.setCentralWidget(scroll)
+
+        self.createWidgetsFromGroups()
+    
+    def run(self, odir_input, plot):
+        #print('run')
+        cmd = f'cp {args.file} {odir_input.text()}'
+        print(cmd)
+        Popen(cmd.split())
+        
+        #cmd = f'{athena} -i {args.file} -d {odir_input.text()} output2/file_type=tab '
+        cmd = f'{athena} -i {args.file} -d {odir_input.text()} '
+
+        for k in self.data:
+            e = data[k]
+            t = e['gtype']
+
+            if t == 'RADIO':
+                for r in self.input[k]:
+                    if r.isChecked():
+                        cmd += f'{k}={r.text()} '
+                        break
+            elif t == 'CHECK' and self.input[k]:
+                cmd += f'{k}='
+                for c in self.input[k]:
+                    if c.isChecked():
+                        cmd += f'{c.text()},'
+                cmd = cmd[:-1] + ' '
+            else:
+                cmd += '%s=%s ' % (k, self.input[k].text())
+
+        print(cmd)
+        # create odir (including intermediaries if needed)
+        odir = odir_input.text()
+        os.makedirs(odir,exist_ok=True)
+        hname = f'{odir_input.text()}/history'
+        with open(hname, 'w') as file:
+            file.write(cmd)
+        
+        if plot:
+            if not path.exists(athena):
+                print('Athena not found\nExiting')
+            # open the plot in a subprocess
+            # remove the forward slash at the end if there is one
+            if odir[-1] == '/':
+                odir = odir[:-1]
+            # remove the hst file since it always gets appended to
+            # intentional?
+            h = glob(odir + '/*.hst')
+            if len(h) > 0:
+                remove(h[0])
+            # will the tlim variable always be like this?
+            # display_pbar(cmd, values['time/tlim'])
+            '''p = Popen(cmd.split())
+            p.wait()'''
+            w = LoadingWindow(cmd, float(self.input['time/tlim'].text()))
+            self.windows.append(w)
+            w.show()
+            w.run()
+            w.close()
+            # @todo     only if tab files, fix for tab/vtk
+            # @todo     solve when info['problem'] has spaces (as many do)
+            #Popen(['python', 'plot1d.py', '-d', odir+'/tab',           '-n', info['problem']])
+            #Popen(['python', 'plot1d.py', '-d', odir,         '--hst', '-n', info['problem'] + ' history'])
+            cmd1 = 'python plot1d.py  -d %s/tab' % (odir)
+            cmd2 = 'python plot1d.py  -d %s --hst' % (odir)
+            print(cmd1)
+            print(cmd2)
+            Popen(cmd1.split())
+            Popen(cmd2.split())
+        else:
+            w = DisplayWindow(cmd)
+            self.windows.append(w)
+            w.show()
+
+    def view(self):
+        #print('view')
+        w = ViewerWindow()
+        self.windows.append(w)
+        w.show()
+    
+    def reset(self):
+        for k in self.data:
+            e = data[k]
+            t = e['gtype']
+
+            if t == 'RADIO':
+                for r in self.input[k]:
+                    if r.text() == e['value']:
+                        r.setChecked(True)
+                        break
+            elif t == 'CHECK' and self.input[k]:
+                defaults = e['value'].split(',')
+                for c in self.input[k]:
+                    c.setChecked(c.text() in defaults)
+            elif t == 'SCALE':
+                self.input[k].setText(str(e['value']))
+                self.sliders[k]['key'].setValue(int(self.sliders[k]['factor'] * float(e['value'])))
+            else:
+                self.input[k].setText(str(e['value']))
+
+    def quit(self):
+        self.close()
+        #print('quit')
+
+    def help(self):
+        #print('help')
+        w = HelpWindow(self.data)
+        size = w.main_layout.sizeHint()
+        size.setWidth(size.width() + 10)
+        size.setHeight(size.height() + 10)
+        self.windows.append(w)
+        w.show()
+
+    def createWidgetsFromGroups(self):
+        plabel = qw.QLabel('Parameters:')
+        plabel.setStyleSheet("font-weight: bold")
+        self.elmtlayout.addWidget(plabel)
+        #self.elmtlayout.setSpacing(10)
+        for k in data:
+            e = data[k]
+            t = e['gtype']
+            tooltip = e['help'][1:].strip()
+            if t == 'RADIO':
+                new_group = qw.QButtonGroup()
+                self.radio_groups.append(new_group)
+                self.input[k] = []
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+
+                for option in e['gparams'].split(','):
+                    # option = option.strip()
+                    radio_button = qw.QRadioButton(option)
+                    self.input[k].append(radio_button)
+                    new_group.addButton(radio_button)
+                    group_layout.addWidget(radio_button)
+                    if option == e['value']:
+                        radio_button.setChecked(True)
+                self.elmtlayout.addLayout(group_layout)
+
+            elif t == "IFILE" or t == "OFILE":
+                #print("browse files button created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                btn = qw.QPushButton(self)
+                btn.setText("browse")
+                txt = qw.QLineEdit(self)
+                def browse_file(t):
+                    file = qw.QFileDialog.getOpenFileName(self, "Select File", "")[0]
+                    t.setText(file)
+                btn.clicked.connect(lambda _, t=txt: browse_file(t))
+                txt.setFixedWidth(250)
+                txt.setText(e['value'])
+                group_layout.addWidget(btn)
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = txt
+
+            elif t == "IDIR" or t == 'ODIR':
+                #print("browse directories button created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                btn = qw.QPushButton(self)
+                btn.setText("browse")
+                def browse_dir(t):
+                    file = qw.QFileDialog.getExistingDirectory(self, "Select Directory", "")
+                    t.setText(file)
+                txt = qw.QLineEdit(self)
+                btn.clicked.connect(lambda _, t=txt: browse_dir(t))
+                txt.setFixedWidth(250)
+                txt.setText(e['value'])
+                group_layout.addWidget(btn)
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = txt
+
+            elif t == "CHECK":
+                #print("checkbox created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                values = e['value'].split(',')
+                self.input[k] = []
+                for option in e['gparams'].split(','):
+                    #option = option.strip()
+                    checkbox = qw.QCheckBox(option, self)
+                    self.input[k].append(checkbox)
+                    group_layout.addWidget(checkbox)
+                    if option in values:
+                        checkbox.setChecked(True)
+                self.elmtlayout.addLayout(group_layout)
+
+            
+            elif t == "ENTRY":
+                #print("textbox created")
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                txt = qw.QLineEdit(self)
+                txt.setText(e['value'])
+                txt.setFixedWidth(250)
+                self.input[k] = txt
+                group_layout.addWidget(txt)
+                self.elmtlayout.addLayout(group_layout)
+
+            elif t == "SCALE":
+                group_layout = qw.QHBoxLayout()
+                label = qw.QLabel(f'\t{k}:')
+                label.setToolTip(tooltip)
+                group_layout.addWidget(label)
+                group_layout.addStretch()
+                params = e['gparams'].split(':')
+
+                #print("slider created")
+                #creates a horizontal slider
+                init = float(e['value'])
+                label_slider = qw.QLineEdit(str(int(init) if init.is_integer() else init))
+                label_slider.textEdited.connect(lambda value, key=k: self.update_slider(value, key))
+                label_slider.setAlignment(qc.Qt.AlignRight)
+                label_slider.setFixedWidth(85)
+                # the label slider is unique to this slider
+                # so we will use it to identify the slider
+                factor = max([1 if float(x) == 0 else round(self.rm_dot(x) / float(x)) for x in params])
+                slider = qw.QSlider(self)
+                self.sliders[k] = {
+                    'key':slider,
+                    'factor':factor
+                    #'is_int':params[0].isdigit() and params[1].isdigit() and params[2].isdigit()
+                }
+                [minimum, maximum, increment] = [float(x) for x in params]
+                slider.setOrientation(qc.Qt.Horizontal)
+                slider.setSingleStep(int(factor * increment))
+                slider.setPageStep(int(factor * increment))       #moves the slider when clicking or up/down
+                slider.setRange(int(factor * minimum), int(factor * maximum))
+                slider.setValue(int(factor * init))
+
+                slider.valueChanged.connect(lambda value, key=k, lbl=label_slider: self.updateLabel(key, lbl, value))
+                
+                slider.setFixedWidth(250)
+
+                group_layout.addWidget(label_slider)
+                group_layout.addWidget(slider)
+                self.elmtlayout.addLayout(group_layout)
+                self.input[k] = label_slider
+
+    def update_slider(self, value, key):
+        try:
+            slider_info = self.sliders[key]
+            slider = slider_info['key']
+            minimum = slider.minimum()
+            maximum = slider.maximum()
+            fvalue = float(value) * slider_info['factor']
+            if minimum <= fvalue <= maximum:
+                self.forced_slider = True
+                slider.setValue(int(fvalue))
+        except:
+            pass
+
+    def updateLabel(self, key, label, value):
+        if self.forced_slider:
+            self.forced_slider = False
+        else:
+            slider_info = self.sliders[key]
+            scaled = value/slider_info['factor']
+            label.setText(str(int(scaled) if scaled.is_integer() else scaled))
+
+class LoadingWindow(qw.QMainWindow):
+    def __init__(self, cmd, tlim):
+        super().__init__()
+
+        self.setWindowTitle('Loading')
+        self.cmd = cmd
+        self.tlim = tlim
+        self.pbar = qw.QProgressBar(self)
+        self.setCentralWidget(self.pbar)
+
+    def run(self):
+        p = Popen(self.cmd.split(), stdout=PIPE)
+
+        line = p.stdout.readline()
+
+        while line:
+            m = match('.*cycle=.* time=(.*) dt=.*', line.decode())
+            if m:
+                i = int(100 * float(m.group(1)) / self.tlim)
+                self.pbar.setValue(i)
+                # print(i, self.pbar.value())
+                qg.QGuiApplication.processEvents()
+            line = p.stdout.readline()
+
+class ConfirmWindow(qw.QWidget):
+    def __init__(self, parent):
+        super().__init__()
+
+        self.setWindowTitle('Confirm')
+
+        self.par = parent
+
+        layout = qw.QVBoxLayout()
+        btn_layout = qw.QHBoxLayout()
+
+        text = qw.QLabel('WARNING: You are about to override ' + args.file)
+        layout.addWidget(text)
+
+        btn = qw.QPushButton()
+        btn.setText('Ok')
+        btn.clicked.connect(self.ok)
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Cancel')
+        btn.clicked.connect(self.cancel)
+        btn_layout.addWidget(btn)
+
+        layout.addLayout(btn_layout)
+
+        self.setLayout(layout)
+
+    def ok(self):
+        self.par.ok = True
+        self.close()
+
+    def cancel(self):
+        self.par.ok = False
+        self.close()
+
+class ViewerWindow(qw.QMainWindow):
+    def __init__(self):
+        super().__init__()
+        global lines
+        self.ok = False
+        self.windows = []
+        self.setWindowTitle(args.file)
+        self.resize(750, 750)
+
+        toolbar = self.addToolBar('ToolBar')
+
+        load_action = qw.QAction('Load', self)
+        load_action.setToolTip('Reload the GUI with this file')
+        load_action.triggered.connect(self.load)
+        toolbar.addAction(load_action)
+        toolbar.addSeparator()
+
+        save_as_action = qw.QAction('Save As', self)
+        save_as_action.setToolTip('Save as a new file (Ctrl+Shift+s)')
+        save_as_action.triggered.connect(self.save_as)
+        save_as_action.setShortcut('Ctrl+Shift+s')
+        toolbar.addAction(save_as_action)
+        toolbar.addSeparator()
+
+        save_action = qw.QAction('Save', self)
+        save_action.setToolTip('Save changes to the original input file (Ctrl+s)')
+        save_action.triggered.connect(self.save)
+        save_action.setShortcut('Ctrl+s')
+        toolbar.addAction(save_action)
+        toolbar.addSeparator()
+
+        quit_action = qw.QAction('Quit', self)
+        quit_action.setToolTip('Closes the editor')
+        quit_action.triggered.connect(self.quit)
+        toolbar.addAction(quit_action)
+        toolbar.addSeparator()
+
+        layout = qw.QVBoxLayout()
+        self.box = qw.QPlainTextEdit(''.join(lines), self)
+        self.box.resize(750, 700)
+        self.box.setFont(qg.QFont('Courier New', 10))
+        layout.addWidget(self.box)
+
+        #set the main page layout
+        widget = qw.QWidget()
+        widget.setLayout(layout) 
+        # self.setGeometry(500, 100, 700, 500)
+        self.setCentralWidget(widget)
+
+        '''btn_layout = qw.QHBoxLayout()
+
+        btn = qw.QPushButton()
+        btn.setText('Load')
+        btn.clicked.connect(self.load)
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Save As')
+        btn.clicked.connect(self.save_as)
+        btn.setShortcut('Ctrl+Shift+s')
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        btn.setText('Save')
+        btn.clicked.connect(self.save)
+        btn.setShortcut('Ctrl+s')
+        btn_layout.addWidget(btn)
+
+        btn = qw.QPushButton()
+        
+        btn.setText('Quit')
+        btn.clicked.connect(self.quit)
+        btn_layout.addWidget(btn)
+    
+        layout.addLayout(btn_layout)'''
+
+    def load(self):
+        global data, info, lines, main
+        lines = [line + '\n' for line in self.box.toPlainText().split('\n')]
+        data, info, _ = parse(lines, silent=True)
+        main.close()
+        build_main(data, info)
+        self.close()
+
+    def save_as(self):
+        filename, _ = qw.QFileDialog.getSaveFileName(self,
+                                       'Save File',
+                                       '',
+                                       'All Files(*);;Text Files(*.txt);;AthenaK Input(*.athinput);;Athena Input(athinput.*)')
+        if filename:
+            with open(filename, 'w') as file:
+                file.write(self.box.toPlainText())
+
+    def save(self):
+        w = ConfirmWindow(self)
+        self.windows.append(w)
+        w.setAttribute(qc.Qt.WA_DeleteOnClose)
+        w.setWindowModality(qc.Qt.ApplicationModal)
+        w.show()
+        loop = qc.QEventLoop()
+        w.destroyed.connect(loop.quit)
+        loop.exec()
+        if self.ok:
+            with open(args.file, 'w') as file:
+                file.write(self.box.toPlainText())
+
+    def quit(self):
+        self.close()
+
+class DisplayWindow(qw.QWidget):
+    def __init__(self, cmd):
+        super().__init__()
+        self.setWindowTitle('Athena Output')
+        self.resize(500, 200)
+        layout = qw.QVBoxLayout()
+        line = qw.QPlainTextEdit(cmd, self)
+        line.setFont(qg.QFont('Courier New', 10))
+        layout.addWidget(line)
+        self.setLayout(layout)
+
+class HelpWindow(qw.QWidget):
+    def __init__(self, data):
+        super().__init__()
+        self.setWindowTitle('Help')
+        self.main_layout = qw.QVBoxLayout()
+        for k in data:
+            sublayout = qw.QHBoxLayout()
+            l1 = qw.QLabel(k + ': ')
+            l1.setStyleSheet("font-weight: bold")
+            l2 = qw.QLabel(data[k]['help'][1:].strip())
+            sublayout.addWidget(l1)
+            sublayout.addWidget(l2)
+            sublayout.addStretch()
+            self.main_layout.addLayout(sublayout)
+        self.setLayout(self.main_layout)
+
+# building the gui
+
+def build_main(data, info):
+    global main
+    main = MainWindow(data, info)
+
+    # additions to the hint are needed to prevent the scrollbar from showing up
+    size = main.pagelayout.sizeHint()
+    size.setWidth(size.width() + 100)
+    size.setHeight(size.height() + 50)
+
+    main.resize(size)
+    main.show()
+
+cwd = getcwd()
+
+# parse arguments
+argparser = ArgumentParser(description='Runs the GUI for configuring an athinput file')
+'''argparser.add_argument('-r', '--run',
+                       action='store_true',
+                       help='executes the athena command and plots the tab files on run',
+                       default=False)'''
+argparser.add_argument('-x', '--exe', help='the path to the athena executable')
+argparser.add_argument('file', help='the athinput file to configure')
+args = argparser.parse_args()
+
+athena = args.exe if args.exe else (environ['AGUI'] if 'AGUI' in environ else cwd) + '/athena/bin/athena'
+
+# parse the input files
+with open(args.file) as file:
+    lines = file.readlines()
+
+data, info, _ = parse(lines, silent=True)
+
+app = qw.QApplication(argv)
+
+main = None
+
+build_main(data, info)
+
+try:
+    #print('opening window')
+    exit(app.exec())
+except:
+    #print('closing window')
+    pass
diff --git a/reconfig.sh b/reconfig.sh
new file mode 100755
index 0000000..b6b4706
--- /dev/null
+++ b/reconfig.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+cd ./athena
+./configure.py $1
+make clean
+make -j
\ No newline at end of file
diff --git a/requirements.apt b/requirements.apt
index 334e111..b559569 100644
--- a/requirements.apt
+++ b/requirements.apt
@@ -1,3 +1,5 @@
+# for ubuntu:      sudo apt install $(grep -v ^# requirements.apt)
 libgtk-3-dev
 pyqt5-dev-tools
 python-is-python3
+cmake
diff --git a/requirements.brew b/requirements.brew
new file mode 100644
index 0000000..29da4ad
--- /dev/null
+++ b/requirements.brew
@@ -0,0 +1,3 @@
+#  brew install $(grep -v ^# requirements.brew)
+#
+cmake
diff --git a/requirements.dnf b/requirements.dnf
new file mode 100644
index 0000000..56dadc3
--- /dev/null
+++ b/requirements.dnf
@@ -0,0 +1 @@
+#  for redhat systems that use dnf
diff --git a/requirements.txt b/requirements.txt
index 6be76d8..747e166 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,6 @@
-# for python
+# for python:   pip install -r requirements.txt
+numpy
+matplotlib>=3.7.0
 PySimpleGUI
+PySimpleGUIQt
 gooey
diff --git a/script.py b/script.py
new file mode 100755
index 0000000..eb50950
--- /dev/null
+++ b/script.py
@@ -0,0 +1,35 @@
+#! /usr/bin/env python
+from re import match
+from aparser import parse_generic as parse
+import json
+
+file = open('inputs.txt', 'r')
+
+line = file.readline()
+
+dict = {}
+
+while line:
+    m = match('./athena/inputs/[^/]+/athinput+', line)
+    if m:
+        #print(line)
+        clean_line = line.split()[0]
+        _, info, _ = parse(clean_line)
+        try:
+            dict[info['problem']] = clean_line
+            #print(info['problem'])
+        except:
+            dict[match('.+athinput\.(.+)', clean_line).group(1)] = clean_line
+            #print(match('.+athinput\.(.+)', clean_line).group(1))
+        #print()
+
+    line = file.readline()
+
+# Serializing json
+json_object = json.dumps(dict, indent=3)
+ 
+# Writing to sample.json
+with open("athena_problems.json", "w") as outfile:
+    outfile.write(json_object)
+
+file.close()
\ No newline at end of file
diff --git a/test.athinput b/test.athinput
new file mode 100644
index 0000000..447ea9b
--- /dev/null
+++ b/test.athinput
@@ -0,0 +1,85 @@
+# AthenaXXX input file for HYDRO linear wave tests
+
+<comment>
+problem   = hydro linear waves
+reference = Stone et al, ApJS 178, 137 (2008), sect 8.1
+
+<job>
+basename  = LinWave    # problem ID: basename of output filenames
+
+<mesh>
+nghost    = 2          # Number of ghost cells
+nx1       = 64         # Number of zones in X1-direction    #> SCALE 16:512:16
+x1min     = 0.0        # minimum value of X1
+x1max     = 3.0        # maximum value of X1
+ix1_bc    = periodic   # inner-X1 boundary flag
+ox1_bc    = periodic   # outer-X1 boundary flag
+
+nx2       = 32         # Number of zones in X2-direction    #> RADIO 1,16,32,64,128,256
+x2min     = 0.0        # minimum value of X2
+x2max     = 1.5        # maximum value of X2
+ix2_bc    = periodic   # inner-X2 boundary flag
+ox2_bc    = periodic   # outer-X2 boundary flag
+
+nx3       = 32         # Number of zones in X3-direction    #> RADIO 1,16,32,64,128,256
+x3min     = 0.0        # minimum value of X3
+x3max     = 1.5        # maximum value of X3
+ix3_bc    = periodic   # inner-X3 boundary flag
+ox3_bc    = periodic   # outer-X3 boundary flag
+
+<meshblock>
+nx1       = 64         # Number of cells in each MeshBlock, X1-dir
+nx2       = 32         # Number of cells in each MeshBlock, X2-dir
+nx3       = 32         # Number of cells in each MeshBlock, X3-dir
+
+<time>
+evolution  = dynamic   # dynamic/kinematic/static
+integrator = rk2       # time integration algorithm
+cfl_number = 0.3       # The Courant, Friedrichs, & Lewy (CFL) Number   #> SCALE 0:1.2:0.1
+nlim       = -1        # cycle limit (no limit if <0)
+tlim       = 5.0       # time limit                                     #> SCALE 1:100:1
+ndiag      = 1         # cycles between diagostic output
+
+<hydro>
+eos         = ideal    # EOS type
+reconstruct = plm      # spatial reconstruction method
+rsolver     = llf      # Riemann-solver to be used
+gamma       = 1.66666666667   # gamma = C_p/C_v
+
+<problem>
+pgen_name = linear_wave # problem generator name
+wave_flag = 0           # Wave family number ([0-4] for adiabatic hydro, [0-6] for MHD)
+amp       = 1.0e-3      # Wave Amplitude
+vflow     = 0.0         # background flow velocity
+along_x1  = false       # set to 'true' for wave along x1-axis
+along_x2  = false       # set to 'true' for wave along x2-axis
+along_x3  = false       # set to 'true' for wave along x3-axis
+
+<output1>
+file_type   = tab       # Tabular data dump
+variable    = hydro_w   # variables to be output
+data_format = %12.5e    # Optional data format string
+dt          = 0.05      # time increment between outputs
+slice_x2    = 1.0       # slice in x2
+slice_x3    = 1.0       # slice in x3
+ghost_zones = false     # switch to output ghost cells
+
+<output2>
+file_type   = vtk       # legacy VTK output
+variable    = hydro_w   # variables to be output
+dt          = 0.05      # time increment between outputs
+ghost_zones = false     # switch to output ghost cells
+
+<output3>
+file_type   = hst       # history data dump
+data_format = %12.5e    # Optional data format string
+dt          = 0.1       # time increment between outputs
+
+<test>
+input_field = 3.14     # test input button field #> ENTRY
+check_field = op1,op3  # test check button field #> CHECK op1,op2,op3,op4,op5
+in_file_field = ~/in.txt     # test input file field #> IFILE
+out_file_field = ~/out.txt   # test output file field #> OFILE
+in_dir_field = ~/     # test input dir field #> IDIR
+out_dir_field = ~/   # test output dir field #> ODIR
+nx1       = 64         # test slider    #> SCALE 1:100:0.1
\ No newline at end of file
diff --git a/write_problems.py b/write_problems.py
new file mode 100755
index 0000000..5f59f65
--- /dev/null
+++ b/write_problems.py
@@ -0,0 +1,49 @@
+#! /usr/bin/env python
+import sys
+from re import match
+from aparser import parse_generic as parse
+import json
+
+ofile ="athena_problems.json"
+
+if len(sys.argv) > 1:
+    ifile = sys.argv[1]
+else:
+    ifile = 'inputs.txt'
+    
+file = open(ifile, 'r')
+print("input: ",ifile)
+
+line = file.readline()
+
+dict = {}
+athena = last = None
+while line:
+    m = match('./([^/]+)/', line)
+    if m:
+        info = None
+        last = athena
+        athena = m.group(1)
+        clean_line = line.split()[0]
+        problem = clean_line.split('/')[-1].split('.')[0 if athena == 'athenak' else 1]
+        try:
+            _, info, _ = parse(clean_line, True)
+        except:
+            pass
+        if athena != last:
+            dict[athena] = {}
+        try:
+            dict[athena][info['problem']] = clean_line
+        except:
+            dict[athena][problem] = clean_line
+    line = file.readline()
+
+# Serializing json
+json_object = json.dumps(dict, indent=3)
+ 
+# Writing to sample.json
+with open(ofile, "w") as outfile:
+    outfile.write(json_object)
+
+file.close()
+print("output:",ofile)
diff --git a/z1.sh b/z1.sh
index c571f43..2fd51f2 100755
--- a/z1.sh
+++ b/z1.sh
@@ -1,5 +1,14 @@
 #!/bin/sh
+#
+#   zenity:  see also https://help.gnome.org/users/zenity/stable/
+#
 
-FILE=`zenity --file-selection --title="Select a File" --filename=athinput.linear_wave1d`
+FILE=`zenity --file-selection --title="Select an athinput" --filename=athinput.linear_wave1d`
 
-echo $FILE
+if [  $? = 0 ]; then
+    echo $FILE
+elif [ $? -gt 0 ]; then
+    echo Cancel
+else
+    echo Bad too
+fi