diff --git a/.github/workflows/build_docs.yml b/.github/workflows/build_docs.yml
new file mode 100644
index 00000000..d0dcb9dc
--- /dev/null
+++ b/.github/workflows/build_docs.yml
@@ -0,0 +1,55 @@
+# workflow to build and deploy FORD docs for FTorch
+
+name: BuildDocs
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the "main" branch
+  push:
+    branches: [ "main"]
+  pull_request:
+    branches: [ "main" ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Workflow run - one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build-docs"
+  build-docs:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install ford
+
+      - name: Build docs with FORD
+        run: ford FTorch.md
+
+      - name: Test docs build
+        if: github.ref != 'refs/heads/main'
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+          branch: docs-test # The branch the action should deploy to.
+          folder: doc      # The folder the action should deploy.
+          dry-run: true    # Don't actually push to pages, just test if we can
+
+      - name: Deploy Documentation for main
+        if: github.ref == 'refs/heads/main'
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+          branch: gh-pages # The branch the action should deploy to.
+          folder: doc      # The folder the action should deploy.
diff --git a/.gitignore b/.gitignore
index a20ace75..870daca0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
+# Documentation files
+/doc/*
+
 # Prerequisites
 *.d
 
diff --git a/FTorch.md b/FTorch.md
new file mode 100644
index 00000000..a562ee2a
--- /dev/null
+++ b/FTorch.md
@@ -0,0 +1,76 @@
+---
+project: FTorch
+summary: A library for coupling (Py)Torch machine learning models to Fortran
+author: ICCS Cambridge
+license: mit
+github: https://github.com/Cambridge-ICCS
+project_github: https://github.com/Cambridge-ICCS/FTorch
+page_dir: pages
+src_dir: ./src
+         ./utils
+output_dir: ./doc
+exclude_dir: **/build*
+extra_filetypes: c   //
+                 cpp //
+                 h //
+                 py  #
+sort: alpha
+source: true
+graph: true
+externalize: true
+md_extensions: markdown.extensions.toc
+               markdown.extensions.tables
+               markdown.extensions.fenced_code
+---
+
+--------------------
+
+[TOC]
+
+Brief description
+-----------------
+
+It is desirable to be able to run machine learning (ML) models directly in Fortran.
+ML models are often trained in some other language (say, Python) using a popular frameworks (say, PyTorch) and saved.
+We want to run inference on this model without having to call a Python executable.
+To achieve this we use the existing Torch C++ interface, libtorch.
+
+FTorch provides a library enabling a user to directly couple their PyTorch models to Fortran code.
+There are also installation instructions for the library and examples of performing coupling.
+
+We support running on both CPU and GPU, and have tested the library on UNIX and Windows based operating systems
+
+Presentations
+-------------
+
+The following presentations contain information about FTorch:
+
+* Reducing the overheads for coupling PyTorch machine learning models to Fortran\
+  ML & DL Seminars, LSCE, IPSL, Paris - November 2023\
+  [Slides](IPSL_FTorch/IPSL_FTorch.html) - [Recording](https://www.youtube.com/watch?v=-NJGuV6Rz6U)
+* Reducing the Overhead of Coupled Machine Learning Models between Python and Fortran\
+  RSECon23, Swansea - September 2023\
+  [Slides](https://jackatkinson.net/slides/RSECon23/RSECon23.html) - [Recording](https://www.youtube.com/watch?v=Ei6H_BoQ7g4&list=PL27mQJy8eDHmibt_aL3M68x-4gnXpxvZP&index=33)
+
+License
+-------
+
+The FTorch source code, related files and documentation are
+distributed under an [MIT License which can be viewed here](page/LICENSE.html).
+
+
+Projects using FTorch
+---------------------
+
+The following projects make use of FTorch.  
+If you use our library in your work please let us know.
+
+* [M2LInES CAM-ML](https://github.com/m2lines/CAM-ML)\
+  Using FTorch to couple a neural net parameterisation of convection to the CAM
+  atmospheric model in CESM.
+* [DataWave CAM-GW](https://github.com/DataWaveProject/CAM/)\
+  Using FTorch to couple neural net parameterisations of gravity waves to the CAM
+  atmospheric model in CESM.
+* [MiMA Machine Learning](https://github.com/DataWaveProject/MiMA-machine-learning)\
+  Using FTorch to couple a neural net parameterisation of gravity waves to the MiMA
+  atmospheric model.
diff --git a/README.md b/README.md
index 69df0dcb..efb52443 100644
--- a/README.md
+++ b/README.md
@@ -7,11 +7,15 @@
 This repository contains code, utilities, and examples for directly calling PyTorch ML
 models from Fortran.
 
+For full API and user documentation please see the
+[online documentation](https://cambridge-iccs.github.io/FTorch/) which is 
+significantly more detailed than this README.
 
 ## Contents
 - [Description](#description)
 - [Installation](#installation)
 - [Usage](#usage)
+- [GPU Support](#gpu-support)
 - [Examples](#examples)
 - [License](#license)
 - [Contributions](#contributions)
@@ -21,14 +25,41 @@ models from Fortran.
 ## Description
 
 It is desirable to be able to run machine learning (ML) models directly in Fortran.
-Such models are often trained in some other language (say Python) using popular frameworks (say PyTorch) and saved.
+Such models are often trained in some other language (say Python) using popular
+frameworks (say PyTorch) and saved.
 We want to run inference on this model without having to call a Python executable.
 To achieve this we use the existing Torch C++ interface.
 
-This project provides a library enabling a user to directly couple their PyTorch models to Fortran code.
-We provide installation instructions for the library as well as instructions and examples for performing coupling.
+This project provides a library enabling a user to directly couple their PyTorch
+models to Fortran code.
+We provide installation instructions for the library as well as instructions and
+examples for performing coupling.
 
-Project status: This project is currently in pre-release with documentation and code being prepared for a first release.
+```fortran
+use ftorch
+...
+type(torch_module) :: model
+type(torch_tensor), dimension(n_inputs) :: model_input_arr
+type(torch_tensor) :: model_output
+...
+model = torch_module_load("/my/saved/TorchScript/model.pt")
+model_input_arr(1) = torch_tensor_from_array(input_fortran, in_layout, torch_kCPU)
+model_output = torch_tensor_from_array(output_fortran, out_layout, torch_kCPU)
+
+call torch_module_forward(model, model_input_arr, n_inputs, model_output)
+```
+
+The following presentations provide an introduction and overview of _FTorch_:
+
+* Reducing the overheads for coupling PyTorch machine learning models to Fortran\
+  ML & DL Seminars, LSCE, IPSL, Paris - November 2023\
+  [Slides](IPSL_FTorch/IPSL_FTorch.html) - [Recording](https://www.youtube.com/watch?v=-NJGuV6Rz6U)
+* Reducing the Overhead of Coupled Machine Learning Models between Python and Fortran\
+  RSECon23, Swansea - September 2023\
+  [Slides](https://jackatkinson.net/slides/RSECon23/RSECon23.html) - [Recording](https://www.youtube.com/watch?v=Ei6H_BoQ7g4&list=PL27mQJy8eDHmibt_aL3M68x-4gnXpxvZP&index=33)
+
+Project status: This project is currently in pre-release with documentation and code
+being prepared for a first release.
 As such breaking changes may be made.
 If you are interested in using this library please get in touch.
 
@@ -48,45 +79,46 @@ To install the library requires the following to be installed on the system:
 
 #### Windows Support
 
-If building in a windows environment then you can either:
-
-1) Use [Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/) (WSL)  
-   In this case the build process is the same as for Linux environment.
-2) Use Visual Studio and the Intel Fortran Compiler  
-   In this case you must install [Visual Studio](https://visualstudio.microsoft.com/) followed by [Intel OneAPI Base and HPC toolkit](https://www.intel.com/content/www/us/en/developer/tools/oneapi/base-toolkit-download.html) (ensure that the Intel Fortran compiler and VS integration is selected in the latter). 
-
+If building in a Windows environment then you can either use
+[Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/) (WSL)
+or Visual Studio and the Intel Fortran Compiler.
+For full details on the process see the
+[online Windows documentation](https://cambridge-iccs.github.io/FTorch/page/troubleshooting.html#windows).\
 Note that libTorch is not supported for the GNU Fortran compiler with MinGW.
 
 #### Apple Silicon Support
 
-At the time of writing, libtorch is currently only officially available for x86 architectures (according to https://pytorch.org/). However, the version of PyTorch provided by `pip install` provides an ARM binary for libtorch which works on Apple Silicon. Therefore you should `pip install` PyTorch in this situation and follow the guidance below on locating Torch for cmake.
+At the time of writing, libtorch is only officially available for x86 architectures
+(according to https://pytorch.org/). However, the version of PyTorch provided by
+`pip install torch` uses an ARM binary for libtorch which works on Apple Silicon.
 
 ### Library installation
 
+For detailed installation instructions please see the
+[online installation documentation](https://cambridge-iccs.github.io/FTorch/page/cmake.html).
+
 To build and install the library:
 
 1. Navigate to the location in which you wish to install the source and run:  
-    ```bash
+    ```
     git clone git@github.com:Cambridge-ICCS/FTorch.git
     ```
     to clone via ssh, or  
-    ```bash
+    ```
     git clone https://github.com/Cambridge-ICCS/FTorch.git
     ```
     to clone via https.  
-2. Navigate into the library directory by running:  
-    ```bash
+2. Navigate to the source directory by running:  
+    ```
     cd FTorch/src/
     ```
-3. Create a `build` directory and execute cmake from within it using the relevant options (see below):  
-    ```bash
+3. Build the library using CMake with the relevant options from the table below:  
+    ```
     mkdir build
     cd build
     cmake .. -DCMAKE_BUILD_TYPE=Release
     ```
-    If building on Windows you will need to add `-G "NMake Makefiles"` to the `cmake` command. Also you will need to load the
-    intel fortran compilers using `setvars.bat` ([see Intel docs](https://www.intel.com/content/www/us/en/docs/oneapi/programming-guide/2023-2/use-the-setvars-script-with-windows.html)) which is found in the Intel compiler install directory.
-    
+
     The following table of CMake options are available to be passed as arguments to `cmake` through `-D<Option>=<Value>`.  
     It is likely that you will need to provide at least `CMAKE_PREFIX_PATH`.  
     | Option                                                                                            | Value                        | Description                                                   |
@@ -109,11 +141,11 @@ To build and install the library:
 		  You can find the location of your torch install by importing torch from your python environment (`import torch`) and running `print(torch.__file__)`_
 	  
 4. Make and install the library to the desired location with either:
-	```bash
+	```
     cmake --build . --target install
     ```
     or, if you want to separate these steps:
-    ```bash
+    ```
     cmake --build .
     cmake --install .
     ```
@@ -121,7 +153,7 @@ To build and install the library:
     Note: If you are using cmake<3.15 then you will need to build and install separately
     using the make system specific commands.
     For example, if using `make` on UNIX this would be:
-    ```bash
+    ```
     make
     make install
     ```
@@ -142,140 +174,28 @@ In order to use FTorch users will typically need to follow these steps:
 2. Write Fortran using the FTorch bindings to use the model from within Fortran.
 3. Build and compile the code, linking against the FTorch library
 
+These steps are described in more detail in the
+[online documentation](https://cambridge-iccs.github.io/FTorch/page/examples.html#overview-of-the-interfacing-process)
 
-### 1. Saving the model as TorchScript
-
-The trained PyTorch model needs to be exported to [TorchScript](https://pytorch.org/docs/stable/jit.html).
-This can be done from within your code using the [`jit.script`](https://pytorch.org/docs/stable/generated/torch.jit.script.html#torch.jit.script) or [`jit.trace`](https://pytorch.org/docs/stable/generated/torch.jit.trace.html#torch.jit.trace) functionalities from within python.
-
-If you are not familiar with these we provide a tool [`pt2ts.py`](utils/pt2ts.py) as part of this distribution which contains an easily adaptable script to save your PyTorch model as TorchScript.
-
-
-### 2. Using the model from Fortran
-
-To use the trained Torch model from within Fortran we need to import the `ftorch` module and use the binding routines to load the model, convert the data, and run inference.
 
-A very simple example is given below.
-For more detailed documentation please consult the API documentation, source code, and examples.
+## GPU Support
 
-This minimal snippet loads a saved Torch model, creates an input consisting of a `10x10` matrix of ones, and runs the model to infer output.  
-This is illustrative only, and we recommend following the [examples](examples/) before writing your own code to explore more features.
+To run on GPU requires a CUDA-compatible installation of libtorch and two main
+adaptations to the code:
 
-```fortran
-! Import library for interfacing with PyTorch
-use ftorch
-
-implicit none
-
-! Generate an object to hold the Torch model
-type(torch_module) :: model
-
-! Set up types of input and output data
-integer, parameter :: n_inputs = 1
-type(torch_tensor), dimension(n_inputs) :: model_input_arr
-type(torch_tensor) :: model_output
-
-! Set up the model input and output as Fortran arrays
-real, dimension(10,10), target  :: input
-real, dimension(5), target   :: output
-
-! Set up number of dimensions of input tensor and axis order
-integer, parameter :: in_dims = 2
-integer :: in_layout(in_dims) = [1,2]
-integer, parameter :: out_dims = 1
-integer :: out_layout(out_dims) = [1]
-
-! Initialise the Torch model to be used
-model = torch_module_load("/path/to/saved/model.pt")
-
-! Initialise the inputs as Fortran array of ones
-input = 1.0
-
-! Wrap Fortran data as no-copy Torch Tensors
-! There may well be some reshaping required depending on the 
-! structure of the model which is not covered here (see examples)
-model_input_arr(1) = torch_tensor_from_array(input, in_layout, torch_kCPU)
-model_output = torch_tensor_from_array(output, out_layout, torch_kCPU)
-
-! Run model and Infer
-! Again, there may be some reshaping required depending on model design
-call torch_module_forward(model, model_input_arr, n_inputs, model_output)
-
-! Write out the result of running the model
-write(*,*) output
-
-! Clean up
-call torch_module_delete(model)
-call torch_tensor_delete(model_input_arr(1))
-call torch_tensor_delete(model_output)
-```
-
-### 3. Build the code
-
-The code now needs to be compiled and linked against our installed library.
-Here we describe how to do this for two build systems, cmake and make.
-
-#### CMake
-If our project were using cmake we would need the following in the `CMakeLists.txt` file to find the FTorch installation and link it to the executable.
-
-This can be done by adding the following to the `CMakeLists.txt` file:
-```CMake
-find_package(FTorch)
-target_link_libraries( <executable> PRIVATE FTorch::ftorch )
-message(STATUS "Building with Fortran PyTorch coupling")
-```
-and using the `-DCMAKE_PREFIX_PATH=</path/to/install/location>` flag when running cmake.  
-_Note: If you used the `CMAKE_INSTALL_PREFIX` argument when
-[building and installing the library](#library-installation) above then you should use
-the same path for `</path/to/install/location>`._
-
-#### Make
-To build with make we need to include the library when compiling and link the executable
-against it.
-
-To compile with make we need add the following compiler flag when compiling files that
-use ftorch:
-```makefile
-FCFLAGS += -I<path/to/install/location>/include/ftorch
-```
-
-When compiling the final executable add the following link flag:
-```makefile
-LDFLAGS += -L<path/to/install/location>/lib -lftorch
-```
-
-You may also need to add the location of the `.so` files to your `LD_LIBRARY_PATH`
-unless installing in a default location:
-```bash
-export LD_LIBRARY_PATH = $LD_LIBRARY_PATH:<path/to/install/location>/lib
-```
-_Note: depending on your system and architecture `lib` may be `lib64` or something similar._
-
-### 4. Running on GPUs
-
-In order to run a model on GPU, two main changes are required:
-
-1. When saving your TorchScript model, ensure that it is on the GPU. For example, when using [pt2ts.py](utils/pt2ts.py), this can be done by uncommenting the following lines:
-
-```
-device = torch.device('cuda')
-trained_model = trained_model.to(device)
-trained_model.eval()
-trained_model_dummy_input_1 = trained_model_dummy_input_1.to(device)
-trained_model_dummy_input_2 = trained_model_dummy_input_2.to(device)
-```
-
-Note: this also moves the dummy input tensors to the GPU. This is not necessary for saving the model, but the tensors must also be on the GPU to test that the models runs.
-
-
-2. When calling `torch_tensor_from_blob` in Fortran, the device for the input tensor(s), but not the output tensor(s),
-   should be set to `torch_kCUDA`, rather than `torch_kCPU`. This ensures that the inputs are on the same device as the model.
+1. When saving a TorchScript model, ensure that it is on the GPU
+2. When using FTorch in Fortran, set the device for the input
+   tensor(s) to `torch_kCUDA`, rather than `torch_kCPU`.
 
+For detailed guidance about running on GPU please see the
+[online GPU documentation](https://cambridge-iccs.github.io/FTorch/page/gpu.html).
 
 ## Examples
 
 Examples of how to use this library are provided in the [examples directory](examples/).  
-They demonstrate different functionalities and are provided with instructions to modify, build, and run as necessary.
+They demonstrate different functionalities of the code and are provided with
+instructions to modify, build, and run as necessary.
+
 
 ## License
 
@@ -323,9 +243,8 @@ for a full list.
 ## Used by
 The following projects make use of this code or derivatives in some way:
 
+* [M2LInES CAM-ML](https://github.com/m2lines/CAM-ML)
+* [DataWave CAM-GW](https://github.com/DataWaveProject/CAM/)
 * [DataWave - MiMA ML](https://github.com/DataWaveProject/MiMA-machine-learning)
 
 Are we missing anyone? Let us know.
-
-
-
diff --git a/pages/LICENSE.md b/pages/LICENSE.md
new file mode 100644
index 00000000..b13d5207
--- /dev/null
+++ b/pages/LICENSE.md
@@ -0,0 +1,3 @@
+title: FTorch License
+
+{!LICENSE!}
diff --git a/pages/cmake.md b/pages/cmake.md
new file mode 100644
index 00000000..bcd9ab12
--- /dev/null
+++ b/pages/cmake.md
@@ -0,0 +1,143 @@
+title: Installation and Build Process
+
+[TOC]
+
+Installation of FTorch is done by CMake.
+
+This is controlled by the `CMakeLists.txt` file in `src/`.
+
+## Basic instructions
+
+To build the library, first clone it from GitHub to your local machine and then run:
+```
+cd FTorch/src/
+mkdir build
+cd build
+```
+
+Then invoke CMake with the `Release` build option, plus any other options as required
+from the table below in [CMake build options](#cmake-build-options)
+(note: you will likely _need_ to add some of these options to enforce a consistent
+build on your machine):
+```
+cmake .. -DCMAKE_BUILD_TYPE=Release
+```
+
+Finally build and install the library using:
+```
+cmake --build . --target install
+```
+or, if you want to separate these steps:
+```
+cmake --build .
+cmake --install .
+```
+
+> Note: _if you are building on Windows please refer to the
+> [Windows install guidance](page/troubleshooting.html#windows) as the process will
+> likely differ from the UNIX-based stsyems covered here._
+
+## CMake build options
+
+### FTorch Library
+
+It is likely that you will need to provide at least the `CMAKE_PREFIX_PATH` flag.  
+The following CMake flags are available and can be passed as arguments through `-D<Option>=<Value>`:
+
+| Option                                                                                            | Value                        | Description                                                   |
+| ------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------------------|
+| [`CMAKE_Fortran_COMPILER`](https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER.html) | `ifort` / `gfortran`         | Specify a Fortran compiler to build the library with. This should match the Fortran compiler you're using to build the code you are calling this library from.<sup>1</sup>        |
+| [`CMAKE_C_COMPILER`](https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER.html)       | `icc` / `gcc`                | Specify a C compiler to build the library with.<sup>1</sup>                |
+| [`CMAKE_CXX_COMPILER`](https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER.html)     | `icpc` / `g++`               | Specify a C++ compiler to build the library with.<sup>1</sup>              |
+| [`CMAKE_PREFIX_PATH`](https://cmake.org/cmake/help/latest/variable/CMAKE_PREFIX_PATH.html)        | `</path/to/libTorch/>`       | Location of Torch installation<sup>2</sup>                    |
+| [`CMAKE_INSTALL_PREFIX`](https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX.html)  | `</path/to/install/lib/at/>` | Location at which the library files should be installed. By default this is `/usr/local` |
+| [`CMAKE_BUILD_TYPE`](https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html)          | `Release` / `Debug`          | Specifies build type. The default is `Debug`, use `Release` for production code|
+| `ENABLE_CUDA`                                                                                     | `TRUE` / `FALSE`             | Specifies whether to check for and enable CUDA<sup>3</sup> |
+
+
+
+> <sup>1</sup> _On Windows this may need to be the full path to the compiler if CMake
+> cannot locate it by default._
+> <sup>2</sup> _The path to the Torch installation needs to allow CMake to locate the relevant Torch CMake files.  
+>       If Torch has been [installed as libtorch](https://pytorch.org/cppdocs/installing.html)
+>       then this should be the absolute path to the unzipped libtorch distribution.
+>       If Torch has been installed as PyTorch in a python [venv (virtual environment)](https://docs.python.org/3/library/venv.html),
+>       e.g. with `pip install torch`, then this should be `</path/to/venv/>lib/python<3.xx>/site-packages/torch/`._
+> 
+> <sup>3</sup> _This is often overridden by PyTorch. When installing with pip, the `index-url` flag can be used to ensure a CPU or GPU only version is installed, e.g.
+>       `pip install torch --index-url https://download.pytorch.org/whl/cpu`
+>       or
+>       `pip install torch --index-url https://download.pytorch.org/whl/cu118`
+>       (for CUDA 11.8). URLs for alternative versions can be found [here](https://pytorch.org/get-started/locally/)._
+
+For example, to build on a unix system using the gnu compilers and install to `$HOME/FTorchbin/`
+we would need to run:
+```
+cmake .. \
+-DCMAKE_BUILD_TYPE=Release \
+-DCMAKE_Fortran_COMPILER=gfortran \
+-DCMAKE_C_COMPILER=gcc \
+-DCMAKE_CXX_COMPILER=g++ \
+-DCMAKE_PREFIX_PATH=/path/to/venv/lib/python3.xx/site-packages/torch/ \
+-DCMAKE_INSTALL_PREFIX=~/FTorchbin
+```
+
+Once this completes you should be able to generate the code and install using:
+```
+cmake --build . --target install
+```
+
+> Note: _If you are using CMake < 3.15 then you will need to build and install separately
+> using the make system specific commands._
+For example, if using `make` on UNIX this would be:
+```
+make
+make install
+```
+
+Installation will place the following directories at the install location:
+
+* `CMAKE_INSTALL_PREFIX/include/` - contains C header and Fortran mod files
+* `CMAKE_INSTALL_PREFIX/lib64/` - contains `cmake` directory and `.so` files
+
+> Note: _In a Windows environment this will require administrator privileges for the default install location._
+
+
+### Other projects using CMake
+
+We generally advise building projects that make use of FTorch with CMake where possible.
+
+If doing this you need to include the following in the `CMakeLists.txt` file to
+find the FTorch installation and link it to the executable.
+
+```CMake
+find_package(FTorch)
+target_link_libraries( <executable> PRIVATE FTorch::ftorch )
+message(STATUS "Building with Fortran PyTorch coupling")
+```
+
+You will then need to use the `-DFTorch_DIR=</path/to/install/location>` flag
+when running CMake.
+
+
+## Building other projects with make
+
+To build a project with make you need to include the FTorch library when compiling
+and link the executable against it.
+
+To compile with make add the following compiler flag when compiling files that
+use ftorch:
+```
+FCFLAGS += -I<path/to/install/location>/include/ftorch
+```
+
+When compiling the final executable add the following link flag:
+```
+LDFLAGS += -L<path/to/install/location>/lib64 -lftorch
+```
+
+You may also need to add the location of the `.so` files to your `LD_LIBRARY_PATH`
+unless installing in a default location:
+```
+export LD_LIBRARY_PATH = $LD_LIBRARY_PATH:<path/to/installation>/lib64
+```
diff --git a/pages/examples.md b/pages/examples.md
new file mode 100644
index 00000000..963d6374
--- /dev/null
+++ b/pages/examples.md
@@ -0,0 +1,170 @@
+title: Examples
+
+[TOC]
+
+## Generic example
+
+### Overview of the interfacing process
+
+In order to use FTorch users will typically need to follow these steps:
+
+1. Save a PyTorch model as [TorchScript](https://pytorch.org/docs/stable/jit.html).
+2. Write Fortran using the FTorch bindings to use the model from within Fortran.
+3. Build and compile the code, linking against the FTorch library
+
+These are outlined in detail below.
+
+#### 1. Saving the model as TorchScript
+
+The trained PyTorch model needs to be exported to
+[TorchScript](https://pytorch.org/docs/stable/jit.html).
+This can be done from within your code using the
+[`jit.script`](https://pytorch.org/docs/stable/generated/torch.jit.script.html#torch.jit.script)
+or
+[`jit.trace`](https://pytorch.org/docs/stable/generated/torch.jit.trace.html#torch.jit.trace)
+functionalities from within python.
+
+If you are not familiar with these we provide a tool
+[`pt2ts.py`](https://github.com/Cambridge-ICCS/FTorch/blob/main/utils/pt2ts.py)
+as part of this distribution which contains an easily adaptable script to save your
+PyTorch model as TorchScript.
+
+#### 2. Using the model from Fortran
+
+To use the trained Torch model from within Fortran we need to import the `ftorch`
+module and use the binding routines to load the model, convert the data,
+and run inference.
+A very simple example is given below.
+
+This minimal snippet loads a saved Torch model, creates an input consisting of a
+`10x10` matrix of ones, and runs the model to infer output.  
+This is for illustrative purposes only, and we recommend following the
+[examples](https://github.com/Cambridge-ICCS/FTorch/tree/main/examples)
+before writing your own code to fully explore the features.
+
+```fortran
+! Import library for interfacing with PyTorch
+use ftorch
+
+implicit none
+
+! Generate an object to hold the Torch model
+type(torch_module) :: model
+
+! Set up types of input and output data
+integer, parameter :: n_inputs = 1
+type(torch_tensor), dimension(n_inputs) :: model_input_arr
+type(torch_tensor) :: model_output
+
+! Set up the model input and output as Fortran arrays
+real, dimension(10,10), target  :: input
+real, dimension(5), target   :: output
+
+! Set up number of dimensions of input tensor and axis order
+integer, parameter :: in_dims = 2
+integer :: in_layout(in_dims) = [1,2]
+integer, parameter :: out_dims = 1
+integer :: out_layout(out_dims) = [1]
+
+! Initialise the Torch model to be used
+model = torch_module_load("/path/to/saved/model.pt")
+
+! Initialise the inputs as Fortran array of ones
+input = 1.0
+
+! Wrap Fortran data as no-copy Torch Tensors
+! There may well be some reshaping required depending on the 
+! structure of the model which is not covered here (see examples)
+model_input_arr(1) = torch_tensor_from_array(input, in_layout, torch_kCPU)
+model_output = torch_tensor_from_array(output, out_layout, torch_kCPU)
+
+! Run model and Infer
+! Again, there may be some reshaping required depending on model design
+call torch_module_forward(model, model_input_arr, n_inputs, model_output)
+
+! Write out the result of running the model
+write(*,*) output
+
+! Clean up
+call torch_module_delete(model)
+call torch_tensor_delete(model_input_arr(1))
+call torch_tensor_delete(model_output)
+```
+
+#### 3. Build the code
+
+The code now needs to be compiled and linked against our installed library.
+Here we describe how to do this for two build systems, CMake and make.
+
+##### CMake
+If our project were using CMake we would need the following in the `CMakeLists.txt`
+file to find the FTorch installation and link it to the executable.
+
+This can be done by adding the following to the `CMakeLists.txt` file:
+```CMake
+find_package(FTorch)
+target_link_libraries( <executable> PRIVATE FTorch::ftorch )
+message(STATUS "Building with Fortran PyTorch coupling")
+```
+and using the `-DCMAKE_PREFIX_PATH=</path/to/install/location>` flag when running CMake.  
+
+> Note: _If you used the `CMAKE_INSTALL_PREFIX` argument when
+> [building and installing the library](https://cambridge-iccs.github.io/FTorch/page/cmake.html)
+> then you should use the same path for `</path/to/install/location>`._
+
+##### Make
+To build with make we need to include the library when compiling and link the executable
+against it.
+
+To compile with make we need add the following compiler flag when compiling files that
+use FTorch:
+```
+FCFLAGS += -I<path/to/install/location>/include/ftorch
+```
+
+When compiling the final executable add the following link flag:
+```
+LDFLAGS += -L<path/to/install/location>/lib -lftorch
+```
+
+You may also need to add the location of the `.so` files to your `LD_LIBRARY_PATH`
+unless installing in a default location:
+```
+export LD_LIBRARY_PATH = $LD_LIBRARY_PATH:<path/to/install/location>/lib
+```
+> Note: _Depending on your system and architecture `lib` may be `lib64` or something similar._
+
+### Running on GPUs
+
+In order to run a model on GPU, two main changes to the above process are required:
+
+1. When saving your TorchScript model, ensure that it is on the GPU.
+2. When calling `torch_tensor_from_array` in Fortran, the device for the input
+   tensor(s) should be set to `torch_kCUDA`, rather than `torch_kCPU`.
+
+For more information refer to the [GPU Documentation](gpu.html)
+
+## Worked examples
+
+The repository comes with a number of documented
+[worked examples](https://github.com/Cambridge-ICCS/FTorch/tree/main/examples).
+
+These are designed to introduce users to FTorch and how to use the various features.
+
+#### 1) SimpleNet
+
+[This worked example](https://github.com/Cambridge-ICCS/FTorch/tree/main/examples/1_SimpleNet)
+provides a simple but complete demonstration of how to use the library.
+It uses simple PyTorch 'net' that takes an input vector of length 5 and applies a single
+Linear layer to multiply it by 2.
+The aim is to demonstrate the most basic features of coupling before worrying about
+more complex issues that are covered in later examples.
+
+#### 2) Resnet
+
+[This worked example](https://github.com/Cambridge-ICCS/FTorch/tree/main/examples/2_ResNet18)
+provides a more realistic demonstration of how to use the library,
+using ResNet-18 to classify an image.
+As the input to this model is four-dimensional (batch size, colour, x, y),
+care must be taken dealing with the data array in Python and Fortran.
+See [when to transpose arrays](transposing.html) for more details.
diff --git a/pages/gpu.md b/pages/gpu.md
new file mode 100644
index 00000000..f1b9ba5c
--- /dev/null
+++ b/pages/gpu.md
@@ -0,0 +1,31 @@
+title: GPU Support
+
+[TOC]
+
+## GPU Support
+
+In order to run a model on GPU, two main changes are required:
+
+1) When saving your TorchScript model, ensure that it is on the GPU.
+For example, when using
+[`pt2ts.py`](https://github.com/Cambridge-ICCS/FTorch/blob/main/utils/pt2ts.py),
+this can be done by uncommenting the following lines:
+
+```python
+device = torch.device("cuda")
+trained_model = trained_model.to(device)
+trained_model.eval()
+trained_model_dummy_input_1 = trained_model_dummy_input_1.to(device)
+trained_model_dummy_input_2 = trained_model_dummy_input_2.to(device)
+```
+
+> Note: _This code also moves the dummy input tensors to the GPU.
+> Whilst not necessary for saving the model, but the tensors must also be on the GPU
+> to test that the models runs._
+
+2) When calling `torch_tensor_from_array` in Fortran, the device for the input
+   tensor(s) should be set to `torch_kCUDA`, rather than `torch_kCPU`.
+   This ensures that the inputs are on the same device as the model.
+
+> Note: _You do **not** need to change the device for the output tensors as we
+> want them to be on the CPU for subsequent use in Fortran._
diff --git a/pages/index.md b/pages/index.md
new file mode 100644
index 00000000..8d9e6bc3
--- /dev/null
+++ b/pages/index.md
@@ -0,0 +1,11 @@
+title: User Guide
+
+Please see the menu on the left for detailed documentation and user guides for using
+_FTorch_.
+
+[TOC]
+
+## Useful resources
+
+* [The libtorch API](https://pytorch.org/cppdocs/api/library_root.html)
+
diff --git a/pages/transposing.md b/pages/transposing.md
new file mode 100644
index 00000000..25896aaa
--- /dev/null
+++ b/pages/transposing.md
@@ -0,0 +1,179 @@
+title: When to transpose data
+
+Transposition of data between Fortran and C can lead to a lot of unneccessary confusion.
+The FTorch library looks after this for you with the
+[`torch_tensor_from_array()`](doc/interface/torch_tensor_from_array.html) function which
+allows you to index a tensor in Torch in **exactly the same way** as you would in Fortran.
+
+If you wish to do something different to this then there are more complex functions
+available and we describe here how and when to use them.
+
+[TOC]
+
+## Introduction - row- vs. column-major
+
+Astute users will note that Fortran is a
+[column-major](https://en.wikipedia.org/wiki/Row-_and_column-major_order)
+language whilst C, C++, and Python are 
+[row-major](https://en.wikipedia.org/wiki/Row-_and_column-major_order).
+
+This means that the matrix/tensor in Fortran
+$$
+\begin{pmatrix}
+a_{11} & a_{12} \\
+a_{21} & a_{22}
+\end{pmatrix}
+=
+\begin{pmatrix}
+a & b \\
+c & d
+\end{pmatrix}
+$$
+will appear in
+[contiguous memory](https://en.wikipedia.org/wiki/Memory_management_(operating_systems))
+on the computer as 
+$$
+\begin{pmatrix}
+a_{11} & a_{21} & a_{12} & a_{22}
+\end{pmatrix}
+=
+\begin{pmatrix}
+a & c & b & d
+\end{pmatrix}
+$$
+with the order of elements decided by moving down the columns before progressing in the
+row dimension.  
+In contrast, the same matrix/tensor defined in a row-major language will appear in
+contiguous memory as
+$$
+\begin{pmatrix}
+a_{11} & a_{12} & a_{21} & a_{22}
+\end{pmatrix}
+=
+\begin{pmatrix}
+a & b & c & d
+\end{pmatrix}
+$$
+reading along each row before progressing down the column dimension.
+
+
+## Why does this matter?
+
+This matters for FTorch because a key feature is no-copy memory transfer between Fortran
+and Torch.
+To do this the Fortran data that will be used in Torch is stored in memory and a
+[pointer](https://en.wikipedia.org/wiki/Pointer_(computer_programming)) to the first
+element, \(a\) provided to Torch.
+
+Now, if Torch were to take this block of memory and interpret it as as a 2x2 matrix it
+would be read in as
+$$
+\begin{pmatrix}
+a & c \\
+b & d
+\end{pmatrix}
+$$
+which is the [transpose](https://en.wikipedia.org/wiki/Transpose) of the
+matrix we had in Fortran; likely not what we were expecting!
+
+This means we need to be careful when passing data to make sure that what we read in
+to our Torch net is correct as we expect.
+
+
+## What can we do?
+
+There are a few approaches we can take to address this.  
+The first two of these are listed for conceptual purposes, whilst in practice we
+advise handling this using the `torch_tensor_from_array` function described in 
+[3) below](#3-use-the-layout-argument-in-torch_tensor_from_array).
+
+#### 1) Transpose before passing
+As seen from the above example, writing out from Fortran and reading directly in to
+Torch results in us recieving the transpose.
+
+Therefore we could transpose out Fortran data immediately before passing it to Torch.
+As a result we will read in to Torch indexed the same as in Fortran pre-transposition.
+
+For arrays of dimension 2 this can be done using the intrinsic
+[`transpose()`](https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gfortran/TRANSPOSE.html)
+function.
+
+For larger arrays we are required to use the
+['reshape()'](https://gcc.gnu.org/onlinedocs/gfortran/RESHAPE.html) intrinsic to swap
+the order of the indices.  
+For example, if we had a 3x4x5 matrix \(A\) we would need to call
+```
+A_to_torch = reshape(A, shape=[5, 4, 3], order=[3, 2, 1])
+```
+which could then be read by Torch as a 3x4x5 tensor.
+
+We would, of course, need to remember to transpose/reshape any output of the model
+as required.
+
+However, the transposition process involves creating a copy of the Fortran data.
+For large matrices/tensors this can become expensive.
+It would be better if we can pass data without having to transpose beforehand.
+
+#### 2) Design nets to use transpose
+Alternatively we could design our net to use
+$$
+\begin{pmatrix}
+a & c \\
+b & d
+\end{pmatrix}
+$$
+as its input tensor meaning we can simply write from Fortran and read to Torch.
+
+However, this requires foresight and may not be intuitive - we would like to be indexing
+data in the same way in both Fortran and Torch.
+Not doing so could leave us open to introducing bugs.
+
+#### 3) Use the `layout` argument in `torch_tensor_from_array`
+
+By far the easiest way to deal with the issue is not to worry about it at all!
+
+As described at the top of this page, by using the
+[torch_tensor_from_array](doc/interface/torch_tensor_from_array.html) function
+we can make use of the `layout` argument.
+This allows us to take data from Fortran and send it to Torch to be indexed in exactly
+the same way by using strided access based on the shape of the array.
+
+It takes the form of an array specifying which order to read the indices in.
+i.e. `[1, 2]` will read `i` then `j`.
+By passing `layout = [1, 2]` the data will be read into the correct indices by
+Torch.
+
+This is achieved by wrapping the `torch_tensor_from_blob` function to automatically
+generate strides assuming that a straightforward conversion between
+row- and column-major is what should happen.
+
+i.e. if the Fortran array `A`
+$$
+\begin{pmatrix}
+a & b \\
+c & d
+\end{pmatrix}
+$$
+is passed as `torch_tensor_from_array(A, [1, 2], torch_device)`
+the resulting Tensor will be read by Torch as 
+$$
+\begin{pmatrix}
+a & b \\
+c & d
+\end{pmatrix}
+$$
+
+> Note: _If, for some reason, we did want a different, transposed layout in Torch we
+> could use `torch_tensor_from_array(A, [2, 1], torch_device)` to get:_
+> $$
+> \begin{pmatrix}
+> a & c \\
+> b & d
+> \end{pmatrix}
+> $$
+
+## Advanced use with `torch_tensor_from_blob`
+
+For more advanced options for manipulating and controlling data access when passing
+between Fortran and Torch see the more powerful but more complex
+[torch_tensor_from_blob function](doc/proc/torch_tensor_from_blob.html)
diff --git a/pages/troubleshooting.md b/pages/troubleshooting.md
new file mode 100644
index 00000000..8cbbccf6
--- /dev/null
+++ b/pages/troubleshooting.md
@@ -0,0 +1,62 @@
+title: Troubleshooting
+
+If you are experiencing problems building or using FTorch please see below for guidance on common problems.
+
+[TOC]
+
+## Windows
+
+If possible we recommend using the [Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/) (WSL) to build the library.
+In this case the build process is the same as for a Linux environment.
+
+If you need to build in native Windows please read the following information:
+
+### Visual Studio
+
+It is possible to build using Visual Studio and the Intel Fortran Compiler  
+In this case you must install 
+
+* [Visual Studio](https://visualstudio.microsoft.com/)
+* [Intel OneAPI Base and HPC toolkit](https://www.intel.com/content/www/us/en/developer/tools/oneapi/base-toolkit-download.html) (ensure that the Intel Fortran compiler and VS integration is selected).
+
+You will then need to load the intel Fortran compilers using `setvars.bat`
+which is found in the Intel compiler install directory (see the 
+[intel docs](https://www.intel.com/content/www/us/en/docs/oneapi/programming-guide/2023-2/use-the-setvars-script-with-windows.html))
+for more details.\
+From CMD this can be done with:
+```
+"C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+```
+
+Finally you will need to add `-G "NMake Makefiles"` to the cmake command in the
+[regular install instructions](doc/page/cmake.html).\
+So the basic command to build from CMD becomes:
+```
+cmake -G "NMake Makefiles" -DCMAKE_PREFIX_PATH="C:\Users\melt\Downloads\libtorch-win-shared-with-deps-2.1.0+cpu\libtorch" -DCMAKE_BUILD_TYPE=Release ..
+cmake --build .
+cmake --install .
+```
+
+If using powershell the setvars and build commands become:
+```
+cmd /k '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'
+cmake -G "NMake Makefiles" -DCMAKE_PREFIX_PATH="C:\Users\melt\Downloads\libtorch-win-shared-with-deps-2.1.0+cpu\libtorch" -DCMAKE_BUILD_TYPE=Release ..
+cmake --build .
+cmake --install .
+```
+
+### MinGW
+
+It may be tempting to build on Windows using MinGW.
+However, [libtorch does not currently support MinGW](https://github.com/pytorch/pytorch/issues/15099).
+Instead please build using Visual Studio and the intel fortran compiler (ifort) as
+detailed in the project README.
+
+## Apple Silicon
+
+At the time of writing, libtorch is currently only officially available for x86
+architectures (according to [pytorch.org](https://pytorch.org/)).
+However, the version of PyTorch provided by pip install provides an ARM binary
+for libtorch which works on Apple Silicon.
+Therefore you should `pip install torch` in this situation and follow the guidance
+on locating Torch within a virtual environment (venv) for CMake.