diff --git a/.buildinfo b/.buildinfo
new file mode 100644
index 000000000000..d9a750f7ebe3
--- /dev/null
+++ b/.buildinfo
@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 844ab0f3b13ed01d931c7a4a151b1efd
+tags: d77d1c0d9ca2f4c8421862c7c5a0d620
diff --git a/.doctrees/community.doctree b/.doctrees/community.doctree
new file mode 100644
index 000000000000..9f38757f81bd
Binary files /dev/null and b/.doctrees/community.doctree differ
diff --git a/.doctrees/community/contributing.doctree b/.doctrees/community/contributing.doctree
new file mode 100644
index 000000000000..8ff070ae1ccf
Binary files /dev/null and b/.doctrees/community/contributing.doctree differ
diff --git a/.doctrees/community/history.doctree b/.doctrees/community/history.doctree
new file mode 100644
index 000000000000..f071130b5e4a
Binary files /dev/null and b/.doctrees/community/history.doctree differ
diff --git a/.doctrees/community/minibooks.doctree b/.doctrees/community/minibooks.doctree
new file mode 100644
index 000000000000..5a9ea1c9bfde
Binary files /dev/null and b/.doctrees/community/minibooks.doctree differ
diff --git a/.doctrees/community/packages.doctree b/.doctrees/community/packages.doctree
new file mode 100644
index 000000000000..a1d9a94adf79
Binary files /dev/null and b/.doctrees/community/packages.doctree differ
diff --git a/.doctrees/compilers.doctree b/.doctrees/compilers.doctree
new file mode 100644
index 000000000000..ca5f9f01c6ec
Binary files /dev/null and b/.doctrees/compilers.doctree differ
diff --git a/.doctrees/environment.pickle b/.doctrees/environment.pickle
new file mode 100644
index 000000000000..68eb7af64ff1
Binary files /dev/null and b/.doctrees/environment.pickle differ
diff --git a/.doctrees/index.doctree b/.doctrees/index.doctree
new file mode 100644
index 000000000000..445949ce8bba
Binary files /dev/null and b/.doctrees/index.doctree differ
diff --git a/.doctrees/learn.doctree b/.doctrees/learn.doctree
new file mode 100644
index 000000000000..46dca8036891
Binary files /dev/null and b/.doctrees/learn.doctree differ
diff --git a/.doctrees/learn/best_practices/allocatable_arrays.doctree b/.doctrees/learn/best_practices/allocatable_arrays.doctree
new file mode 100644
index 000000000000..67b0ab4343ef
Binary files /dev/null and b/.doctrees/learn/best_practices/allocatable_arrays.doctree differ
diff --git a/.doctrees/learn/best_practices/arrays.doctree b/.doctrees/learn/best_practices/arrays.doctree
new file mode 100644
index 000000000000..83087e72a191
Binary files /dev/null and b/.doctrees/learn/best_practices/arrays.doctree differ
diff --git a/.doctrees/learn/best_practices/callbacks.doctree b/.doctrees/learn/best_practices/callbacks.doctree
new file mode 100644
index 000000000000..9cf1284a28e9
Binary files /dev/null and b/.doctrees/learn/best_practices/callbacks.doctree differ
diff --git a/.doctrees/learn/best_practices/element_operations.doctree b/.doctrees/learn/best_practices/element_operations.doctree
new file mode 100644
index 000000000000..5f24a1cbee34
Binary files /dev/null and b/.doctrees/learn/best_practices/element_operations.doctree differ
diff --git a/.doctrees/learn/best_practices/file_io.doctree b/.doctrees/learn/best_practices/file_io.doctree
new file mode 100644
index 000000000000..d7c8978c8c1d
Binary files /dev/null and b/.doctrees/learn/best_practices/file_io.doctree differ
diff --git a/.doctrees/learn/best_practices/floating_point.doctree b/.doctrees/learn/best_practices/floating_point.doctree
new file mode 100644
index 000000000000..727f6650238d
Binary files /dev/null and b/.doctrees/learn/best_practices/floating_point.doctree differ
diff --git a/.doctrees/learn/best_practices/index.doctree b/.doctrees/learn/best_practices/index.doctree
new file mode 100644
index 000000000000..0fc2e4612648
Binary files /dev/null and b/.doctrees/learn/best_practices/index.doctree differ
diff --git a/.doctrees/learn/best_practices/integer_division.doctree b/.doctrees/learn/best_practices/integer_division.doctree
new file mode 100644
index 000000000000..fca00140053d
Binary files /dev/null and b/.doctrees/learn/best_practices/integer_division.doctree differ
diff --git a/.doctrees/learn/best_practices/modules_programs.doctree b/.doctrees/learn/best_practices/modules_programs.doctree
new file mode 100644
index 000000000000..2a33831fcd32
Binary files /dev/null and b/.doctrees/learn/best_practices/modules_programs.doctree differ
diff --git a/.doctrees/learn/best_practices/multidim_arrays.doctree b/.doctrees/learn/best_practices/multidim_arrays.doctree
new file mode 100644
index 000000000000..c09a8175930e
Binary files /dev/null and b/.doctrees/learn/best_practices/multidim_arrays.doctree differ
diff --git a/.doctrees/learn/best_practices/style_guide.doctree b/.doctrees/learn/best_practices/style_guide.doctree
new file mode 100644
index 000000000000..e214ac1bed3a
Binary files /dev/null and b/.doctrees/learn/best_practices/style_guide.doctree differ
diff --git a/.doctrees/learn/best_practices/type_casting.doctree b/.doctrees/learn/best_practices/type_casting.doctree
new file mode 100644
index 000000000000..341ca769ae11
Binary files /dev/null and b/.doctrees/learn/best_practices/type_casting.doctree differ
diff --git a/.doctrees/learn/building_programs/build_tools.doctree b/.doctrees/learn/building_programs/build_tools.doctree
new file mode 100644
index 000000000000..d970224c85ae
Binary files /dev/null and b/.doctrees/learn/building_programs/build_tools.doctree differ
diff --git a/.doctrees/learn/building_programs/compiling_source.doctree b/.doctrees/learn/building_programs/compiling_source.doctree
new file mode 100644
index 000000000000..43bc8f77b48a
Binary files /dev/null and b/.doctrees/learn/building_programs/compiling_source.doctree differ
diff --git a/.doctrees/learn/building_programs/distributing.doctree b/.doctrees/learn/building_programs/distributing.doctree
new file mode 100644
index 000000000000..e736cc89f413
Binary files /dev/null and b/.doctrees/learn/building_programs/distributing.doctree differ
diff --git a/.doctrees/learn/building_programs/include_files.doctree b/.doctrees/learn/building_programs/include_files.doctree
new file mode 100644
index 000000000000..5d1c1113efdf
Binary files /dev/null and b/.doctrees/learn/building_programs/include_files.doctree differ
diff --git a/.doctrees/learn/building_programs/index.doctree b/.doctrees/learn/building_programs/index.doctree
new file mode 100644
index 000000000000..bfdaff3eb690
Binary files /dev/null and b/.doctrees/learn/building_programs/index.doctree differ
diff --git a/.doctrees/learn/building_programs/linking_pieces.doctree b/.doctrees/learn/building_programs/linking_pieces.doctree
new file mode 100644
index 000000000000..a42ab9f6b8fa
Binary files /dev/null and b/.doctrees/learn/building_programs/linking_pieces.doctree differ
diff --git a/.doctrees/learn/building_programs/managing_libraries.doctree b/.doctrees/learn/building_programs/managing_libraries.doctree
new file mode 100644
index 000000000000..eadd22b624f4
Binary files /dev/null and b/.doctrees/learn/building_programs/managing_libraries.doctree differ
diff --git a/.doctrees/learn/building_programs/project_make.doctree b/.doctrees/learn/building_programs/project_make.doctree
new file mode 100644
index 000000000000..6bd69c1813db
Binary files /dev/null and b/.doctrees/learn/building_programs/project_make.doctree differ
diff --git a/.doctrees/learn/building_programs/runtime_libraries.doctree b/.doctrees/learn/building_programs/runtime_libraries.doctree
new file mode 100644
index 000000000000..12472933e8f4
Binary files /dev/null and b/.doctrees/learn/building_programs/runtime_libraries.doctree differ
diff --git a/.doctrees/learn/intrinsics/array.doctree b/.doctrees/learn/intrinsics/array.doctree
new file mode 100644
index 000000000000..2e1fdfe1225f
Binary files /dev/null and b/.doctrees/learn/intrinsics/array.doctree differ
diff --git a/.doctrees/learn/intrinsics/bit.doctree b/.doctrees/learn/intrinsics/bit.doctree
new file mode 100644
index 000000000000..97920f3a9812
Binary files /dev/null and b/.doctrees/learn/intrinsics/bit.doctree differ
diff --git a/.doctrees/learn/intrinsics/cfi.doctree b/.doctrees/learn/intrinsics/cfi.doctree
new file mode 100644
index 000000000000..c7223b2793a7
Binary files /dev/null and b/.doctrees/learn/intrinsics/cfi.doctree differ
diff --git a/.doctrees/learn/intrinsics/character.doctree b/.doctrees/learn/intrinsics/character.doctree
new file mode 100644
index 000000000000..0703b6d98895
Binary files /dev/null and b/.doctrees/learn/intrinsics/character.doctree differ
diff --git a/.doctrees/learn/intrinsics/compiler.doctree b/.doctrees/learn/intrinsics/compiler.doctree
new file mode 100644
index 000000000000..36ff416e4407
Binary files /dev/null and b/.doctrees/learn/intrinsics/compiler.doctree differ
diff --git a/.doctrees/learn/intrinsics/index.doctree b/.doctrees/learn/intrinsics/index.doctree
new file mode 100644
index 000000000000..acac162fcdd8
Binary files /dev/null and b/.doctrees/learn/intrinsics/index.doctree differ
diff --git a/.doctrees/learn/intrinsics/math.doctree b/.doctrees/learn/intrinsics/math.doctree
new file mode 100644
index 000000000000..0f5071704344
Binary files /dev/null and b/.doctrees/learn/intrinsics/math.doctree differ
diff --git a/.doctrees/learn/intrinsics/model.doctree b/.doctrees/learn/intrinsics/model.doctree
new file mode 100644
index 000000000000..d27196247e78
Binary files /dev/null and b/.doctrees/learn/intrinsics/model.doctree differ
diff --git a/.doctrees/learn/intrinsics/numeric.doctree b/.doctrees/learn/intrinsics/numeric.doctree
new file mode 100644
index 000000000000..2583af8f4fd2
Binary files /dev/null and b/.doctrees/learn/intrinsics/numeric.doctree differ
diff --git a/.doctrees/learn/intrinsics/parallel.doctree b/.doctrees/learn/intrinsics/parallel.doctree
new file mode 100644
index 000000000000..e319b9e8b29a
Binary files /dev/null and b/.doctrees/learn/intrinsics/parallel.doctree differ
diff --git a/.doctrees/learn/intrinsics/state.doctree b/.doctrees/learn/intrinsics/state.doctree
new file mode 100644
index 000000000000..381cacf4f4c9
Binary files /dev/null and b/.doctrees/learn/intrinsics/state.doctree differ
diff --git a/.doctrees/learn/intrinsics/system.doctree b/.doctrees/learn/intrinsics/system.doctree
new file mode 100644
index 000000000000..40c6e002064f
Binary files /dev/null and b/.doctrees/learn/intrinsics/system.doctree differ
diff --git a/.doctrees/learn/intrinsics/transform.doctree b/.doctrees/learn/intrinsics/transform.doctree
new file mode 100644
index 000000000000..5fbe177eb9ab
Binary files /dev/null and b/.doctrees/learn/intrinsics/transform.doctree differ
diff --git a/.doctrees/learn/intrinsics/type.doctree b/.doctrees/learn/intrinsics/type.doctree
new file mode 100644
index 000000000000..a0a743823661
Binary files /dev/null and b/.doctrees/learn/intrinsics/type.doctree differ
diff --git a/.doctrees/learn/os_setup/choose_compiler.doctree b/.doctrees/learn/os_setup/choose_compiler.doctree
new file mode 100644
index 000000000000..e9add53be915
Binary files /dev/null and b/.doctrees/learn/os_setup/choose_compiler.doctree differ
diff --git a/.doctrees/learn/os_setup/ides.doctree b/.doctrees/learn/os_setup/ides.doctree
new file mode 100644
index 000000000000..160b0e12f606
Binary files /dev/null and b/.doctrees/learn/os_setup/ides.doctree differ
diff --git a/.doctrees/learn/os_setup/index.doctree b/.doctrees/learn/os_setup/index.doctree
new file mode 100644
index 000000000000..ebe18f4d4c69
Binary files /dev/null and b/.doctrees/learn/os_setup/index.doctree differ
diff --git a/.doctrees/learn/os_setup/install_gfortran.doctree b/.doctrees/learn/os_setup/install_gfortran.doctree
new file mode 100644
index 000000000000..9d54a6addf61
Binary files /dev/null and b/.doctrees/learn/os_setup/install_gfortran.doctree differ
diff --git a/.doctrees/learn/os_setup/text_editors.doctree b/.doctrees/learn/os_setup/text_editors.doctree
new file mode 100644
index 000000000000..aeba3811c1d3
Binary files /dev/null and b/.doctrees/learn/os_setup/text_editors.doctree differ
diff --git a/.doctrees/learn/os_setup/tips.doctree b/.doctrees/learn/os_setup/tips.doctree
new file mode 100644
index 000000000000..9a959132a297
Binary files /dev/null and b/.doctrees/learn/os_setup/tips.doctree differ
diff --git a/.doctrees/learn/quickstart/arrays_strings.doctree b/.doctrees/learn/quickstart/arrays_strings.doctree
new file mode 100644
index 000000000000..b5888e22eb13
Binary files /dev/null and b/.doctrees/learn/quickstart/arrays_strings.doctree differ
diff --git a/.doctrees/learn/quickstart/derived_types.doctree b/.doctrees/learn/quickstart/derived_types.doctree
new file mode 100644
index 000000000000..daa056b07321
Binary files /dev/null and b/.doctrees/learn/quickstart/derived_types.doctree differ
diff --git a/.doctrees/learn/quickstart/hello_world.doctree b/.doctrees/learn/quickstart/hello_world.doctree
new file mode 100644
index 000000000000..b3d1efe1e64f
Binary files /dev/null and b/.doctrees/learn/quickstart/hello_world.doctree differ
diff --git a/.doctrees/learn/quickstart/index.doctree b/.doctrees/learn/quickstart/index.doctree
new file mode 100644
index 000000000000..97d7d207e27b
Binary files /dev/null and b/.doctrees/learn/quickstart/index.doctree differ
diff --git a/.doctrees/learn/quickstart/operators_control_flow.doctree b/.doctrees/learn/quickstart/operators_control_flow.doctree
new file mode 100644
index 000000000000..e45e76a1cd45
Binary files /dev/null and b/.doctrees/learn/quickstart/operators_control_flow.doctree differ
diff --git a/.doctrees/learn/quickstart/organising_code.doctree b/.doctrees/learn/quickstart/organising_code.doctree
new file mode 100644
index 000000000000..ba9dd8113f32
Binary files /dev/null and b/.doctrees/learn/quickstart/organising_code.doctree differ
diff --git a/.doctrees/learn/quickstart/variables.doctree b/.doctrees/learn/quickstart/variables.doctree
new file mode 100644
index 000000000000..b9cf29ff89f7
Binary files /dev/null and b/.doctrees/learn/quickstart/variables.doctree differ
diff --git a/.doctrees/news.doctree b/.doctrees/news.doctree
new file mode 100644
index 000000000000..9d182fcbbf86
Binary files /dev/null and b/.doctrees/news.doctree differ
diff --git a/.doctrees/news/2020/02-28-J3-february-meeting.doctree b/.doctrees/news/2020/02-28-J3-february-meeting.doctree
new file mode 100644
index 000000000000..d775bd1b428f
Binary files /dev/null and b/.doctrees/news/2020/02-28-J3-february-meeting.doctree differ
diff --git a/.doctrees/news/2020/04-06-Announcing-FortranCon-2020.doctree b/.doctrees/news/2020/04-06-Announcing-FortranCon-2020.doctree
new file mode 100644
index 000000000000..4e14983329ee
Binary files /dev/null and b/.doctrees/news/2020/04-06-Announcing-FortranCon-2020.doctree differ
diff --git a/.doctrees/news/2020/04-18-Fortran-Webinar.doctree b/.doctrees/news/2020/04-18-Fortran-Webinar.doctree
new file mode 100644
index 000000000000..f0fec6f98ec6
Binary files /dev/null and b/.doctrees/news/2020/04-18-Fortran-Webinar.doctree differ
diff --git a/.doctrees/news/2020/05-01-Fortran-Newsletter-May-2020.doctree b/.doctrees/news/2020/05-01-Fortran-Newsletter-May-2020.doctree
new file mode 100644
index 000000000000..61c59a7b3b7f
Binary files /dev/null and b/.doctrees/news/2020/05-01-Fortran-Newsletter-May-2020.doctree differ
diff --git a/.doctrees/news/2020/06-01-Fortran-Newsletter-June-2020.doctree b/.doctrees/news/2020/06-01-Fortran-Newsletter-June-2020.doctree
new file mode 100644
index 000000000000..a174918bacea
Binary files /dev/null and b/.doctrees/news/2020/06-01-Fortran-Newsletter-June-2020.doctree differ
diff --git a/.doctrees/news/2020/07-01-Fortran-Newsletter-July-2020.doctree b/.doctrees/news/2020/07-01-Fortran-Newsletter-July-2020.doctree
new file mode 100644
index 000000000000..d10d86702783
Binary files /dev/null and b/.doctrees/news/2020/07-01-Fortran-Newsletter-July-2020.doctree differ
diff --git a/.doctrees/news/2020/08-01-Fortran-Newsletter-August-2020.doctree b/.doctrees/news/2020/08-01-Fortran-Newsletter-August-2020.doctree
new file mode 100644
index 000000000000..b42f314ee5f7
Binary files /dev/null and b/.doctrees/news/2020/08-01-Fortran-Newsletter-August-2020.doctree differ
diff --git a/.doctrees/news/2020/09-01-Fortran-Newsletter-September-2020.doctree b/.doctrees/news/2020/09-01-Fortran-Newsletter-September-2020.doctree
new file mode 100644
index 000000000000..7a3ae20daa66
Binary files /dev/null and b/.doctrees/news/2020/09-01-Fortran-Newsletter-September-2020.doctree differ
diff --git a/.doctrees/news/2020/10-01-Fortran-Newsletter-October-2020.doctree b/.doctrees/news/2020/10-01-Fortran-Newsletter-October-2020.doctree
new file mode 100644
index 000000000000..5546b52b4e79
Binary files /dev/null and b/.doctrees/news/2020/10-01-Fortran-Newsletter-October-2020.doctree differ
diff --git a/.doctrees/news/2020/11-01-Fortran-Newsletter-November-2020.doctree b/.doctrees/news/2020/11-01-Fortran-Newsletter-November-2020.doctree
new file mode 100644
index 000000000000..05a79d0b5e0c
Binary files /dev/null and b/.doctrees/news/2020/11-01-Fortran-Newsletter-November-2020.doctree differ
diff --git a/.doctrees/news/2020/12-01-Fortran-Newsletter-December-2020.doctree b/.doctrees/news/2020/12-01-Fortran-Newsletter-December-2020.doctree
new file mode 100644
index 000000000000..fa210648354b
Binary files /dev/null and b/.doctrees/news/2020/12-01-Fortran-Newsletter-December-2020.doctree differ
diff --git a/.doctrees/news/2021/01-01-Fortran-Newsletter-January-2021.doctree b/.doctrees/news/2021/01-01-Fortran-Newsletter-January-2021.doctree
new file mode 100644
index 000000000000..2bb9b602bef1
Binary files /dev/null and b/.doctrees/news/2021/01-01-Fortran-Newsletter-January-2021.doctree differ
diff --git a/.doctrees/news/2021/02-01-Fortran-Newsletter-February-2021.doctree b/.doctrees/news/2021/02-01-Fortran-Newsletter-February-2021.doctree
new file mode 100644
index 000000000000..65f22ce96caf
Binary files /dev/null and b/.doctrees/news/2021/02-01-Fortran-Newsletter-February-2021.doctree differ
diff --git a/.doctrees/news/2021/03-01-Fortran-Newsletter-March-2021.doctree b/.doctrees/news/2021/03-01-Fortran-Newsletter-March-2021.doctree
new file mode 100644
index 000000000000..d2bc88785fea
Binary files /dev/null and b/.doctrees/news/2021/03-01-Fortran-Newsletter-March-2021.doctree differ
diff --git a/.doctrees/news/2021/03-09-fortran-lang-accepted-for-google-summer-of-code-2021.doctree b/.doctrees/news/2021/03-09-fortran-lang-accepted-for-google-summer-of-code-2021.doctree
new file mode 100644
index 000000000000..47036baf9003
Binary files /dev/null and b/.doctrees/news/2021/03-09-fortran-lang-accepted-for-google-summer-of-code-2021.doctree differ
diff --git a/.doctrees/news/2021/04-01-Fortran-Newsletter-April-2021.doctree b/.doctrees/news/2021/04-01-Fortran-Newsletter-April-2021.doctree
new file mode 100644
index 000000000000..5c5130bc830e
Binary files /dev/null and b/.doctrees/news/2021/04-01-Fortran-Newsletter-April-2021.doctree differ
diff --git a/.doctrees/news/2021/04-20-First-Year.doctree b/.doctrees/news/2021/04-20-First-Year.doctree
new file mode 100644
index 000000000000..9e3cfce8fab4
Binary files /dev/null and b/.doctrees/news/2021/04-20-First-Year.doctree differ
diff --git a/.doctrees/news/2021/05-01-Fortran-Newsletter-May-2021.doctree b/.doctrees/news/2021/05-01-Fortran-Newsletter-May-2021.doctree
new file mode 100644
index 000000000000..e91dd41eca13
Binary files /dev/null and b/.doctrees/news/2021/05-01-Fortran-Newsletter-May-2021.doctree differ
diff --git a/.doctrees/news/2021/05-18-Welcome-GSoC-students.doctree b/.doctrees/news/2021/05-18-Welcome-GSoC-students.doctree
new file mode 100644
index 000000000000..fa2df2918855
Binary files /dev/null and b/.doctrees/news/2021/05-18-Welcome-GSoC-students.doctree differ
diff --git a/.doctrees/news/2021/06-01-Fortran-Newsletter-June-2021.doctree b/.doctrees/news/2021/06-01-Fortran-Newsletter-June-2021.doctree
new file mode 100644
index 000000000000..58868e1524eb
Binary files /dev/null and b/.doctrees/news/2021/06-01-Fortran-Newsletter-June-2021.doctree differ
diff --git a/.doctrees/news/2021/07-01-Fortran-Newsletter-July-2021.doctree b/.doctrees/news/2021/07-01-Fortran-Newsletter-July-2021.doctree
new file mode 100644
index 000000000000..b18f715ccecc
Binary files /dev/null and b/.doctrees/news/2021/07-01-Fortran-Newsletter-July-2021.doctree differ
diff --git a/.doctrees/news/2021/08-01-Fortran-Newsletter-August-2021.doctree b/.doctrees/news/2021/08-01-Fortran-Newsletter-August-2021.doctree
new file mode 100644
index 000000000000..56a7f06a364a
Binary files /dev/null and b/.doctrees/news/2021/08-01-Fortran-Newsletter-August-2021.doctree differ
diff --git a/.doctrees/news/2021/09-01-Fortran-Newsletter-September-2021.doctree b/.doctrees/news/2021/09-01-Fortran-Newsletter-September-2021.doctree
new file mode 100644
index 000000000000..6a9ae8244512
Binary files /dev/null and b/.doctrees/news/2021/09-01-Fortran-Newsletter-September-2021.doctree differ
diff --git a/.doctrees/news/2021/10-01-Fortran-Newsletter-October-2021.doctree b/.doctrees/news/2021/10-01-Fortran-Newsletter-October-2021.doctree
new file mode 100644
index 000000000000..be49a5c115c2
Binary files /dev/null and b/.doctrees/news/2021/10-01-Fortran-Newsletter-October-2021.doctree differ
diff --git a/.doctrees/news/2021/11-01-Fortran-Newsletter-November-2021.doctree b/.doctrees/news/2021/11-01-Fortran-Newsletter-November-2021.doctree
new file mode 100644
index 000000000000..585ff633ee26
Binary files /dev/null and b/.doctrees/news/2021/11-01-Fortran-Newsletter-November-2021.doctree differ
diff --git a/.doctrees/news/2021/12-01-Fortran-Newsletter-December-2021.doctree b/.doctrees/news/2021/12-01-Fortran-Newsletter-December-2021.doctree
new file mode 100644
index 000000000000..903e1bd0ae3a
Binary files /dev/null and b/.doctrees/news/2021/12-01-Fortran-Newsletter-December-2021.doctree differ
diff --git a/.doctrees/news/2021/12-29-Fortran-lang-2021-in-review.doctree b/.doctrees/news/2021/12-29-Fortran-lang-2021-in-review.doctree
new file mode 100644
index 000000000000..ddce0e1d8bbe
Binary files /dev/null and b/.doctrees/news/2021/12-29-Fortran-lang-2021-in-review.doctree differ
diff --git a/.doctrees/news/2022/01-01-Fortran-Newsletter-January-2022.doctree b/.doctrees/news/2022/01-01-Fortran-Newsletter-January-2022.doctree
new file mode 100644
index 000000000000..c0fab521c88f
Binary files /dev/null and b/.doctrees/news/2022/01-01-Fortran-Newsletter-January-2022.doctree differ
diff --git a/.doctrees/news/2022/02-01-Fortran-Newsletter-February-2022.doctree b/.doctrees/news/2022/02-01-Fortran-Newsletter-February-2022.doctree
new file mode 100644
index 000000000000..181415a4359d
Binary files /dev/null and b/.doctrees/news/2022/02-01-Fortran-Newsletter-February-2022.doctree differ
diff --git a/.doctrees/news/2022/03-09-Fortran-Newsletter-March-2022.doctree b/.doctrees/news/2022/03-09-Fortran-Newsletter-March-2022.doctree
new file mode 100644
index 000000000000..351ab4801c39
Binary files /dev/null and b/.doctrees/news/2022/03-09-Fortran-Newsletter-March-2022.doctree differ
diff --git a/.doctrees/news/2022/04-07-Fortran-Newsletter-April-2022.doctree b/.doctrees/news/2022/04-07-Fortran-Newsletter-April-2022.doctree
new file mode 100644
index 000000000000..fbebd65ef29a
Binary files /dev/null and b/.doctrees/news/2022/04-07-Fortran-Newsletter-April-2022.doctree differ
diff --git a/.doctrees/news/2022/05-05-Fortran-Newsletter-May-2022.doctree b/.doctrees/news/2022/05-05-Fortran-Newsletter-May-2022.doctree
new file mode 100644
index 000000000000..f796e1f01d0f
Binary files /dev/null and b/.doctrees/news/2022/05-05-Fortran-Newsletter-May-2022.doctree differ
diff --git a/.doctrees/news/2022/06-09-Fortran-Newsletter-June-2022.doctree b/.doctrees/news/2022/06-09-Fortran-Newsletter-June-2022.doctree
new file mode 100644
index 000000000000..0953649e61dc
Binary files /dev/null and b/.doctrees/news/2022/06-09-Fortran-Newsletter-June-2022.doctree differ
diff --git a/.doctrees/packages.doctree b/.doctrees/packages.doctree
new file mode 100644
index 000000000000..a1e3810e4e9c
Binary files /dev/null and b/.doctrees/packages.doctree differ
diff --git a/.doctrees/packages/data-types.doctree b/.doctrees/packages/data-types.doctree
new file mode 100644
index 000000000000..5250a12d8035
Binary files /dev/null and b/.doctrees/packages/data-types.doctree differ
diff --git a/.doctrees/packages/examples.doctree b/.doctrees/packages/examples.doctree
new file mode 100644
index 000000000000..2caa04e2cc7a
Binary files /dev/null and b/.doctrees/packages/examples.doctree differ
diff --git a/.doctrees/packages/graphics.doctree b/.doctrees/packages/graphics.doctree
new file mode 100644
index 000000000000..f3d96d778918
Binary files /dev/null and b/.doctrees/packages/graphics.doctree differ
diff --git a/.doctrees/packages/interfaces.doctree b/.doctrees/packages/interfaces.doctree
new file mode 100644
index 000000000000..6da79f81bce0
Binary files /dev/null and b/.doctrees/packages/interfaces.doctree differ
diff --git a/.doctrees/packages/io.doctree b/.doctrees/packages/io.doctree
new file mode 100644
index 000000000000..48e7e9941e10
Binary files /dev/null and b/.doctrees/packages/io.doctree differ
diff --git a/.doctrees/packages/libraries.doctree b/.doctrees/packages/libraries.doctree
new file mode 100644
index 000000000000..191bef0c3554
Binary files /dev/null and b/.doctrees/packages/libraries.doctree differ
diff --git a/.doctrees/packages/numerical.doctree b/.doctrees/packages/numerical.doctree
new file mode 100644
index 000000000000..b0080eba6383
Binary files /dev/null and b/.doctrees/packages/numerical.doctree differ
diff --git a/.doctrees/packages/programming.doctree b/.doctrees/packages/programming.doctree
new file mode 100644
index 000000000000..0217c3508bdb
Binary files /dev/null and b/.doctrees/packages/programming.doctree differ
diff --git a/.doctrees/packages/scientific.doctree b/.doctrees/packages/scientific.doctree
new file mode 100644
index 000000000000..c721c64f9b6e
Binary files /dev/null and b/.doctrees/packages/scientific.doctree differ
diff --git a/.doctrees/packages/strings.doctree b/.doctrees/packages/strings.doctree
new file mode 100644
index 000000000000..85e3a2e60b88
Binary files /dev/null and b/.doctrees/packages/strings.doctree differ
diff --git a/.doctrees/roadmap.doctree b/.doctrees/roadmap.doctree
new file mode 100644
index 000000000000..c659ae3b921b
Binary files /dev/null and b/.doctrees/roadmap.doctree differ
diff --git a/BingSiteAuth.xml b/BingSiteAuth.xml
index 1d68adbb23ba..8151ede59bf2 100644
--- a/BingSiteAuth.xml
+++ b/BingSiteAuth.xml
@@ -1 +1 @@
-A2502A09101EE028158E1850D3BA90CE
+
diff --git a/_sources/community.md.txt b/_sources/community.md.txt
new file mode 100644
index 000000000000..967d44db69ab
--- /dev/null
+++ b/_sources/community.md.txt
@@ -0,0 +1,209 @@
+---
+sd_hide_title: true
+---
+
+
+
+
+
+
+# Community
+
+:::{div} sd-text-center sd-fs-2 sd-font-weight-bold sd-text-primary
+Fortran-lang Community
+:::
+
+:::{div} sd-text-center sd-fs-3
+Collaboration for the advancement of Fortran
+:::
+
+:::{div} sd-text-left sd-fs-2 sd-text-primary
+Fortran-lang Community Projects
+:::
+
+:::::{grid} 2
+
+::::{grid-item-card}
+:columns: 5
+:shadow: none
+
+:::{div} sd-text-left sd-fs-4
+Fortran Standard Library (stdlib)
+:::
+
+A community-driven project for a de facto 'standard' library for Fortran. The stdlib project is both a specification and a reference implementation, developed in cooperation with the Fortran Standards Committee.
+[GitHub](https://github.com/fortran-lang/stdlib),[Documentation](https://stdlib.fortran-lang.org/),[Contributing](https://github.com/fortran-lang/stdlib/blob/HEAD/WORKFLOW.md).
+
+:::{div} sd-text-left sd-fs-4
+Fortran Package Manager (fpm)
+:::
+
+A prototype project to develop a common build system for Fortran packages and their dependencies.
+[GitHub](https://github.com/fortran-lang/fpm),[Documentation](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md),[Contributing](https://github.com/fortran-lang/fpm/blob/HEAD/CONTRIBUTING.md).
+
+:::{div} sd-text-left sd-fs-4
+fortran-lang.org
+:::
+
+This website is open source and contributions are welcome!.
+[GitHub](https://github.com/fortran-lang/webpage),[Contributing](../community/contributing).
+
+::::
+::::{grid-item-card}
+:columns: 7
+:shadow: none
+
+
+
+
+
+::::
+:::::
+
+:::{div} sd-text-left sd-fs-2 sd-text-primary
+History
+:::
+
+The effort to build a new community around Fortran started at the beginning of 2020
+and was initially led by Ondřej Čertík [[1]][blog-ondrej] and Milan Curcic [[2]][blog-milan].
+Starting in several discussions around ambitious proposals for the Fortran Standards
+Committee, the Fortran Standard Library (`stdlib`) [[3]][issue-stdlib], the Fortran
+Package Manager (`fpm`) [[4]][issue-fpm] and the [`fortran-lang.org`][webpage-orig]
+webpage with new logo [[5]][issue-logo] were created.
+With the new webpage and projects attracting more contributors, the Fortran-lang discourse
+was created to provide a place for general discussions around all the things Fortran,
+announcing newly started projects, getting help, etc.
+Since its creation the Fortran-lang community was joined by hundreds of contributors.
+
+[Read more](../community/history)
+
+[blog-ondrej]: https://ondrejcertik.com/blog/2021/03/resurrecting-fortran/
+[blog-milan]: https://medium.com/modern-fortran/first-year-of-fortran-lang-d8796bfa0067
+[issue-fpm]: https://github.com/j3-fortran/fortran_proposals/issues/55
+[issue-stdlib]: https://github.com/j3-fortran/fortran_proposals/issues/104
+[issue-logo]: https://github.com/j3-fortran/fortran_proposals/issues/47
+[webpage-orig]: https://web.archive.org/web/20200504000648/https://fortran-lang.org/
+
+:::{div} sd-text-left sd-fs-2 sd-text-primary
+Get Involved
+:::
+
+:::::{grid} 2
+:gutter: 1
+
+::::{grid-item-card}
+:shadow: none
+
+:::{div} sd-text-left sd-fs-4
+Join the Discussion
+:::
+
+The easiest way to join the community and contribute is by
+commenting on issues and pull requests in the project
+repositories.
+
+Whether Fortran beginner or seasoned veteran, your feedback and comments are most
+welcome in guiding the future of Fortran-lang.
+
+::::
+
+::::{grid-item-card}
+:shadow: none
+
+:::{div} sd-text-left sd-fs-4
+Build and Test
+:::
+
+Get more involved with each project by cloning, building and testing
+it on your own machine(s) and with your own codes;
+if something doesn't work, create an issue to let us know!
+We value user feedback highly, be it a bug report, feature request, or
+suggestion for documentation.
+
+::::
+
+::::{grid-item-card}
+:shadow: none
+
+:::{div} sd-text-left sd-fs-4
+Contributor Guide
+:::
+
+Want to contribute code and content?
+Check out the contributor guides in each repository for information
+on the project workflow and recommended practices.
+
+[Contributor guide for stdlib](https://github.com/fortran-lang/stdlib/blob/HEAD/WORKFLOW.md)
+[Contributor guide for fpm](https://github.com/fortran-lang/fpm/blob/HEAD/CONTRIBUTING.md)
+[Contributor guide for fortran-lang.org](community/contributing)
+
+::::
+::::{grid-item-card}
+:shadow: none
+
+:::{div} sd-text-left sd-fs-4
+Community Conduct
+:::
+
+As a community, we strive to make participation in our discussions and projects a friendly and harassment-free experience for everyone.
+See the full [Code of Conduct](https://github.com/fortran-lang/.github/blob/main/CODE_OF_CONDUCT.md).
+
+::::
+
+:::::
+
+:::{div} sd-text-left sd-fs-2 sd-text-primary
+Fortran-lang Contributors
+:::
+
+
+
+:::{div} sd-text-left sd-fs-3
+source: https://git-contributor.com/
+:::
+
+:::{div} sd-text-left sd-fs-4 sd-text-primary
+Contributors:
+:::
+
+::::::{jinja} contributors
+
+:::::{grid} 6
+:gutter: 1
+{% for j in contributor | batch(6, ' ') %}
+
+{% for i in j %}
+{% if i != ' ' %}
+
+::::{grid-item-card}
+:shadow: none
+
+:::{grid-item-card} [{{i}}]({{"https://github.com/"+i}})
+:shadow: none
+:img-top: https://github.com/{{i}}.png?size=100
+:shadow: none
+:text-align: center
+:::
+::::
+
+{% endif %}
+{% endfor %}
+{% endfor %}
+
+:::::
+
+::::::
+
+:::{toctree}
+:hidden:
+community/history
+community/contributing
+community/minibooks
+community/packages
+:::
diff --git a/_sources/community/contributing.md.txt b/_sources/community/contributing.md.txt
new file mode 100644
index 000000000000..5b32d81e8c5a
--- /dev/null
+++ b/_sources/community/contributing.md.txt
@@ -0,0 +1,303 @@
+# Contributing to fortran-lang.org
+
+Fortran-lang.org is open-source and contributions are welcome!
+
+- See [package index guide](packages) for how to add an entry to the [Package index](/packages)
+
+- See [minibook guide](minibooks) for how to write and structure a mini-book tutorial for the [Learn](/learn) section
+
+## Introduction
+
+**How is the site written?**
+
+The content of the website is primarily written in a combination of Markdown (Myst flavoured), HTML and YAML (for data).
+This source is compiled to produce pure HTML which is what you see on the final website.
+
+The website is _static_ which means that once built, the content on the site is the same for all users;
+this is in contrast to many websites that are _dynamic_, meaning they can serve different content
+depending on the user and the inputs supplied by the user.
+
+Structural components of the website are written in the Sphinx Static site generator for static features, and JavaScript for dynamic features.
+
+**Do I need to know HTML to contribute?**
+
+The majority of the site content is written in [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet), a simple markup language for formatting text - don't worry if you haven't used it before, it's very easy to pick up!
+
+**How is the site built?**
+
+The Fortran-lang site uses the Python-based [Sphinx static site generator](https://www.sphinx-doc.org/en/master/) to compile the RST,Markdown and HTML files.
+It is recommended for contributors to install Python on your development computer so that changes can be previewed locally, however this is not mandatory since site previews can be generated during the pull request process (see below for more information).
+See [README.md](https://github.com/fortran-lang/webpage/blob/HEAD/README.md) for how to setup Sphinx and build the site.
+
+The GitHub repository default branch only ever contains the 'source code' for the website, not the final compiled result; an automated service compiles this source code every time an update is pushed and stores the compiled result on the [`gh-pages`](https://github.com/fortran-lang/webpage/tree/gh-pages) branch which is served up at .
+
+Therefore, as a contributor you only need to upload changes to the site source code and not the compiled result, because this is built automatically from the source code on the default branch.
+
+## Workflow
+
+Contributions to the site are made by pull request to the github repository: .
+
+The workflow for doing so takes the following form:
+
+1. Create/update a personal fork of webpage
+
+ - (See [github help: syncing a fork](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/syncing-a-fork) )
+
+2. Create a new branch in your fork
+
+ - The branch name should concisely describe your contribution, _e.g._ `fix-spelling-homepage`, `update-compiler-info`
+
+3. Perform your changes on the local branch
+
+4. Push your modified branch to your fork
+
+ - _e.g._ `git push --set-upstream origin fix-spelling-homepage`
+
+5. Create a pull request in the fortran-lang/webpage from your modified fork branch
+ - (See [github help: creating a pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request) )
+
+**Note: Before opening a pull request you must build your changes locally using Sphinx (see [README.md](https://github.com/fortran-lang/webpage/HEAD/blob/README.md)) to verify that your changes build correctly and render as you expect.**
+
+**Note: You can continue to push changes to your fork branch after you open a pull request - the pull request will update accordingly**
+
+Your pull request will be reviewed by other members of the community who may request changes.
+GitHub provides an easy interface on its website to apply (or reject) any reviewer-suggested changes with a click of a button.
+This avoids having to manually copy suggestions to your local copy and push back again.
+If you use the "Commit suggestion" button, you will need to update the local copy on your computer using `git pull` if you intend to push more edits from your computer.
+
+Once your pull request is approved, usually by at least two other community members, it will be merged into the webpage default branch by the maintainers at which point it will be published to the fortran-lang.org site.
+
+If required, the repository maintainers can build a public preview of your proposed changes which will be available to view at `fortran-lang.org/pr//` where `` is the numeric identifier of your pull request.
+
+This allows reviewers to directly view the generated result of your PR.
+
+**Note:** if you push subsequent commits to your pull request branch, you must rebuild the pull request preview by commenting on
+the pull request with '#build_preview'.
+
+After a pull request has been merged and successfully rendered, the workflows will delete the preview build.
+
+**Note:** if your pull request preview link doesn't work or doesn't update after re-building, try adding a random parameter to the end of the URL, _e.g._ `https://fortran-lang.org/pr/98?v=2` - the name and value of the parameter don't matter, but use different values for each update.
+This will force the GitHub content delivery network to serve you an updated version instead of a cached version which is out-of-date.
+
+## Style guide
+
+### Markdown
+
+- Place code excerpts in [code blocks](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#code-and-syntax-highlighting),
+ denoted by back ticks (` ``` `). Use inline code style (`` `code` ``) for inline code excerpts, programming language keywords, variables names and file names.
+
+- Have no more than one sentence per source-code line, and break-up long sentences across multiples lines -
+ this is important to avoid large git diffs and code review blocks on github.
+
+### External links
+
+It is recommended practice for off-site hyperlinks to open in a new tab.
+On `Fortran-lang.org` all such links will automatically be suffixed with a new-tab icon;
+this gives site users prior expectation that the link will lead them off-site while keeping fortran-lang.org open in a previous tab.
+
+**Example:** Open link in new tab (HTML or markdown)
+
+```html
+Discourse
+```
+
+### Internal site links
+
+Hyperlinks that point to other parts of the fortran-lang.org website should be prefixed with `{{pathto('index',1)[:-5]}}` - this is important for generating pull request previews (see [here](https://byparker.com/blog/2014/clearing-up-confusion-around-baseurl/) for an explanation).
+
+**Example:** markdown link
+
+```
+[Fortran-lang news]({{pathto('index',1)[:-5]}}News)
+```
+
+**Example:** html link
+
+```
+Fortran packages
+```
+
+### Icon packs
+
+Icons are an easy way to improve page aesthetic by breaking-up otherwise monotonic text passages and drawing attention to headings or key information.
+
+Three icon packs are available for use on `fortran-lang.org`:
+- [Sphinx-design](https://sphinx-design.readthedocs.io/en/sbt-theme/badges_buttons.html#inline-icons) (MIT License)
+
+- [Font awesome](https://fontawesome.com/icons?d=gallery) (CC BY 4.0 License)
+
+
+**Example:** Font awesome
+
+```html
+
+```
+
+**Example:** Sphinx design Myst directives
+
+```md
+{octicon}`book;1em;sd-text-info`
+```
+
+Visit the respective websites to browse available icons.
+
+### Page contents
+
+It is sometimes helpful to display hyperlinked page contents for lengthy pages. The page TOC tree has been automated and will generate the TOC of the current page. Whereas the method to generate TOC of the entire directory on `Fortran-lang.org` is:
+
+**For pages in MD:**
+
+add the toc tree directive in md at the end of the index page of the directory with the names of the all files in that directory.
+
+
+````{toctree}
+:hidden:
+ARRAY_index
+````
+
+
+## Tutorials
+
+Guidelines for mini-book content.
+
+### General
+
+Use the `book` layout.
+
+Follow the [Markdown guidelines](#markdown).
+
+### Code style
+
+Use two spaces for indentation, indenting bodies of units but keeping the `contains` statement at the same level as its `module` or `type`. Try to limit line length to 90 characters. These considerations should make the code more readable and easier to view on devices with smaller viewport widths.
+
+```fortran
+module m
+ implicit none
+ private
+ public :: a_t
+
+ type :: a_t
+ integer :: val
+ contains
+ procedure :: func
+ end type a_t
+
+contains
+
+ subroutine func(self)
+ class(a_t), intent(in) :: self
+ if (self%val > 0) then
+ print *, self%val
+ end if
+ end function func
+
+end module m
+```
+
+Each code block should have a base indentation level of 0, even if it would be indented if put into a larger context.
+
+```fortran
+integer :: i1 ! yes
+ integer :: i2 ! no
+```
+
+Avoid vertically aligning `::` and inline comments since this adds maintenance burden and pushes the line length in most cases.
+
+If a code block contains lines that are not valid Fortran, leave it as a language-less code block to avoid the syntax highlighter's red boxes.
+
+```
+module
+...
+end module
+```
+
+Feel free to omit spacing in expressions where it helps with readability, but generally include whitespace around operators.
+
+```fortran
+y1 = a * b
+y2 = a*b + c*d ! instead of a * b + c * d
+y3 = a**2 + 1
+y4 = (a*b + c*d) / 2
+s3 = s1 // s2
+```
+
+Generally add a space after commas, except when indexing with short index values or variables names.
+
+```fortran
+a(:,1)
+a2(1:10, 2:5)
+b(i,j)
+b2(long_i_name, long_j_name)
+b3(i + 2, j)
+call some_subroutine(a, b, an_option=.false.)
+c = [1, 2, 3, 10]
+d = [(i, i = 1, 10)]
+do i = 1, 10
+! ...
+```
+
+Other situations besides simple indexings where white space can be omitted:
+
+- Aliasing in imports
+ ```fortran
+ use, intrinsic :: iso_c_binding, only: sp=>c_float, dp=>c_double
+ ```
+- String concatentation
+ ```fortran
+ print *, 'hello '//'world'
+ ```
+- Accessing components (attributes) of derived types
+ ```fortran
+ p%x
+ p%calc_something(a, b)
+ ```
+- Around `=` when passing keyword arguments
+ ```fortran
+ call sr(a, b, c=3)
+ point = t_point(x=1., y=2.)
+ character(len=:), allocatable :: s
+ ```
+
+Capitalize the first letter for inline comments except for trailing inline comments that only consist of one word or a short phrase.
+
+```fortran
+! Compute new values
+y = m*x + b ! meters
+```
+
+These code style recommendations are similar to those in [the DFTB+ style guide](https://dftbplus-develguide.readthedocs.io/en/latest/fortranstyle.html).
+
+### Text
+
+Use sentence case (as opposed to title case) for page and section titles.
+
+Use _emphasis_ (`*emphasis*`/`_emphasis_`, rendered as italic) for key words/phrases when they are first introduced, for emphasis, ...
+
+Avoid use of **strong** (`**strong**`, rendered as bold) within paragraphs, since bold style is used for headings, drawing attention to examples (**Example:**), admonition/aside titles, etc.
+
+Make use of the admonition/aside (_note_, _tip_, _important_) where appropriate.
+
+- to add a **note** to md document use:
+
+::::{note}
+extra information, something that might appear in a footnote
+:::::
+
+- to add a **tip** to md document use:
+
+::::{tip}
+information about best practices, practical tips
+:::::
+
+- to add an **important** text to md document use:
+
+::::{importrant}
+warnings, things to avoid, etc.
+:::::
+
+
+Prefer including the [Oxford comma](https://en.wikipedia.org/wiki/Serial_comma). It usually makes things more clear.
+
+> Fortran is fast, fun, and famed.
diff --git a/_sources/community/history.md.txt b/_sources/community/history.md.txt
new file mode 100644
index 000000000000..b628de472c0e
--- /dev/null
+++ b/_sources/community/history.md.txt
@@ -0,0 +1,109 @@
+# Fortran-lang history
+
+## Creation
+
+The effort to build a new community around Fortran started at the beginning of 2020
+and was initially led by Ondřej Čertík [[1]][blog-ondrej] and Milan Curcic [[2]][blog-milan].
+Starting in several discussions around ambitious proposals for the Fortran Standards
+Committee, the Fortran Standard Library (`stdlib`) [[3]][issue-stdlib], the Fortran
+Package Manager (`fpm`) [[4]][issue-fpm] and the [`fortran-lang.org`][webpage-orig]
+webpage with new logo [[5]][issue-logo] were created.
+With the new webpage and projects attracting more contributors, the Fortran-lang discourse
+was created to provide a place for general discussions around all the things Fortran,
+announcing newly started projects, getting help, etc.
+Since its creation the Fortran-lang community was joined by hundreds of contributors.
+
+[blog-ondrej]: https://ondrejcertik.com/blog/2021/03/resurrecting-fortran/
+[blog-milan]: https://medium.com/modern-fortran/first-year-of-fortran-lang-d8796bfa0067
+[issue-fpm]: https://github.com/j3-fortran/fortran_proposals/issues/55
+[issue-stdlib]: https://github.com/j3-fortran/fortran_proposals/issues/104
+[issue-logo]: https://github.com/j3-fortran/fortran_proposals/issues/47
+[webpage-orig]: https://web.archive.org/web/20200504000648/https://fortran-lang.org/
+
+## Incubator J3 repo
+
+## The Fortran Standard Library `stdlib`
+
+Created in the late 2019 the Fortran Standard Library provides
+a community driven and agreed upon de facto "standard" library for Fortran.
+The library is a collection of modules that provide a wide range of
+functionality, including: containers, sorting, searching, linear algebra,
+unities, fast Fourier transforms, and more.
+
+Find out more about `stdlib` on our [website](https://stdlib.fortran-lang.org/)
+and on [GitHub](https://github.com/fortran-lang/stdlib).
+
+## The Fortran Package Manager `fpm`
+
+Fortran Package Manager (fpm) is a package manager and build system for Fortran.
+Its key goal is to improve the user experience of Fortran programmers.
+It does so by making it easier to build your Fortran program or library, run the
+executables, tests, and examples, and distribute it as a dependency to other
+Fortran projects.
+Fpm's user interface is modeled after [Rust's Cargo](https://doc.rust-lang.org/cargo/),
+so if you're familiar with that tool, you will feel at home with fpm.
+Fpm's long term vision is to nurture and grow the ecosystem of modern Fortran
+applications and libraries.
+
+## Fortran Discourse
+
+## Fortran Package Index
+
+## Project migration to Fortran-lang
+
+Over time crucial projects to the Fortran community were migrated to the
+Fortran-lang organization to allow for community collaboration and to ensure
+long-term sustainability of the projects.
+
+### fftpack
+
+### minipack
+
+### test-drive
+
+### vscode-fortran-support
+
+
+
+Modern Fortran for Visual Studio Code is feature-rich Visual extension
+for Fortran originally created by
+Miguel Carvajal and maintained by Giannis Nikiteas.
+The extension migrated in early 2022 to the Fortran-lang organization
+to improve integration with other Fortran-lang projects such as `fpm`
+and allow for easier community collaboration.
+
+Find out more about Modern Fortran for Visual Studio Code on
+[VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=fortran-lang.linter-gfortran)
+and on [GitHub](httos://github.com/fortran-lang/vscode-fortran-support).
+
+### fortls
+
+
+
+`fortls` is a Fortran language server created by Giannis Nikiteas
+in late 2019. The project started as a fork of the
+archived project `fortran-language-server` but quickly diverged from it
+both in terms of features and codebase. The project migrated to the
+Fortran-lang organization in late 2022 to allow for easier community
+collaboration.
+
+Find out more about `fortls` on our [website](https://fortls.fortran-lang.org/)
+and on [GitHub](https://github.com/fortran-lang/fortls).
+
+## Fortran Publication
+
+In April 2022, members of the Fortran-lang community published a paper in
+Computing in Science & Engineering titled [_The State of Fortran_][pub-state-of-fortran]
+providing an overview of the language and its ecosystem.
+The paper focused on the ongoing efforts
+of developing the Fortran standard library ([`stdlib`][webpage-stdlib])
+and the Fortran package manager ([`fpm`][webpage-fpm]),
+fostering a friendly and welcoming community online ([`Fortran-lang Discourse`][discourse]),
+improving compiler support and language feature development.
+
+[pub-state-of-fortran]: https://ieeexplore.ieee.org/document/9736688
+[discourse]: https://fortran-lang.discourse.group/
+[webpage-fpm]: https://fpm.fortran-lang.org/
+[webpage-stdlib]: https://stdlib.fortran-lang.org/
+
+## Conferences and Events
diff --git a/_sources/community/minibooks.md.txt b/_sources/community/minibooks.md.txt
new file mode 100644
index 000000000000..ae67ab60f25c
--- /dev/null
+++ b/_sources/community/minibooks.md.txt
@@ -0,0 +1,266 @@
+# Mini-book Tutorials on fortran-lang.org
+
+This guide will cover how to write mini-book tutorials for the [Learn](https://fortran-lang.org/learn)
+section of .
+
+See [contributing guidelines](contributing) for general guidance on contributing to .
+
+## 0. Mini-book formats
+
+Mini-books are designed to be mostly self-contained tutorials on a particular feature of the Fortran language.
+
+There are two types of mini-book format:
+
+- **Single-page:** all content is written within a single markdown file and displayed
+ on a single webpage;
+
+- **Multi-page:** tutorial content is written across multiple markdown files and displayed
+ as a collection of webpages.
+
+The choice of book type depends on the length of your content and how you intend to structure it.
+
+Consider the table of contents that will be produced:
+
+- Single-page books have **one level** of navigation: a link for each heading in the tutorial in inpage-toc (toc on the right hand side of the page).
+
+- Multi-page books have **two levels** of navigation: a link for each heading in the tutorial in inpage-toc (toc on the right hand side of the page) and sidebar-toc (toc on the left hand side of the page showing different pages in directory).
+
+Single-page mini-books are simpler to produce and should be used for brief topics or short tutorials that will
+eventually be subsumed into a more-comprehensive multi-page book.
+
+Multi-page books are recommended for more-comprehensive tutorials that can be structured with one subtopic per page.
+
+The rest of this guide is split into two sections, one each for the single-page and multi-page book types.
+
+## 1. Single-page mini-book
+
+The steps required for publishing a single-page mini-book are:
+
+- Create a new markdown document in the `./learn` directory
+
+- Write your tutorial content
+
+- Add an entry to [data/learning.yml](./data/learning.yml) for your new mini-book
+
+- Open a pull request
+
+### 1.1 Writing your mini-book in markdown
+
+For single-page mini-books your tutorial will be entirely contained within a single markdown document.
+
+First create a new markdown document in the `./learn/{{name_of_minibook}}/` directory with the `.md` file extension
+and a short name that concisely describes the topic of your tutorial, _e.g._ `./learn/{{name_of_minibook}}/file_io.md`.
+
+Open your new markdown file and append an entry in the toc of `learn.md` in the following format:
+
+```
+:::{toctree}
+:hidden:
+
+learn/quickstart/index
+learn/best_practices/index
+learn/os_setup/index
+learn/building_programs/index
+learn/intrinsics/index
+learn/{{book-filename}}
+:::
+```
+
+Replace `{{book-filename}}` with the filename of your markdown file
+but **excluding the `.md` extension**. There should also be no trailing slash.
+
+**Example:** header
+
+```
+:::{toctree}
+:hidden:
+
+learn/quickstart/index
+learn/best_practices/index
+learn/os_setup/index
+learn/building_programs/index
+learn/intrinsics/index
+learn/file_io
+:::
+```
+
+**NOT:** `permalink: /learn/file_io.md`
+
+**NOT:** `permalink: /learn/file_io/`
+
+You can now fill the rest of the file with your tutorial content written in markdown;
+see [Kramdown syntax](https://kramdown.gettalong.org/syntax.html) for documentation on
+the markdown implementation.
+
+### 1.2 Structuring your mini-book with headings
+
+You should use headings to break-up your single-page mini-book into a logical structure.
+Each heading will show up in the hyperlinked table-of-contents.
+
+In markdown, headings can be written as:
+
+```markdown
+# Heading level 1
+
+## Heading level 2
+
+### Heading level 3
+
+#### Heading level 4
+
+##### Heading level 5
+
+###### Heading level 6
+```
+
+**Note:** make sure to include a blank line before your heading.
+
+### 1.3 Add your mini-book to the Learn page
+
+To add your new mini-book to the _Learn_ page, you need to add a new entry
+in the [data/learning.yml](./data/learning.yml) datafile.
+
+Open this file and create a new entry under the `books:` field in the following format:
+
+```yaml
+- title: {{book-title}}
+ description: {{book-description}}
+ category: {{book-category}}
+ link: /learn/{{book-filename}}
+```
+
+The `title` field is what will be displayed on the _Learn_ page for your mini-book
+and should generally be the same as the `title` field in your markdown file, but this isn't required.
+
+The contents of the `description` field is also displayed on the _Learn_ page
+and should briefly summarise the contents of your mini-book tutorial.
+
+The `category` field should match one of the categories listed at the top of the data file (under
+the `categories:` field) and is used to group tutorials on the Learn page.
+
+The `link` field should exactly match the `permalink` field in your markdown document.
+
+**Example:** `learning.yml` book entry
+
+```yaml
+- title: File input and output
+ description: A tutorial on reading and writing files in Fortran
+ category: Getting started
+ link: /learn/file/file_io
+```
+
+Save the modified `learning.yml` data file and run fortran_package.py and rebuild the website on your local machine to check the results.
+If successful, a new link should appear on the \_Learn* page with the title of your new mini-book.
+
+Once you have completed your mini-book and added an entry to the `learning.yml` data file, open a pull request
+at (see [CONTRIBUTING](./CONTRIBUTING.md)).
+
+## 2. Multi-page mini-books
+
+The steps required for publishing a multi-page mini-book are:
+
+- Create a new folder in the `./learn/` directory
+
+- Create an `index.md` file in your new folder
+
+- Write your tutorial content in markdown files in your new folder
+
+- Add an entry to [data/learning.yml](./data/learning.yml) for your new mini-book
+
+- Open a pull request
+
+### 2.1 Create a new folder for your mini-book
+
+Create a new folder in the `./learn/` directory with a short name that concisely describes the topic of your tutorial, _e.g._ `./learn/coarrays/`.
+All pages of your mini-book will be contained within this folder.
+
+The first page of your mini-book should be called `index.md`, so create a new markdown file in
+your mini-book folder called `index.md`, and add a toc in the following format in all the markdown files:
+
+```
+:::{toctree}
+:hidden:
+
+file1
+file2
+:::
+```
+
+**There should be no trailing slash.**
+
+**Example:** toc for `index.md`
+
+```
+:::{toctree}
+:hidden:
+
+learn/quickstart/index
+learn/best_practices/index
+learn/os_setup/index
+learn/building_programs/index
+learn/intrinsics/index
+:::
+```
+
+**NOT:** `permalink: /learn/coarrays/`
+
+
+you should populate the remainder of `index.md` with an introduction to your mini-book tutorial which may include: a summary of the concepts covered; any prerequisites; and any references to other related mini-books or useful third-party resources.
+
+### 2.2 Add pages to your mini-book
+
+For each new page in your mini-book, create a new markdown file in your mini-book folder.
+
+As with single-page mini-books, you should use headings to break-up each
+page into a logical structure.
+Each heading on the current page will show up in the inpage table-of-contents.
+
+### 2.3 Add your mini-book to the Learn page
+
+To add your new mini-book to the _Learn_ page, you need to add a new entry
+in the [data/learning.yml](./data/learning.yml) datafile.
+
+Open this file and create a new entry under the `books:` field in the following format:
+
+```yaml
+- title: {{book-title}}
+ description: {{book-description}}
+ category: {{book-category}}
+ link: /learn/{{book-folder}}
+ pages:
+ - link: /learn/{{book-folder}}/{{page1-filename}}
+ - link: /learn/{{book-folder}}/{{page2-filename}}
+ - link: /learn/{{book-folder}}/{{page3-filename}}
+```
+
+The `title` field is what will be displayed on the _Learn_ page for your mini-book
+and should generally be the same as the `title` field in your `index.md` markdown file, but this isn't required.
+
+The contents of the `description` field is also displayed on the _Learn_ page
+and should briefly summarise the contents of your mini-book tutorial.
+
+The `category` field should match one of the categories listed at the top of the data file (under
+the `categories:` field) and is used to group tutorials on the Learn page.
+
+The top-level `link` field should exactly match the `permalink` field in your `index.md` file.
+
+Each `link` field under `pages` should exactly match the `permalink` field in each of your subsequent mini-book pages.
+
+**Example:** `learning.yml` book entry
+
+```yaml
+- title: Parallel programming with Coarrays
+ description: A tutorial on parallel programming using coarrays
+ category: Parallel programming
+ link: /learn/coarrays
+ pages:
+ - link: /learn/coarrays/background
+ - link: /learn/coarrays/codimension
+ - link: /learn/coarrays/examples
+```
+
+Save the modified `learning.yml` data file and run fortran*package.py and rebuild the website on your local machine to check the results.
+If successful, a new link should appear on the \_Learn* page with the title of your new mini-book.
+
+Once you have completed your mini-book and added an entry to the `learning.yml` data file, open a pull request
+at (see [CONTRIBUTING](./CONTRIBUTING.md)).
diff --git a/_sources/community/packages.md.txt b/_sources/community/packages.md.txt
new file mode 100644
index 000000000000..072012203835
--- /dev/null
+++ b/_sources/community/packages.md.txt
@@ -0,0 +1,151 @@
+# Fortran-lang.org package index
+
+## Package criteria
+
+The following criteria are required of packages to be indexed:
+
+- **Relevance**: the package must be primarily implemented in Fortran or provide
+ a complete Fortran interface to an existing package or be purposed solely towards
+ software development in Fortran.
+
+- **Maturity**: the primary functionality of the package shall be implemented.
+ No prototype, testing or partially complete packages will be accepted.
+ If the package is hosted on github or similar, it should have at least 5 'stars'.
+
+- **Availability**: the package source shall be freely available for browsing online
+ or cloning or downloading
+
+- **Open source**: the package shall be licensed under an appropriate [open-source license](https://opensource.org/licenses)
+ with the license file clearly included with the source code
+
+- **Uniqueness**: the package shall not be a fork or minor revision of existing packages
+
+- **README**: the package shall have some form of README or landing-page clearly
+ stating the package purpose and functionality. This should also contain information on the package dependencies and the steps required to build and run.
+
+The following criteria are not required but are recommended:
+
+- **Documentation**: any form of written documentation aimed at users of the package. Ideally
+ this should cover:
+
+ - Supported / tested compilers
+ - Dependencies
+ - Build and install process
+ - Modules contained within the package
+ - Procedures made available and their interfaces
+ - Example code
+
+- **Contributing**: details on how users may submit issues and contribute to the development of the
+ package
+
+- **Tests**: any form of executable test(s) that can be used to verify the functionality of the package
+
+- **Portability**: no non-standard language extensions or proprietary dependencies
+
+- **FPM**: support installation by the Fortran Package Manager [fpm](https://github.com/fortran-lang/fpm)
+
+## Process for adding packages
+
+1. Users should confirm that their project meets the minimum requirements for listing in the
+ Fortran-lang package index, as written in this document
+
+2. Users should open a pull request using the 'Package index request' template
+
+3. At least three Fortran-lang community members shall review the request against the criteria above
+
+4. If three or more Fortran-lang community members agree that the package should be listed and there is no significant objection, then the pull request will be merged
+
+## Package index requests
+
+Package index requests are made by pull requests against the [fortran-lang.org repository](https://github.com/fortran-lang/webpage/).
+See [this guide](https://guides.github.com/activities/forking/) for guidance on forking and making pull requests.
+
+Package details are listed in the `data/package_index.yml` data file.
+
+To add a package simply create a new entry within this file.
+The data file is ordered by high-level categories merely to aid in navigation;
+find the appropriate category for your package and create a new entry.
+
+#### After adding a new entry to package index, run the github action fortran_packages before building the sphinx build.
+
+### Github hosted packages
+
+```
+ - name:
+ github: /
+ description:
+ categories: [category2]
+ tags: [tag1] [tag2] [tag3]
+ version: [version]
+ license: [license]
+```
+
+Valid categories:
+
+- `libraries`: general libraries
+- `interfaces`: libraries that provide interfaces to other libraries, software or devices
+- `programming`: general programming utilities: errors, logging, testing, documentation _etc._
+- `data-types`: libraries providing advanced data types: containers, datetime, resizable arrays _etc._
+- `strings`: string handling libraries
+- `io`: libraries that parse and generate various file formats
+- `graphics`: plotting and GUIs
+- `numerical`: matrices, linear algebra, solvers, root-finding, interpolation, optimization, differential eqns, statistics, machine learning, random numbers _etc._
+- `scientific`: domain-specific scientific libraries or applications
+- `examples`: repositories offering language feature demonstrations, tutorials and benchmarks
+
+**Projects listing more than one category must provide good justification thereof in the pull request.**
+
+**Notes:**
+
+- The package description should clearly describe the functionality of the package in a single sentence.
+
+- Tags (optional) should contain any terms not already contained in the name or description that users may search directly for. Tags should be separate by spaces.
+
+- Package version
+
+ - this can be determined automatically if a versioned release has been created on github
+ - if version is specified, it will override any detected github version
+ - if version is 'none', then no version information will be displayed. (Use this if
+ your package has no version.)
+
+- Package license
+ - this can be determined automatically if github is able to detect a known license
+ - license must be specified if github is unable to detect a known license
+
+### Non-github hosted packages
+
+```
+ - name:
+ url:
+ description:
+ categories: [category2]
+ tags: [tag1] [tag2] [tag3]
+ version: [version]
+ license:
+```
+
+**Notes:**
+
+- License and version information cannot be detected automatically for non-github repositories
+- if your package has no version, then omit the version field
+- a license must be specified for non-github repositories
+
+### Member review checklist
+
+Community members reviewing packages should cover the following points:
+
+1. Ensure the package meets the minimum criteria as written in this document
+
+2. Check the package metadata
+
+ - Repository exists and is accessible
+ - Description clearly and concisely describes the package
+ - Assigned category is appropriate
+
+3. Check license information
+ - If license field has been omitted: check that github has detected the license
+ - If license field is included: check that it matches repository license file
+
+After merge:
+
+- Check that package is available in expected category and search
diff --git a/_sources/compilers.md.txt b/_sources/compilers.md.txt
new file mode 100644
index 000000000000..19395e9bd218
--- /dev/null
+++ b/_sources/compilers.md.txt
@@ -0,0 +1,195 @@
+---
+sd_hide_title: true
+...
+
+
Fortran Compilers
+
Fortran has over a dozen open source and commercial compilers.
+
+## Compilers
+
+
Open source compilers
+
+
GNU Fortran Compiler
+
+[GNU Fortran Compiler (gfortran)](https://gcc.gnu.org/fortran/) is a mature
+free and open source compiler, part of the GNU Compiler Collection.
+
+[OpenCoarrays](http://www.opencoarrays.org/) is a library and compiler wrapper
+around gfortran which enables the parallel programming features of Fortran 2018
+with gfortran.
+
+
LLVM Flang
+
+[Flang](https://github.com/llvm/llvm-project/tree/main/flang)
+is a new front-end for Fortran 2018 that has been recently
+added to LLVM.
+It is implemented in modern C++ and uses a Fortran-oriented MLIR dialect for lowering to LLVM IR.
+This project is under active development.
+
+
Current Flang
+
+[Flang](https://github.com/flang-compiler/flang) is an open source compiler
+based on the NVIDIA/PGI commercial compiler.
+
+
LFortran
+
+[LFortran](https://lfortran.org) is a modern, interactive, LLVM-based Fortran
+compiler.
+Also available online at [dev.lfortran.org](https://dev.lfortran.org/) using a statically served, WASM based LFortran Compiler for running code in web browsers.
+
Commercial compilers
+
+
Intel oneAPI
+
+[Intel oneAPI](https://software.intel.com/content/www/us/en/develop/tools/oneapi/all-toolkits.html)
+is Intel's suite of compilers, tools, and libraries for Fortran, C, C++, and
+Python. Intel oneAPI HPC Toolkit provides
+[two Fortran compilers](https://software.intel.com/content/www/us/en/develop/articles/intel-oneapi-fortran-compiler-release-notes.html):
+
+- Intel Fortran Compiler (`ifx`), a new, LLVM-based compiler
+ that comes with full Fortran 2018 support. It also supports the [majority of OpenMP 5.0/5.1](https://www.intel.com/content/www/us/en/developer/articles/technical/fortran-language-and-openmp-features-in-ifx.html) including offload to Intel GPUs.
+ ifx can also offload `do concurrent` to Intel GPUs.
+- Intel Fortran Compiler Classic (`ifort`), a mature compiler
+ with full Fortran 2018 support, for CPUs only.
+
+The current version of Intel oneAPI is available for free, and support can be purchased.
+Currently the ifx compiler supports Linux and Windows platforms for x86-64 architectures. ifort supports Linux, Windows, and macOS.
+Community support is available for the free version at the [Intel Developer forum](https://community.intel.com/t5/Intel-Fortran-Compiler/bd-p/fortran-compiler).
+Optionally, you can purchase [Priority Support](https://www.intel.com/content/www/us/en/developer/get-help/priority-support.html) with additional benefits including access to previous versions of ifort and ifx.
+
+
NAG
+
+The latest [NAG Fortran Compiler](https://www.nag.com/nag-compiler)
+release (7.0) has extensive support for legacy and modern Fortran features including parallel programming with coarrays, as well as additional support for programming with OpenMP.
+
+The Compiler also provides significant support for Fortran 2018 (atomic
+operations, events and tasks, plus other smaller features), almost all of
+Fortran 2008, complete coverage of Fortran 2003, and all of OpenMP 3.1. All
+platforms include supporting tools for software development: source file
+polishers, dependency generator for module and include files, call-graph
+generator, interface builder and a precision unifier.
+
+
NVIDIA
+
+The [NVIDIA HPC SDK](https://developer.nvidia.com/hpc-sdk) C, C++, and Fortran compilers, former [PGI compilers](https://www.pgroup.com/products/index.htm), support GPU acceleration of HPC modeling and simulation applications with standard C++ and Fortran, OpenACC® directives, and CUDA®. GPU-accelerated math libraries maximize performance on common HPC algorithms, and optimized communications libraries enable standards-based multi-GPU and scalable systems programming.
+
+NVHPC compilers are available free of charge.
+Currently the compiler supports Linux platforms and x86_64, ppc64le and aarch64 architectures.
+Community support is available at the [HPC compiler forum](https://forums.developer.nvidia.com/c/accelerated-computing/hpc-compilers/nvc-nvc-and-nvfortran/313).
+
+
HPE / Cray
+
+The [Cray Compiling Environment (CCE)](https://www.cray.com/sites/default/files/SB-Cray-Programming-Environment.pdf)
+is the cornerstone innovation of Cray's adaptive computing paradigm. CCE builds
+on a well-developed and sophisticated Cray technology base that identifies
+regions of computation that are either sequential scalar, vector parallel or
+highly multithreaded. It includes optimizing compilers that automatically
+exploit the scalar, vector and multithreading hardware capabilities of the Cray
+system. CCE supports Fortran, C and C++.
+
+
IBM
+
+[IBM® XL Fortran](https://www.ibm.com/us-en/marketplace/xl-fortran-linux-compiler-power)
+for Linux is an industry standards-based programming tool used to develop large
+and complex applications in the Fortran programming language. It generates code
+that leverages the capabilities of the latest POWER9 architecture and maximizes
+your hardware utilization. IBM XL Fortran for Linux optimizes your
+infrastructure on IBM Power Systems™ in support of extensive numerical,
+scientific and high-performance computing.
+
+A community edition of the IBM XL compilers are available free of charge.
+The compilers support Linux and AIX platforms and ppc64le architectures.
+
+
AMD
+
+The [AMD Optimizing C/C++ Compiler (AOCC)](https://developer.amd.com/amd-aocc/)
+compiler system is a high performance, production quality code generation tool.
+The AOCC environment provides various options to developers when building and
+optimizing C, C++, and Fortran applications targeting 32-bit and 64-bit Linux®
+platforms. The AOCC compiler system offers a high level of advanced
+optimizations, multi-threading and processor support that includes global
+optimization, vectorization, inter-procedural analyses, loop transformations,
+and code generation. AMD also provides highly optimized libraries, which extract
+the optimal performance from each x86 processor core when utilized. The AOCC
+Compiler Suite simplifies and accelerates development and tuning for x86
+applications.
+
+The AOCC compilers are available free of charge and support Linux platforms with x86_64 architectures.
+
+
ARM
+
+[Linux user-space Fortran compiler](https://developer.arm.com/tools-and-software/server-and-hpc/compile/arm-compiler-for-linux/arm-fortran-compiler).
+Tailored for HPC and scientific codes, with support for popular Fortran and
+OpenMP standards and tuned for leading server-class Arm-based platforms. Built
+on the open source Flang front-end, and the LLVM‑based optimization and code
+generation back-end. Available as part of the Arm Compiler for Linux package.
+
+
Absoft
+
+[Absoft compilers](https://www.absoft.com/products/) include Pro Fortran
+delivering Absoft’s exclusive AP load balancing, AVX, OpenMP 3.1,
+extended Fortran 95 compiler with F2003 and F2008 features, FX3 graphical debugger,
+native tool suite integration, AMDAL HPC scientific and engineering library, and more.
+Pro Fortran includes Fast Data Visualization, an Absoft exclusive technology for
+graphical rendering and data output.
+
+
Oracle / Sun
+
+[Oracle C, C++, Fortran Compiler](https://www.oracle.com/application-development/technologies/developerstudio-features.html)
+is highly optimized for Oracle systems, on-premise and in the cloud
+
+- Advanced code generation technology for the latest Oracle SPARC and x86 based systems
+- Support for the latest industry standards, including C++14, C++11, C11 and OpenMP 4.0 and extensive GCC compatibility features
+- Automatic code analysis during compilation and automatic stack overflow protection at application runtime
+
+
Lahey / Fujitsu
+
+LF Professional v7.8 combines the 32/64-bit LGF Rainier compiler with the classic
+[Lahey/Fujitsu LF95](https://lahey.com/) compiler. LGF Rainier has full Fortran
+95/90/77 compliance with extensive support for the Fortran 2003 and 2008 standards.
+Lahey/Fujitsu LF95 offers best in class diagnostics.
+Includes the automatic-parallelizing GFortran compiler, Lahey/Fujitsu Fortran 95
+compiler, Visual Studio Fortran support, Winteracter WiSK Graphics package, and more.
+
+
Silverfrost FTN95
+
+[Silverfrost FTN95](https://www.silverfrost.com/) is a full Fortran 95 standards
+compliant compiler, capable of producing fast executables for Win32 and for
+Microsoft .NET. FTN95 ships with the world's best runtime checking and a great
+range of supporting software. All standard and many vendor-specific legacy
+language features are supported, so that Fortran projects may be any combination
+of Fortran 77, Fortran 90 and Fortran 95.
+Some features of Fortran 2003 and 2008 have been [added](https://www.silverfrost.com/19/ftn95/support/ftn95_revision_history.aspx).
+Silverfrost Fortran runs on Windows / x86_64. There is a free personal edition.
+
+
NEC
+
+[The Fortran compiler](https://www.nec.com/en/global/solutions/hpc/sx/tools.html)
+conforms to the Fortran-2003 standard (ISO/IEC 1539-1:2004) and supports many
+features from Fortran-2008 (ISO/IEC 1539-1:2010).
+
+
LCC
+
+[MCST C, C++, Fortran Compiler](http://mcst.ru/lcc) with full support of Fortran-95
+(ISO/IEC 1539:1997) and partial support of Fortran-2003 (ISO/IEC 1539:2004),
+Fortran-2008 (ISO/IEC 1539:2010) and Fortran-2018 (ISO/IEC 1539:2018). Used for
+russian processor architectures Elbrus (e2k) and SPARC (MCST-R), also a cross-compiler
+for x86_64 architecture is available.
+
+
Discontinued
+
+The following is a list of Fortran compilers that seem discontinued, so we do
+not list them above:
+
+- Apogee
+- Edinburgh Portable Compilers
+- Hewlett Packard
+- Watcom
+- PathScale
+- G95
+- Open64
+- Unisys
+
+
Note
+
+Please let us know if there is any compiler that is not listed, or if we listed
+a compiler in the Discontinued section and it is in fact actively maintained.
diff --git a/_sources/index.md.txt b/_sources/index.md.txt
new file mode 100644
index 000000000000..da1fe0e557a4
--- /dev/null
+++ b/_sources/index.md.txt
@@ -0,0 +1,162 @@
+---
+sd_hide_title: true
+---
+
+# The Fortran Programming Language
+
+:::{div} sd-text-center sd-fs-3 sd-font-weight-bold sd-text-primary
+Fortran High-performance parallel programming language
+:::
+
+:::{div} sd-text-center sd-fs-4
+{bdg-link-primary}`Get started `
+:::
+
+:::{div} sd-fs-3 sd-font-weight-bold sd-text-primary
+Features
+:::
+
+:::{div} sd-fs-5 sd-font-weight-bold
+High performance
+:::
+
+Fortran has been designed from the ground up for computationally intensive applications in science and engineering. Mature and battle-tested compilers and libraries allow you to write code that runs close to the metal, fast.
+
+:::{div} sd-fs-5 sd-font-weight-bold
+Statically and strongly typed
+:::
+
+Fortran is statically and strongly typed, which allows the compiler to catch many programming errors early on for you. This also allows the compiler to generate efficient binary code.
+
+:::{div} sd-fs-5 sd-font-weight-bold
+Easy to learn and use
+:::
+
+Fortran is a relatively small language that is surprisingly easy to learn and use. Expressing most mathematical and arithmetic operations over large arrays is as simple as writing them as equations on a whiteboard.
+
+:::{div} sd-fs-5 sd-font-weight-bold
+Versatile
+:::
+
+Fortran allows you to write code in a style that best fits your problem: imperative, procedural, array-oriented, object-oriented, or functional.
+
+:::{div} sd-fs-5 sd-font-weight-bold
+Natively parallel
+:::
+
+Fortran is a natively parallel programming language with intuitive array-like syntax to communicate data between CPUs. You can run almost the same code on a single CPU, on a shared-memory multicore system, or on a distributed-memory HPC or cloud-based system. Coarrays, teams, events, and collective subroutines allow you to express different parallel programming patterns that best fit your problem at hand.
+
+:::{div} sd-fs-3 sd-font-weight-bold sd-text-primary
+FAQ
+:::
+
+:::{div} sd-fs-5 sd-font-weight-bold
+What is the status of Fortran?
+:::
+
+Fortran is mature and under active development.
+The latest revision of the language is
+[Fortran 2018](https://isotc.iso.org/livelink/livelink?func=ll&objId=19441669&objAction=Open).
+The next revision,
+[Fortran 2023](https://wg5-fortran.org/N2151-N2200/N2194.pdf), is planned for
+release in 2023.
+There are over a dozen open source and proprietary
+[Fortran compilers](compilers).
+Further, open source projects like the
+[Standard Library](https://github.com/fortran-lang/stdlib)
+and the [Fortran Package Manager](https://fpm.fortran-lang.org) are
+under active development.
+
+:::{div} sd-fs-5 sd-font-weight-bold
+What is Fortran used for?
+:::
+
+Fortran is mostly used in domains that adopted computation early--science and engineering. These include numerical weather and ocean prediction, computational fluid dynamics, applied math, statistics, and finance. Fortran is the dominant language of High Performance Computing and is used to [benchmark the fastest supercomputers in the world](https://top500.org/).
+
+:::{div} sd-fs-5 sd-font-weight-bold
+Should I use Fortran for my new project?
+:::
+
+If you're writing a program or a library to perform fast arithmetic computation over large numeric arrays, Fortran is the optimal tool for the job.
+
+
+
Join us!
+
Mailing list
+
Subscribe to our mailing list
+to discuss anything Fortran related, announce Fortran projects, discuss development
+of core fortran-lang.org projects (stdlib, fpm), and get
+the latest news.
+
+Contribute code, report bugs and request features at
+GitHub.
+
+
+
+:::{div} sd-fs-3 sd-font-weight-bold sd-text-primary
+Make Fortran better
+:::
+
+:::::{grid} 2
+
+::::{grid-item-card}
+:columns: 6
+
+:::{div} sd-fs-5 sd-font-weight-bold
+Write proposals
+:::
+
+Have an idea about how to improve the language? You can write new proposals or contribute to existing proposals to the Fortran Standard Committee on
+[GitHub](https://github.com/j3-fortran/fortran_proposals).
+
+::::
+::::{grid-item-card}
+:columns: 6
+
+:::{div} sd-fs-5 sd-font-weight-bold
+Develop tools
+:::
+
+You can also help make Fortran better by contributing to its suite of tools, such as [Standard Library](https://github.com/fortran-lang/stdlib), [Package Manager](https://github.com/fortran-lang/fpm), [this website](https://github.com/fortran-lang/webpage).
+
+::::
+:::::
+
+:::::{grid} 2
+::::{grid-item-card}
+:columns: 12
+
+:::{div} sd-fs-5 sd-font-weight-bold
+Write Fortran software
+:::
+
+Or just write Fortran software for your research, business, or schoolwork. You can learn how to [get started here](learn).
+
+::::
+:::::
+
+:::{toctree}
+:hidden:
+
+Play
+learn
+roadmap
+compilers
+community
+packages
+news
+history
+
+:::
diff --git a/_sources/learn.md.txt b/_sources/learn.md.txt
new file mode 100644
index 000000000000..44faf4786cab
--- /dev/null
+++ b/_sources/learn.md.txt
@@ -0,0 +1,187 @@
+---
+sd_hide_title: true
+...
+
+# Learn
+
+:::{div} sd-text-center sd-fs-2 sd-font-weight-bold sd-text-primary
+Learn Fortran
+:::
+
+:::{div} sd-text-center sd-fs-3
+Learning resources for beginners and experts alike
+:::
+
+:::{div} sd-fs-3 sd-font-weight-bold sd-text-primary
+Getting Started
+:::
+
+::::::{grid} 1 1 2 2
+:gutter: 1
+
+:::::{grid-item}
+
+::::{grid} 1 1 1 1
+:gutter: 1
+
+:::{grid-item-card} {octicon}`info;1em;sd-text-info` New to Fortran
+:shadow: none
+
+Try the quickstart Fortran tutorial, to get an overview of the language syntax and capabilities.
+
+```{card}
+:link-type: url
+:link: quickstart/
+:class-card: sd-btn
+:class-body: sd-p-1 sd-text-center sd-font-weight-bold sd-text-info sd-btn-primary sd-text-light sd-btn
+:shadow: none
+
+{octicon}``book;1em;sd-text-info`` Quickstart tutorial
+```
+
+:::
+::::
+:::::
+
+:::::{grid-item}
+
+::::{grid} 1 1 1 1
+:gutter: 1
+
+:::{grid-item-card} {octicon}`bug;1em;sd-text-info` Looking for help
+:shadow: none
+
+Ask a question in the Fortran-lang discourse - a forum for friendly discussion of all things Fortran.
+
+```{card}
+:link-type: url
+:link: https://fortran-lang.discourse.group/
+:class-card: sd-btn
+:class-body: sd-p-1 sd-text-center sd-font-weight-bold sd-text-info sd-btn-primary sd-text-light sd-btn
+:shadow: none
+
+{octicon}``check-circle;1em;sd-text-info`` Fortran-lang Discourse
+```
+
+:::
+::::
+:::::
+
+:::::{grid-item}
+
+::::{grid} 1 1 1 1
+:gutter: 1
+
+:::{grid-item-card} {octicon}`play;1em;sd-text-info` Play with Fortran
+:shadow: none
+
+Get a taste of Fortran in an interactive playground in the browser.
+
+```{card}
+:link-type: url
+:link: https://play.fortran-lang.org/
+:class-card: sd-btn
+:class-body: sd-p-1 sd-text-center sd-font-weight-bold sd-text-info sd-btn-primary sd-text-light sd-btn
+:shadow: none
+
+{octicon}``play;1em;sd-text-info`` Fortran Playground
+```
+
+:::
+::::
+:::::
+::::::
+
+:::{div} sd-fs-3 sd-font-weight-bold sd-text-primary
+
+Mini-book Tutorials
+:::
+
+::::::{jinja} conf
+
+{% for category in categories %}
+:::{div} sd-fs-4 sd-font-weight-bold sd-text-primary
+
+{{category.name}}
+:::
+
+:::::{grid} 2
+{% for book in books %}
+{% if book.category == category.name %}
+
+::::{grid-item-card}
+:columns: 6
+:shadow: none
+
+:::{div} sd-fs-5 sd-font-weight-bold sd-text-primary
+
+{octicon}`book;1em;sd-text-info` {{book.title}}
+:::
+{{book.description}}
+::::
+{% endif %}
+{% endfor %}
+:::::
+{% endfor %}
+
+:::{div} sd-fs-3 sd-font-weight-bold sd-text-primary
+
+Other Resources
+:::
+
+:::{div} sd-fs-4 sd-font-weight-bold sd-text-primary
+
+On the web
+:::
+
+:::{jinja} conf
+
+{% for link in reference_links %}
+
+- [{{link.name}}]({{link.url}}) {{link.description}}
+
+{% endfor %}
+:::
+
+:::{div} sd-fs-4 sd-font-weight-bold sd-text-primary
+
+Online Courses
+:::
+
+:::{jinja} conf
+
+{% for course in reference_courses %}
+
+- [{{course.name}}]({{course.url}}) {{course.description}}
+
+{% endfor %}
+:::
+
+:::{div} sd-fs-4 sd-font-weight-bold sd-text-primary
+
+In print
+:::
+
+:::{jinja} conf
+
+{% for book in reference_books %}
+
+- {{book.author}}
+ {{book.year}}
+ [{{book.title}}]({{book.url}})
+ {{book.edition}}
+ {{book.location}}.
+ {{book.publisher}}
+
+{% endfor %}
+:::
+
+:::{toctree}
+:hidden:
+
+learn/os_setup/index
+learn/quickstart/index
+learn/building_programs/index
+learn/best_practices/index
+learn/intrinsics/index
+:::
diff --git a/_sources/learn/best_practices/allocatable_arrays.md.txt b/_sources/learn/best_practices/allocatable_arrays.md.txt
new file mode 100644
index 000000000000..83cac1b76bf5
--- /dev/null
+++ b/_sources/learn/best_practices/allocatable_arrays.md.txt
@@ -0,0 +1,127 @@
+# Allocatable Arrays
+
+The `allocatable` attribute provides a safe way for memory handling.
+In comparison to variables with `pointer` attribute the memory is managed
+automatically and will be deallocated automatically once the variable goes
+out-of-scope. Using `allocatable` variables removes the possibility to
+create memory leaks in an application.
+
+They can be used in subroutines to create scratch or work arrays, where
+automatic arrays would become too large to fit on the stack.
+
+```fortran
+real(dp), allocatable :: temp(:)
+allocate(temp(10))
+```
+
+The allocation status can be checked using the `allocated` intrinsic
+to avoid uninitialized access
+
+```fortran
+subroutine show_arr(arr)
+ integer, allocatable, intent(in) :: arr(:)
+
+ if (allocated(arr)) then
+ print *, arr
+ end if
+end subroutine show_arr
+```
+
+To allocate variables inside a procedure the dummy argument has to carry
+the `allocatable` attribute. Using it in combination with `intent(out)`
+will deallocate previous allocations before entering the procedure:
+
+```fortran
+subroutine foo(lam)
+ real(dp), allocatable, intent(out) :: lam(:)
+ allocate(lam(5))
+end subroutine foo
+```
+
+The allocated array can be used afterwards like a normal array
+
+```fortran
+real(dp), allocatable :: lam(:)
+call foo(lam)
+```
+
+An already allocated array cannot be allocated again without prior deallocation.
+Similarly, deallocation can only be invoked for allocated arrays. To reallocate
+an array use
+
+```fortran
+if (allocated(lam)) deallocate(lam)
+allocate(lam(10))
+```
+
+Passing allocated arrays to procedures does not require the `allocatable` attribute
+for the dummy arguments anymore.
+
+```fortran
+subroutine show_arr(arr)
+ integer, intent(in) :: arr(:)
+
+ print *, arr
+end subroutine show_arr
+
+subroutine proc
+ integer :: i
+ integer, allocatable :: arr
+
+ allocate(arr(5))
+
+ do i = 1, size(arr)
+ arr(i) = 2*i + 1
+ end do
+ call show_arr(arr)
+end subroutine proc
+```
+
+Passing an unallocated array in this context will lead to an invalid memory access.
+Allocatable arrays can be passed to `optional` dummy arguments -- if they are unallocated
+the argument will not be present. The `allocatable` attribute is not limited to
+arrays and can also be associated with scalars, which can be useful in combination
+with `optional` dummy arguments.
+
+Allocations can be moved between different arrays with `allocatable` attribute
+using the `move_alloc` intrinsic subroutine.
+
+```fortran
+subroutine resize(var, n)
+ real(wp), allocatable, intent(inout) :: var(:)
+ integer, intent(in), optional :: n
+ integer :: this_size, new_size
+ integer, parameter :: inital_size = 16
+
+ if (allocated(var)) then
+ this_size = size(var, 1)
+ call move_alloc(var, tmp)
+ else
+ this_size = initial_size
+ end if
+
+ if (present(n)) then
+ new_size = n
+ else
+ new_size = this_size + this_size/2 + 1
+ end if
+
+ allocate(var(new_size))
+
+ if (allocated(tmp)) then
+ this_size = min(size(tmp, 1), size(var, 1))
+ var(:this_size) = tmp(:this_size)
+ end if
+end subroutine resize
+```
+
+Finally, allocations do not initialize the array. The content of the uninitialized
+array is most likely just the bytes of whatever was previously at the respective address.
+The allocation supports initialization using the source attribute:
+
+```fortran
+real(dp), allocatable :: arr(:)
+allocate(arr(10), source=0.0_dp)
+```
+
+The `source` keyword supports scalar and array valued variables and constants.
diff --git a/_sources/learn/best_practices/arrays.md.txt b/_sources/learn/best_practices/arrays.md.txt
new file mode 100644
index 000000000000..6b547769b906
--- /dev/null
+++ b/_sources/learn/best_practices/arrays.md.txt
@@ -0,0 +1,196 @@
+# Arrays
+
+Arrays are a central object in Fortran. The creation of dynamic sized arrays
+is discussed in the [allocatable arrays section](./allocatable_arrays.html).
+
+To pass arrays to procedures four ways are available
+
+1. _assumed-shape_ arrays
+2. _assumed-rank_ arrays
+3. _explicit-shape_ arrays
+4. _assumed-size_ arrays
+
+The preferred way to pass arrays to procedures is as _assumed-shape_ arrays
+
+```fortran
+subroutine f(r)
+ real(dp), intent(out) :: r(:)
+ integer :: n, i
+ n = size(r)
+ do i = 1, n
+ r(i) = 1.0_dp / i**2
+ end do
+end subroutine f
+```
+
+Higher-dimensional arrays can be passed in a similar way.
+
+```fortran
+subroutine g(A)
+ real(dp), intent(in) :: A(:, :)
+ ...
+end subroutine g
+```
+
+The array is simply passed by
+
+```fortran
+real(dp) :: r(5)
+call f(r)
+```
+
+In this case no array copy is done, which has the advantage that the shape and size
+information is automatically passed along and checked at compile and optionally at
+runtime.
+Similarly, array strides can be passed without requiring a copy of the array but as
+_assumed-shape_ descriptor:
+
+```fortran
+real(dp) :: r(10)
+call f(r(1:10:2))
+call f(r(2:10:2))
+```
+
+This should always be your default way of passing arrays in and out of subroutines.
+Avoid passing arrays as whole slices, as it obfuscates the actual intent of the code:
+
+```fortran
+real(dp) :: r(10)
+call f(r(:))
+```
+
+In case more general arrays should be passed to a procedure the _assumed-rank_
+functionality introduced in the Fortran 2018 standard can be used
+
+```fortran
+subroutine h(r)
+ real(dp), intent(in) :: r(..)
+ select rank(r)
+ rank(1)
+ ! ...
+ rank(2)
+ ! ...
+ end select
+end subroutine h
+```
+
+The actual rank can be queried at runtime using the `select rank` construct.
+This easily allows to create more generic functions that have to deal with
+different array ranks.
+
+_Explicit-shape_ arrays can be useful for returning data from functions.
+Most of their functionality can be provided by _assumed-shape_ and _assumed-rank_
+arrays but they find frequent use for interfacing with C or in legacy Fortran
+procedures, therefore they will be discussed briefly here.
+
+To use _explicit-shape_ arrays, the dimension has to be passed explicitly as dummy
+argument like in the example below
+
+```fortran
+subroutine f(n, r)
+ integer, intent(in) :: n
+ real(dp), intent(out) :: r(n)
+ integer :: i
+ do i = 1, n
+ r(i) = 1.0_dp / i**2
+ end do
+end subroutine
+```
+
+For high-dimensional arrays additional indices have to be passed.
+
+```fortran
+subroutine g(m, n, A)
+ integer, intent(in) :: m, n
+ real(dp), intent(in) :: A(m, n)
+ ...
+end subroutine
+```
+
+The routines can be invoked by
+
+```fortran
+real(dp) :: r(5), s(3, 4)
+call f(size(r), r)
+call g(size(s, 1), size(s, 2), s)
+```
+
+Note that the shape is not checked, so the following would be legal code
+that will potentially yield incorrect results:
+
+```fortran
+real(dp) :: s(3, 4)
+call g(size(s), 1, s) ! s(12, 1) in g
+call g(size(s, 2), size(s, 1), s) ! s(4, 3) in g
+```
+
+In this case the memory layout is preserved but the shape is changed.
+Also, _explicit-shape_ arrays require contiguous memory and will create temporary
+arrays in case non-contiguous array strides are passed.
+
+To return an array from a function with _explicit-shape_ use
+
+```fortran
+function f(n) result(r)
+ integer, intent(in) :: n
+ real(dp) :: r(n)
+ integer :: i
+ do i = 1, n
+ r(i) = 1.0_dp / i**2
+ end do
+end function
+```
+
+Finally, there are _assumed-size_ arrays, which provide the least compile-time and run-time
+checking and can be found frequently in legacy code. They should be avoided
+in favour of _assumed-shape_ or _assumed-rank_ arrays.
+An _assumed-size_ array dummy argument is identified by an asterisk as the last dimension,
+this disables the usage of this array with many intrinsic functions, like `size` or
+`shape`.
+
+To check for the correct size and shape of an _assumed-shape_ array the `size` and
+`shape` intrinsic functions can be used to query for those properties
+
+```fortran
+if (size(r) /= 4) error stop "Incorrect size of 'r'"
+if (any(shape(r) /= [2, 2])) error stop "Incorrect shape of 'r'"
+```
+
+Note that `size` returns the total size of all dimensions. To obtain the shape of
+a specific dimension add it as second argument to the function.
+
+Arrays can be initialized by using an array constructor
+
+```fortran
+integer :: r(5)
+r = [1, 2, 3, 4, 5]
+```
+
+The array constructor can be annotated with the type of the constructed array
+
+```fortran
+real(dp) :: r(5)
+r = [real(dp) :: 1, 2, 3, 4, 5]
+```
+
+Implicit do loops can be used inside an array constructor as well
+
+```fortran
+integer :: i
+real(dp) :: r(5)
+r = [(real(i**2, dp), i = 1, size(r))]
+```
+
+In order for the array to start with different index than 1, do:
+
+```fortran
+subroutine print_eigenvalues(kappa_min, lam)
+ integer, intent(in) :: kappa_min
+ real(dp), intent(in) :: lam(kappa_min:)
+
+ integer :: kappa
+ do kappa = kappa_min, ubound(lam, 1)
+ print *, kappa, lam(kappa)
+ end do
+end subroutine print_eigenvalues
+```
diff --git a/_sources/learn/best_practices/callbacks.md.txt b/_sources/learn/best_practices/callbacks.md.txt
new file mode 100644
index 000000000000..d4f0dadae677
--- /dev/null
+++ b/_sources/learn/best_practices/callbacks.md.txt
@@ -0,0 +1,89 @@
+# Callbacks
+
+A callback is a function that is passed as an argument to another function.
+
+The preferred way of creating such a callback is to provide an _abstract interface_
+declaring the signature of the callback. This allows to use compile time checks
+for the passed callback.
+
+```fortran
+module integrals
+ use types, only: dp
+ implicit none
+ private
+ public :: simpson, integrable_function
+
+ abstract interface
+ function integrable_function(x) result(func)
+ import :: dp
+ real(dp), intent(in) :: x
+ real(dp) :: func
+ end function
+ end interface
+
+contains
+
+ function simpson(f, a, b) result(s)
+ real(dp), intent(in) :: a, b
+ procedure(integrable_function) :: f
+ real(dp) :: s
+
+ s = (b-a) / 6 * (f(a) + 4*f((a+b)/2) + f(b))
+ end function simpson
+
+end module integrals
+```
+
+The function can then be used with a callback by importing the module
+as shown in the following example
+
+```fortran
+module demo_functions
+ use types, only: dp
+ implicit none
+ private
+ public :: test_integral
+
+contains
+
+ subroutine test_integral(a, k)
+ real(dp), intent(in) :: a, k
+
+ print *, simpson(f, 0._dp, pi)
+ print *, simpson(f, 0._dp, 2*pi)
+ contains
+
+ function f(x) result(y)
+ real(dp), intent(in) :: x
+ real(dp) :: y
+ y = a*sin(k*x)
+ end function f
+ end subroutine test_integral
+
+end module demo_functions
+```
+
+Exporting the abstract interface allows you to create procedure pointers with the
+correct signature and also to extend the callback further as shown here
+
+```fortran
+module demo_integrals
+ use types, only: dp
+ use integrals, only: simpson, integrable_function
+ implicit none
+ private
+ public :: simpson2, integrable_function
+
+contains
+
+ function simpson2(f, a, b) result(s)
+ real(dp), intent(in) :: a, b
+ procedure(integrable_function) :: f
+ real(dp) :: s
+ real(dp) :: mid
+ mid = (a + b)/2
+ s = simpson(f, a, mid) + simpson(f, mid, b)
+ end function simpson2
+
+end module demo_integrals
+```
diff --git a/_sources/learn/best_practices/element_operations.md.txt b/_sources/learn/best_practices/element_operations.md.txt
new file mode 100644
index 000000000000..c1692990c951
--- /dev/null
+++ b/_sources/learn/best_practices/element_operations.md.txt
@@ -0,0 +1,124 @@
+# Element-wise Operations on Arrays
+
+There are three approaches to perform element-wise operations on arrays when using subroutines and functions:
+
+- `elemental` procedures
+- _explicit-shape_ arrays
+- implementing the operation for vectors and write simple wrapper
+ subroutines (that use `reshape` internally) for each array shape
+
+In the first approach, one uses the `elemental` keyword to create a
+function like this:
+
+```fortran
+real(dp) elemental function nroot(n, x) result(y)
+ integer, intent(in) :: n
+ real(dp), intent(in) :: x
+ y = x**(1._dp / n)
+end function
+```
+
+All arguments (in and out) must be scalars. You can then use this
+function with arrays of any (compatible) shape, for example:
+
+```fortran
+print *, nroot(2, 9._dp)
+print *, nroot(2, [1._dp, 4._dp, 9._dp, 10._dp])
+print *, nroot(2, reshape([1._dp, 4._dp, 9._dp, 10._dp], [2, 2]))
+print *, nroot([2, 3, 4, 5], [1._dp, 4._dp, 9._dp, 10._dp])
+print *, nroot([2, 3, 4, 5], 4._dp)
+```
+
+The output will be:
+
+```fortran
+3.0000000000000000
+1.0000000000000000 2.0000000000000000 3.0000000000000000 3.1622776601683795
+1.0000000000000000 2.0000000000000000 3.0000000000000000 3.1622776601683795
+1.0000000000000000 1.5874010519681994 1.7320508075688772 1.5848931924611136
+2.0000000000000000 1.5874010519681994 1.4142135623730951 1.3195079107728942
+```
+
+In the above, typically `n` is a parameter and `x` is the array of an
+arbitrary shape, but as you can see, Fortran does not care as long as
+the final operation makes sense (if one argument is an array, then the
+other arguments must be either arrays of the same shape or scalars). If
+it does not, you will get a compiler error.
+
+The `elemental` keyword implies the `pure` keyword, so the procedure
+must be pure. It results that `elemental procedures` can only use `pure` procedures and have no side effects.
+
+If the elemental procedure algorithm can be made faster using array
+operations inside, or if for some reasons the arguments must be arrays of
+incompatible shapes, then one should use the other two approaches. One
+can make `nroot` operate on a vector and write a simple wrapper for
+other array shapes, e.g.:
+
+```fortran
+function nroot(n, x) result(y)
+ integer, intent(in) :: n
+ real(dp), intent(in) :: x(:)
+ real(dp) :: y(size(x))
+ y = x**(1._dp / n)
+end function
+
+function nroot_0d(n, x) result(y)
+ integer, intent(in) :: n
+ real(dp), intent(in) :: x
+ real(dp) :: y
+ real(dp) :: tmp(1)
+ tmp = nroot(n, [x])
+ y = tmp(1)
+end function
+
+function nroot_2d(n, x) result(y)
+ integer, intent(in) :: n
+ real(dp), intent(in) :: x(:, :)
+ real(dp) :: y(size(x, 1), size(x, 2))
+ y = reshape(nroot(n, reshape(x, [size(x)])), [size(x, 1), size(x, 2)])
+end function
+```
+
+And use as follows:
+
+```fortran
+print *, nroot_0d(2, 9._dp)
+print *, nroot(2, [1._dp, 4._dp, 9._dp, 10._dp])
+print *, nroot_2d(2, reshape([1._dp, 4._dp, 9._dp, 10._dp], [2, 2]))
+```
+
+This will print:
+
+```fortran
+3.0000000000000000
+1.0000000000000000 2.0000000000000000 3.0000000000000000 3.1622776601683795
+1.0000000000000000 2.0000000000000000 3.0000000000000000 3.1622776601683795
+```
+
+Or one can use _explicit-shape_ arrays as
+follows:
+
+```fortran
+function nroot(n, k, x) result(y)
+ integer, intent(in) :: n, k
+ real(dp), intent(in) :: x(k)
+ real(dp) :: y(k)
+ y = x**(1._dp / n)
+end function
+```
+
+Use as follows:
+
+```fortran
+print *, nroot(2, 1, [9._dp])
+print *, nroot(2, 4, [1._dp, 4._dp, 9._dp, 10._dp])
+print *, nroot(2, 4, reshape([1._dp, 4._dp, 9._dp, 10._dp], [2, 2]))
+```
+
+The output is the same as before:
+
+```fortran
+3.0000000000000000
+1.0000000000000000 2.0000000000000000 3.0000000000000000 3.1622776601683795
+1.0000000000000000 2.0000000000000000 3.0000000000000000 3.1622776601683795
+```
diff --git a/_sources/learn/best_practices/file_io.md.txt b/_sources/learn/best_practices/file_io.md.txt
new file mode 100644
index 000000000000..d399cfa8ccf9
--- /dev/null
+++ b/_sources/learn/best_practices/file_io.md.txt
@@ -0,0 +1,97 @@
+# File Input/Output
+
+In Fortran files are managed by unit identifiers. Interaction with the filesystem
+mainly happens through the `open` and `inquire` built-in procedures.
+Generally, the workflow is to open a file to a unit identifier, read and/or write
+to it and close it again.
+
+```fortran
+integer :: io
+open(newunit=io, file="log.txt")
+! ...
+close(io)
+```
+
+By default the file will be created if it is not existing already and opened for
+both reading and writing. Writing to an existing file will start in the first
+record (line) and therefore overwrite the file by default.
+
+To create a read-only access to a file the `status` and `action` have to be
+specified with
+
+```fortran
+integer :: io
+open(newunit=io, file="log.txt", status="old", action="read")
+read(io, *) a, b
+close(io)
+```
+
+In case the file is not present a runtime error will occur. To check for the existence
+of a file prior to opening it the `inquire` function can be used
+
+```fortran
+logical :: exists
+inquire(file="log.txt", exist=exists)
+if (exists) then
+ ! ...
+end if
+```
+
+Alternatively, the `open` procedure can return an optional _iostat_ and _iomsg_:
+
+```fortran
+integer :: io, stat
+character(len=512) :: msg
+open(newunit=io, file="log.txt", status="old", action="read", &
+ iostat=stat, iomsg=msg)
+if (stat /= 0) then
+ print *, trim(msg)
+end if
+```
+
+Note that _iomsg_ requires a fixed-length character variable with sufficient storage
+size to hold the error message.
+
+Similarly, writing to a file happens by using the _status_ and _action_ keyword.
+To create a new file use
+
+```fortran
+integer :: io
+open(newunit=io, file="log.txt", status="new", action="write")
+write(io, *) a, b
+close(io)
+```
+
+Alternatively, `status="replace"` can be used to overwrite an existing file.
+It is highly recommended to first check for the existence of a file before deciding
+on the _status_ to use.
+To append to an output file the _position_ keyword can be specified explicitly with
+
+```fortran
+integer :: io
+open(newunit=io, file="log.txt", position="append", &
+ & status="old", action="write")
+write(io, *) size(v)
+write(io, *) v(:)
+close(io)
+```
+
+To reset the position in a file the built-in procedures `rewind` and `backspace`
+can be used. `rewind` will reset to the first record (line), while `backspace` will
+return to the previous record (line).
+
+Finally, to delete a file the file has to be opened and can be deleted after closing
+with
+
+```fortran
+logical :: exists
+integer :: io, stat
+inquire(file="log.txt", exist=exists)
+if (exists) then
+ open(file="log.txt", newunit=io, iostat=stat)
+ if (stat == 0) close(io, status="delete", iostat=stat)
+end if
+```
+
+A useful IO feature is scratch files, which can be opened with `status="scratch"`.
+They are automatically deleted after closing the unit identifier.
diff --git a/_sources/learn/best_practices/floating_point.md.txt b/_sources/learn/best_practices/floating_point.md.txt
new file mode 100644
index 000000000000..145567015a46
--- /dev/null
+++ b/_sources/learn/best_practices/floating_point.md.txt
@@ -0,0 +1,90 @@
+# Floating Point Numbers
+
+The default representation of floating point numbers is using single precision
+(usually 32 bits / 4 bytes). For most applications a higher precision is required.
+For this purpose a custom kind parameter can be defined.
+The recommended way of defining kind parameters is to use
+
+```fortran
+integer, parameter :: dp = selected_real_kind(15)
+```
+
+For many purposes it also suffices to directly infer the kind parameter from
+a literal like here
+
+```fortran
+integer, parameter :: dp = kind(0.0d0)
+```
+
+or to rename the imported kind parameter from the `iso_fortran_env` module
+
+```fortran
+use, intrinsic :: iso_fortran_env, only : dp => real64
+```
+
+For some insightful thoughts on kind parameters see
+Doctor Fortran in it takes all KINDs.
+
+It is recommended to have a central module to define kind parameters and include
+them with use as necessary. An example for such a module is given with
+
+```fortran
+!> Numerical storage size parameters for real and integer values
+module kind_parameter
+ implicit none
+ public
+
+ !> Single precision real numbers, 6 digits, range 10⁻³⁷ to 10³⁷-1; 32 bits
+ integer, parameter :: sp = selected_real_kind(6, 37)
+ !> Double precision real numbers, 15 digits, range 10⁻³⁰⁷ to 10³⁰⁷-1; 64 bits
+ integer, parameter :: dp = selected_real_kind(15, 307)
+ !> Quadruple precision real numbers, 33 digits, range 10⁻⁴⁹³¹ to 10⁴⁹³¹-1; 128 bits
+ integer, parameter :: qp = selected_real_kind(33, 4931)
+
+ !> Char length for integers, range -2⁷ to 2⁷-1; 8 bits
+ integer, parameter :: i1 = selected_int_kind(2)
+ !> Short length for integers, range -2¹⁵ to 2¹⁵-1; 16 bits
+ integer, parameter :: i2 = selected_int_kind(4)
+ !> Length of default integers, range -2³¹ to 2³¹-1; 32 bits
+ integer, parameter :: i4 = selected_int_kind(9)
+ !> Long length for integers, range -2⁶³ to 2⁶³-1; 64 bits
+ integer, parameter :: i8 = selected_int_kind(18)
+
+end module kind_parameter
+```
+
+Floating point constants should always be declared including a kind parameter suffix:
+
+```fortran
+real(dp) :: a, b, c
+a = 1.0_dp
+b = 3.5_dp
+c = 1.34e8_dp
+```
+
+It is safe to assign integers to floating point numbers without losing accuracy:
+
+```fortran
+real(dp) :: a
+a = 3
+```
+
+In order to impose floating point division (as opposed to integer
+division `3/4` equal to `0`), one can convert the integer to a floating
+point number by:
+
+```fortran
+real(dp) :: a
+a = real(3, dp) / 4 ! 'a' is equal to 0.75_dp
+```
+
+or simply separate the integer division with multiplication by `1.0_dp`
+
+```fortran
+real(dp) :: a
+a = 3 * 1.0_dp / 4 ! 'a' is equal to 0.75_dp
+```
+
+To print floating point numbers without losing precision use the unlimited
+format specifier `(g0)` or the exponential representation `(es24.16e3)`,
+which will give you 17 significant digits of printout.
diff --git a/_sources/learn/best_practices/index.md.txt b/_sources/learn/best_practices/index.md.txt
new file mode 100644
index 000000000000..b84773007a2c
--- /dev/null
+++ b/_sources/learn/best_practices/index.md.txt
@@ -0,0 +1,26 @@
+:::{sectionauthor} Ondřej Čertík, John Pask, Jed Brown, Matthew Emmett, Juan Luis Cano Rodríguez, Neil Carlson, Andrea Vigliotti, Pierre Haessig, Vincent Magnin, Sebastian Ehlert, Jeremie Vandenplas
+:::
+
+# Fortran Best Practices
+
+This mini-book collects a modern canonical way of doing things in Fortran.
+It serves as a style guide and best practice recommendation for popular topics
+and common tasks. Generally, a canonical solution or pattern is presented and
+discussed. It is meant for programmers with basic familiarity of the Fortran syntax
+and programming in general.
+
+```{toctree}
+:maxdepth: 2
+:hidden:
+Fortran Style Guide
+Floating Point Numbers
+Integer Division
+Modules and Programs
+Arrays
+Multidimensional Arrays
+Element-wise Operations on Array
+Allocatable Arrays
+File Input/Output
+Callbacks
+Type Casting in Callbacks
+```
diff --git a/_sources/learn/best_practices/integer_division.md.txt b/_sources/learn/best_practices/integer_division.md.txt
new file mode 100644
index 000000000000..51fb0330a90c
--- /dev/null
+++ b/_sources/learn/best_practices/integer_division.md.txt
@@ -0,0 +1,34 @@
+# Integer Division
+
+Fortran distinguishes between floating point and integer arithmetic. It is
+important to note that division for integers is always using integer
+arithmetic. Furthermore, while Fortran uses the standard order-of-operations
+(e.g. multiplication and division preceed addition and subtraction, in the
+absence of parenthesis), operations of the same precedence are evaluated from
+left to right. Consider the following example for integer division of an odd
+number:
+
+```fortran
+integer :: n
+n = 3
+print *, n / 2 ! prints 1
+print *, n*(n + 1)/2 ! prints 6
+print *, n/2*(n + 1) ! prints 4 (left-to-right evaluation order)
+n = -3
+print *, n / 2 ! prints -1
+```
+
+Be careful about whether you want to actually use integer arithmetic
+in this context. If you want to use floating point arithmetic instead
+make sure to cast to reals before using the division operator, or separate
+the integers by multiplying by `1.0_dp`:
+
+```fortran
+integer :: n
+n = 3
+print *, real(n, dp) / 2 ! prints 1.5
+print *, n * 1.0_dp / 2 ! prints 1.5
+n = -3
+print *, real(n, dp) / 2 ! prints -1.5
+print *, n * 1.0_dp / 2 ! prints -1.5
+```
diff --git a/_sources/learn/best_practices/modules_programs.md.txt b/_sources/learn/best_practices/modules_programs.md.txt
new file mode 100644
index 000000000000..565883bd220a
--- /dev/null
+++ b/_sources/learn/best_practices/modules_programs.md.txt
@@ -0,0 +1,144 @@
+# Modules and Programs
+
+Modules are the preferred way create modern Fortran libraries and applications.
+As a convention, one source file should always contain only one module, while
+the module name should match the filepath to allow easy navigation in larger
+projects. It is also recommended to prefix module names with the library name
+to avoid name clashes when used as dependency in other projects.
+
+An example for such a module file is given here
+
+```fortran
+!> Interface to TOML processing library.
+!>
+!> ...
+module fpm_toml
+ use fpm_error, only : error_t, fatal_error, file_not_found_error
+ use fpm_strings, only : string_t
+ use tomlf, only : toml_table, toml_array, toml_key, toml_stat, get_value, &
+ & set_value, toml_parse, toml_error, new_table, add_table, add_array, &
+ & toml_serializer, len
+ implicit none
+ private
+
+ public :: read_package_file
+ public :: toml_table, toml_array, toml_key, toml_stat, get_value, set_value
+ public :: new_table, add_table, add_array, len
+ public :: toml_error, toml_serializer, toml_parse
+
+contains
+
+ !> Process the configuration file to a TOML data structure
+ subroutine read_package_file(table, manifest, error)
+ !> TOML data structure
+ type(toml_table), allocatable, intent(out) :: table
+ !> Name of the package configuration file
+ character(len=*), intent(in) :: manifest
+ !> Error status of the operation
+ type(error_t), allocatable, intent(out) :: error
+ ! ...
+ end subroutine read_package_file
+
+end module fpm_toml
+```
+
+There are a few things in this example module to highlight. First, every module
+starts with comments documenting the purpose and content of the module.
+Similarly, every procedure starts with a comment briefly describing its
+purpose and the intent of the dummy arguments. Documentation is one of the most
+important parts of creating long-living software, regardless of language.
+
+Second, imports (_use_) and exports (_public_) are explicitly given, this
+allows on a glance at the module source to check the used and available
+procedures, constants and derived types. The imports are usually limited
+to the module scope rather than reimported in every procedure or interface
+scope. Similarly, exports are made explicitly by adding a _private_ statement
+on a single line and explicitly listing all exported symbols in _public_
+statements.
+
+Finally, the `implicit none` statement works for the whole module and there
+is no need to repeat it within each procedure.
+
+Variables inside a module are static (_implicitly saved_). It is highly
+recommended to limit the usage of module variables to constant expressions,
+like parameters or enumerators only or export them as _protected_ rather
+than _public_.
+
+Submodules can be used to break long dependency chains and shorten recompilation
+cascades in Fortran programs. They also offer the possibility to provide specialized
+and optimized implementations without requiring the use of preprocessor.
+
+An example from the Fortran standard library is the quadrature module, which
+only defines interfaces to module procedures, but no implementations
+
+```fortran
+!> Numerical integration
+!>
+!> ...
+module stdlib_quadrature
+ use stdlib_kinds, only: sp, dp, qp
+ implicit none
+ private
+
+ public :: trapz
+ ! ...
+
+ !> Integrates sampled values using trapezoidal rule
+ interface trapz
+ pure module function trapz_dx_dp(y, dx) result(integral)
+ real(dp), intent(in) :: y(:)
+ real(dp), intent(in) :: dx
+ real(dp) :: integral
+ end function trapz_dx_dp
+ module function trapz_x_dp(y, x) result(integral)
+ real(dp), intent(in) :: y(:)
+ real(dp), intent(in) :: x(:)
+ real(dp) :: integral
+ end function trapz_x_dp
+ end interface trapz
+
+ ! ...
+end module stdlib_quadrature
+```
+
+While the implementation is provided in separate submodules like the one for the
+trapezoidal integration rule given here.
+
+```fortran
+!> Actual implementation of the trapezoidal integration rule
+!>
+!> ...
+submodule (stdlib_quadrature) stdlib_quadrature_trapz
+ use stdlib_error, only: check
+ implicit none
+
+contains
+
+ pure module function trapz_dx_dp(y, dx) result(integral)
+ real(dp), intent(in) :: y(:)
+ real(dp), intent(in) :: dx
+ real(dp) :: integral
+ integer :: n
+
+ n = size(y)
+ select case (n)
+ case (0:1)
+ integral = 0.0_dp
+ case (2)
+ integral = 0.5_dp*dx*(y(1) + y(2))
+ case default
+ integral = dx*(sum(y(2:n-1)) + 0.5_dp*(y(1) + y(n)))
+ end select
+ end function trapz_dx_dp
+
+ ! ...
+end submodule stdlib_quadrature_trapz
+```
+
+Note that the module procedures do not have to be implemented in the same submodule.
+Several submodules can be used to reduce the compilation load for huge modules.
+
+Finally, when setting up a program, it is recommended to keep the actual implementations
+in the program body at minimum. Reusing implementations from modules allows you to write
+reusable code and focus the program unit on conveying user input to the respective library
+functions and objects.
diff --git a/_sources/learn/best_practices/multidim_arrays.md.txt b/_sources/learn/best_practices/multidim_arrays.md.txt
new file mode 100644
index 000000000000..70d36b2aa676
--- /dev/null
+++ b/_sources/learn/best_practices/multidim_arrays.md.txt
@@ -0,0 +1,66 @@
+# Multidimensional Arrays
+
+Multidimensional arrays are stored in column-major order. This means the
+left-most (inner-most) index addresses elements contiguously.
+From a practical point this means that the array slice `V(:, 1)` is
+contiguous, while the stride between elements in the slice `V(1, :)`
+is the dimension of the columns. This is important when passing array
+slices to procedures which expect to work on contiguous data.
+
+The locality of the memory is important to consider depending on
+your application, usually when performing operations on a multidimensional
+the sequential access should always advance in unity strides.
+
+In the following example the inverse distance between two sets of points
+is evaluated. Note that the points are stored contiguously in the arrays
+`xyz1`/`xyz2`, while the inner-most loop is advancing the left-most
+index of the matrix `a`.
+
+```fortran
+subroutine coulomb_matrix(xyz1, xyz2, a)
+ real(dp), intent(in) :: xyz1(:, :)
+ real(dp), intent(in) :: xyz2(:, :)
+ real(dp), intent(out) :: a(:, :)
+ integer :: i, j
+ do i = 1, size(a, 2)
+ do j = 1, size(a, 1)
+ a(j, i) = 1.0_dp/norm2(xyz1(:, j) - xyz2(:, i))
+ end do
+ end do
+end subroutine coulomb_matrix
+```
+
+Another example would be the contraction of the third dimension of a rank
+three array:
+
+```fortran
+do i = 1, size(amat, 3)
+ do j = 1, size(amat, 2)
+ do k = 1, size(amat, 1)
+ cmat(k, j) = cmat(k, j) + amat(k, j, i) * bvec(i)
+ end do
+ end do
+end do
+```
+
+Contiguous array slices can be used in array-bound remapping to allow usage
+of higher rank arrays as lower rank arrays without requiring to reshape
+and potentially create a temporary copy of the array.
+
+For example this can be used to contract the third dimension of a rank
+three array using a matrix-vector operation:
+
+```fortran
+subroutine matmul312(amat, bvec, cmat)
+ real(dp), contiguous, intent(in), target :: amat(:, :, :)
+ real(dp), intent(in) :: bvec(:)
+ real(dp), contiguous, intent(out), target :: cmat(:, :)
+ real(dp), pointer :: aptr(:, :)
+ real(dp), pointer :: cptr(:)
+
+ aptr(1:size(amat, 1)*size(amat, 2), 1:size(amat, 3)) => amat
+ cptr(1:size(cmat)) => cmat
+
+ cptr = matmul(aptr, bvec)
+end subroutine matmul312
+```
diff --git a/_sources/learn/best_practices/style_guide.md.txt b/_sources/learn/best_practices/style_guide.md.txt
new file mode 100644
index 000000000000..7539c822c6d7
--- /dev/null
+++ b/_sources/learn/best_practices/style_guide.md.txt
@@ -0,0 +1,51 @@
+# Fortran Style Guide
+
+## Naming Convention
+
+Ultimately this is a matter of preference. Here is a style guide that we
+like and that seems to be prevalent in most scientific codes (as well as
+the Fortran standard library), and you are welcome to follow it.
+
+1. Use lowercase for all Fortran constructs (`do`, `subroutine`,
+ `module`, ...).
+2. Follow short mathematical notation for mathematical
+ variables/functions (`Ylm`, `Gamma`, `gamma`, `Enl`, `Rnl`, ...).
+3. For other names use all lowercase: try to keep names to one or two
+ syllables; if more are required, use underscores to clarify
+ (`sortpair`, `whitechar`, `meshexp`, `numstrings`, `linspace`,
+ `meshgrid`, `argsort`, `spline`, `spline_interp`,
+ `spline_interpolate`, `stoperr`, `stop_error`, `meshexp_der`).
+
+For example "spline interpolation" can be shortened to
+`spline_interpolation`, `spline_interpolate`, `spline_interp`, `spline`,
+but not to `splineint` ("int" could mean integration, integer, etc. ---
+too much ambiguity, even in the clear context of a computational code).
+This is in contrast to `get_argument()` where `getarg()` is perfectly
+clean and clear.
+
+The above are general guidelines. In general, choosing the right name
+certainly depends on the word being truncated as to whether the first
+syllable is sufficient. Usually it is but clearly not always. Thus some
+thought should go into step "try to keep names to 2 syllables or less"
+since it can really affect the indicativeness and simplicity. Simple
+consistent naming rules are a real help in this regard -- for both
+collaboration and for one's own sanity when going back to some old code
+you haven't seen in while.
+
+## Indentation
+
+Use a consistent indentation to make your code readable.
+The amount of indentation is a matter of preference, the most common choices
+are two, three or four spaces.
+
+## Comparison to Other Languages
+
+On the other hand, in most of the rest of the programming world, where
+the main focus is, in one form or another, on defining and using large
+sets of complex objects, with tons of properties and behaviors, known
+only in the code in which they are defined (as opposed to defined by the
+same notation throughout the literature), it makes more sense to use
+longer, more descriptive names. The naming conventions one sees used in
+more general-purpose languages such as C++ and Python, therefore, are
+perfectly consistent with their more general-purpose missions. But
+Fortran has a different mission (numerical scientific computing).
diff --git a/_sources/learn/best_practices/type_casting.md.txt b/_sources/learn/best_practices/type_casting.md.txt
new file mode 100644
index 000000000000..fdcbd9c8bb69
--- /dev/null
+++ b/_sources/learn/best_practices/type_casting.md.txt
@@ -0,0 +1,482 @@
+# Type Casting in Callbacks
+
+There are essentially five different ways to do type casting, each with its own
+advantages and disadvantages.
+
+The methods I, II and V can be used both in C and Fortran. The methods
+III and IV are only available in Fortran. The method VI is obsolete and
+should not be used.
+
+## Work Arrays
+
+Pass a "work array" which is packed with everything needed by
+the caller and unpacked by the called routine. This is the old way --
+e.g., how LAPACK does it.
+
+Integrator:
+
+```fortran
+module integrals
+ use types, only: dp
+ implicit none
+ private
+ public simpson
+
+contains
+
+real(dp) function simpson(f, a, b, data) result(s)
+ real(dp), intent(in) :: a, b
+ interface
+ real(dp) function func(x, data)
+ use types, only: dp
+ implicit none
+ real(dp), intent(in) :: x
+ real(dp), intent(inout) :: data(:)
+ end function
+ end interface
+ procedure(func) :: f
+ real(dp), intent(inout) :: data(:)
+ s = (b-a) / 6 * (f(a, data) + 4*f((a+b)/2, data) + f(b, data))
+end function
+
+end module
+```
+
+Usage:
+
+```fortran
+module test
+ use types, only: dp
+ use integrals, only: simpson
+ implicit none
+ private
+ public foo
+
+contains
+
+real(dp) function f(x, data) result(y)
+ real(dp), intent(in) :: x
+ real(dp), intent(inout) :: data(:)
+ real(dp) :: a, k
+ a = data(1)
+ k = data(2)
+ y = a*sin(k*x)
+end function
+
+subroutine foo(a, k)
+ real(dp) :: a, k
+ real(dp) :: data(2)
+ data(1) = a
+ data(2) = k
+ print *, simpson(f, 0._dp, pi, data)
+ print *, simpson(f, 0._dp, 2*pi, data)
+end subroutine
+
+end module
+```
+
+## General Structure
+
+Define a general structure which encompass the variations you
+actually need (or are even remotely likely to need going forward). This
+single structure type can then change if needed as future
+needs/ideas permit but won't likely need to change from passing, say,
+real numbers to, say, and instantiation of a text editor.
+
+Integrator:
+
+```fortran
+module integrals
+ use types, only: dp
+ implicit none
+ private
+ public simpson, context
+
+ type context
+ ! This would be adjusted according to the problem to be solved.
+ ! For example:
+ real(dp) :: a, b, c, d
+ integer :: i, j, k, l
+ real(dp), pointer :: x(:), y(:)
+ integer, pointer :: z(:)
+ end type
+
+contains
+
+real(dp) function simpson(f, a, b, data) result(s)
+ real(dp), intent(in) :: a, b
+ interface
+ real(dp) function func(x, data)
+ use types, only: dp
+ implicit none
+ real(dp), intent(in) :: x
+ type(context), intent(inout) :: data
+ end function
+ end interface
+ procedure(func) :: f
+ type(context), intent(inout) :: data
+ s = (b-a) / 6 * (f(a, data) + 4*f((a+b)/2, data) + f(b, data))
+end function
+
+end module
+```
+
+Usage:
+
+```fortran
+module test
+ use types, only: dp
+ use integrals, only: simpson, context
+ implicit none
+ private
+ public foo
+
+contains
+
+real(dp) function f(x, data) result(y)
+ real(dp), intent(in) :: x
+ type(context), intent(inout) :: data
+ real(dp) :: a, k
+ a = data%a
+ k = data%b
+ y = a*sin(k*x)
+end function
+
+subroutine foo(a, k)
+ real(dp) :: a, k
+ type(context) :: data
+ data%a = a
+ data%b = k
+ print *, simpson(f, 0._dp, pi, data)
+ print *, simpson(f, 0._dp, 2*pi, data)
+end subroutine
+
+end module
+```
+
+There is only so much flexibility really needed. For example, you could
+define two structure types for this purpose, one for Schroedinger and
+one for Dirac. Each would then be sufficiently general and contain all
+the needed pieces with all the right labels.
+
+Point is: it needn't be "one abstract type to encompass all" or bust.
+There are natural and viable options between "all" and "none".
+
+## Private Module Variables
+
+Hide the variable arguments completely by passing in module variables.
+
+Integrator:
+
+```fortran
+module integrals
+ use types, only: dp
+ implicit none
+ private
+ public simpson
+
+contains
+
+real(dp) function simpson(f, a, b) result(s)
+ real(dp), intent(in) :: a, b
+ interface
+ real(dp) function func(x)
+ use types, only: dp
+ implicit none
+ real(dp), intent(in) :: x
+ end function
+ end interface
+ procedure(func) :: f
+ s = (b-a) / 6 * (f(a) + 4*f((a+b)/2) + f(b))
+end function
+
+end module
+```
+
+Usage:
+
+```fortran
+module test
+ use types, only: dp
+ use integrals, only: simpson
+ implicit none
+ private
+ public foo
+
+ real(dp) :: global_a, global_k
+
+contains
+
+real(dp) function f(x) result(y)
+ real(dp), intent(in) :: x
+ y = global_a*sin(global_k*x)
+end function
+
+subroutine foo(a, k)
+ real(dp) :: a, k
+ global_a = a
+ global_k = k
+ print *, simpson(f, 0._dp, pi)
+ print *, simpson(f, 0._dp, 2*pi)
+end subroutine
+
+end module
+```
+
+However it is best to avoid such global variables -- even though really
+just semi-global -- if possible. But sometimes it may be the simplest
+cleanest way. However, with a bit of thought, usually there is a better,
+safer, more explicit way along the lines of II or IV.
+
+## Nested functions
+
+Integrator:
+
+```fortran
+module integrals
+ use types, only: dp
+ implicit none
+ private
+ public simpson
+
+contains
+
+real(dp) function simpson(f, a, b) result(s)
+ real(dp), intent(in) :: a, b
+ interface
+ real(dp) function func(x)
+ use types, only: dp
+ implicit none
+ real(dp), intent(in) :: x
+ end function
+ end interface
+ procedure(func) :: f
+ s = (b-a) / 6 * (f(a) + 4*f((a+b)/2) + f(b))
+end function
+
+end module
+```
+
+Usage:
+
+```fortran
+subroutine foo(a, k)
+use integrals, only: simpson
+real(dp) :: a, k
+print *, simpson(f, 0._dp, pi)
+print *, simpson(f, 0._dp, 2*pi)
+
+contains
+
+real(dp) function f(x) result(y)
+real(dp), intent(in) :: x
+y = a*sin(k*x)
+end function f
+
+end subroutine foo
+```
+
+## Using type(c_ptr) Pointer
+
+In C, one would use the `void *` pointer. In Fortran, one can use
+`type(c_ptr)` for exactly the same purpose.
+
+Integrator:
+
+```fortran
+module integrals
+ use types, only: dp
+ use iso_c_binding, only: c_ptr
+ implicit none
+ private
+ public simpson
+
+contains
+
+real(dp) function simpson(f, a, b, data) result(s)
+ real(dp), intent(in) :: a, b
+ interface
+ real(dp) function func(x, data)
+ use types, only: dp
+ implicit none
+ real(dp), intent(in) :: x
+ type(c_ptr), intent(in) :: data
+ end function
+ end interface
+ procedure(func) :: f
+ type(c_ptr), intent(in) :: data
+ s = (b-a) / 6 * (f(a, data) + 4*f((a+b)/2, data) + f(b, data))
+end function
+
+end module
+```
+
+Usage:
+
+```fortran
+module test
+ use types, only: dp
+ use integrals, only: simpson
+ use iso_c_binding, only: c_ptr, c_loc, c_f_pointer
+ implicit none
+ private
+ public foo
+
+ type f_data
+ ! Only contains data that we need for our particular callback.
+ real(dp) :: a, k
+ end type
+
+contains
+
+real(dp) function f(x, data) result(y)
+ real(dp), intent(in) :: x
+ type(c_ptr), intent(in) :: data
+ type(f_data), pointer :: d
+ call c_f_pointer(data, d)
+ y = d%a * sin(d%k * x)
+end function
+
+subroutine foo(a, k)
+ real(dp) :: a, k
+ type(f_data), target :: data
+ data%a = a
+ data%k = k
+ print *, simpson(f, 0._dp, pi, c_loc(data))
+ print *, simpson(f, 0._dp, 2*pi, c_loc(data))
+end subroutine
+
+end module
+```
+
+As always, with the advantages of such re-casting, as Fortran lets you
+do if you really want to, come also the disadvantages that fewer
+compile- and run-time checks are possible to catch errors; and with
+that, inevitably more leaky, bug-prone code. So one always has to
+balance the costs and benefits.
+
+Usually, in the context of scientific programming, where the main thrust
+is to represent and solve precise mathematical formulations (as opposed
+to create a GUI with some untold number of buttons, drop-downs, and
+other interface elements), simplest, least bug-prone, and fastest is to
+use one of the previous approaches.
+
+## transfer() Intrinsic Function
+
+Before Fortran 2003, the only way to do type casting was using the
+`transfer` intrinsic function. It is functionally equivalent to the
+method V, but more verbose and more error prone. It is now obsolete and
+one should use the method V instead.
+
+Examples:
+
+
+
+
+
+
+
+## Object Oriented Approach
+
+The module:
+
+```fortran
+module integrals
+
+ use types, only: dp
+ implicit none
+ private
+
+ public :: integrand, simpson
+
+ ! User extends this type
+ type, abstract :: integrand
+ contains
+ procedure(func), deferred :: eval
+ end type
+
+ abstract interface
+ function func(this, x) result(fx)
+ import :: integrand, dp
+ class(integrand) :: this
+ real(dp), intent(in) :: x
+ real(dp) :: fx
+ end function
+ end interface
+
+contains
+
+real(dp) function simpson(f, a, b) result(s)
+ class(integrand) :: f
+ real(dp), intent(in) :: a, b
+ s = ((b-a)/6) * (f%eval(a) + 4*f%eval((a+b)/2) + f%eval(b))
+end function
+
+end module
+```
+
+The abstract type prescribes exactly what the integration routine needs,
+namely a method to evaluate the function, but imposes nothing else on
+the user. The user extends this type, providing a concrete
+implementation of the eval type bound procedure and adding necessary
+context data as components of the extended type.
+
+Usage:
+
+```fortran
+module example_usage
+
+ use types, only: dp
+ use integrals, only: integrand, simpson
+ implicit none
+ private
+
+ public :: foo
+
+ type, extends(integrand) :: my_integrand
+ real(dp) :: a, k
+ contains
+ procedure :: eval => f
+ end type
+
+contains
+
+function f(this, x) result(fx)
+ class(my_integrand) :: this
+ real(dp), intent(in) :: x
+ real(dp) :: fx
+ fx = this%a*sin(this%k*x)
+end function
+
+subroutine foo(a, k)
+ real(dp) :: a, k
+ type(my_integrand) :: my_f
+ my_f%a = a
+ my_f%k = k
+ print *, simpson(my_f, 0.0_dp, 1.0_dp)
+ print *, simpson(my_f, 0.0_dp, 2.0_dp)
+end subroutine
+
+end module
+```
+
+## Complete Example of void \* vs type(c_ptr) and transfer()
+
+Here are three equivalent codes: one in C using `void *` and two codes
+in Fortran using `type(c_ptr)` and `transfer()`:
+
+| Language | Method | Link |
+| --------------- | -------------------- | --------------------------------- |
+| C | `void *` | |
+| Fortran | `type(c_ptr)` | |
+| Fortran | `transfer()` | |
+
+The C code uses the standard C approach for writing extensible libraries
+that accept callbacks and contexts. The two Fortran codes show how to do
+the same. The `type(c_ptr)` method is equivalent to the C version and
+that is the approach that should be used.
+
+The `transfer()` method is here for completeness only (before Fortran
+2003, it was the only way) and it is a little cumbersome, because the
+user needs to create auxiliary conversion functions for each of his
+types. As such, the `type(c_ptr)` method should be used instead.
diff --git a/_sources/learn/building_programs/build_tools.md.txt b/_sources/learn/building_programs/build_tools.md.txt
new file mode 100644
index 000000000000..c867ae55ab24
--- /dev/null
+++ b/_sources/learn/building_programs/build_tools.md.txt
@@ -0,0 +1,542 @@
+# Build tools
+
+Compiling your Fortran projects by hand can become quite complicated depending
+on the number of source files and the interdependencies through the module.
+Supporting different compilers and linkers or different platforms can become
+increasingly complicated unless the right tools are used to automatically
+perform those tasks.
+
+Depending on the size of your project and the purpose of project different
+options for the build automation can be used.
+
+First, your integrated development environment probably provides a way to build
+your program. A popular cross-platform tool is Microsoft's
+Visual Studio Code,
+but others exist, such as
+Atom,
+Eclipse Photran,
+and Code::Blocks.
+They offer a graphical user-interface, but are often very specific for the
+compiler and platform.
+
+For smaller projects, the rule based build system `make` is a common
+choice. Based on the rules defined it can perform task like (re)compiling
+object files from updated source files, creating libraries and linking
+executables.
+To use `make` for your project you have to encode those rules in `Makefile`,
+which defines the interdependencies of all the final program, the intermediary
+object files or libraries and the actual source files.
+For a short introduction see [the guide on `make`](#using-make-as-build-tool).
+
+Maintenance tools like autotools and CMake can generate Makefiles or
+Visual Studio project files via a high-level description. They abstract
+away from the compiler and platform specifics.
+
+Which of those tools are the best choice for your projects depends on many factors.
+Choose a build tool you are comfortable working with, it should not get in your
+way while developing. Spending more time on working against your build tools
+than doing actual development work can quickly become frustrating.
+
+Also, consider the accessibility of your build tools.
+If it is restricted to a specific integrated development environment, can all
+developers on your project access it?
+If you are using a specific build system, does it work on all platforms you
+are developing for?
+How large is the entry barrier of your build tools? Consider the learning curve
+for the build tools, the perfect build tool will be of no use, if you have to
+learn a complex programming language first to add a new source file.
+Finally, consider what other project are using, those you are depending on and
+those that use (or will use) your project as dependency.
+
+## Using make as build tool
+
+The most well-known and commonly used build system is called `make`.
+It performs actions following rules defined in a configuration file
+called `Makefile` or `makefile`, which usually leads to compiling a program
+from the provided source code.
+
+::::{tip}
+For an in-depth `make` tutorial lookup its info page. There is an online version of this info page, available.
+::::
+
+We will start with the basics from your clean source directory. Create and open
+the file `Makefile`, we start with a simple rule called _all_:
+
+```make
+all:
+ echo "$@"
+```
+
+After saving the `Makefile` run it by executing `make` in the same directory.
+You should see the following output:
+
+ echo "all"
+ all
+
+First, we note that `make` is substituting `$@` for the name of the rule,
+the second thing to note is that `make` is always printing the command it is
+running, finally, we see the result of running `echo "all"`.
+
+::::{note}
+We call the entry point of our `Makefile` always _all_ by convention, but you can choose whatever name you like.
+::::
+
+::::{note}
+You should not have noticed it if your editor is working correctly,
+but you have to indent the content of a rule with a tab character.
+In case you have problems running the above `Makefile` and see an error like
+
+ Makefile:2: *** missing separator. Stop.
+
+The indentation is probably not correct. In this case replace the indentation
+in the second line with a tab character.
+
+::::
+
+Now we want to make our rules more complicated, therefore we add another rule:
+
+```make
+PROG := my_prog
+
+all: $(PROG)
+ echo "$@ depends on $^"
+
+$(PROG):
+ echo "$@"
+```
+
+Note how we declare variables in `make`, you should always declare your local
+variables with `:=`. To access the content of a variable we use the `$(...)`,
+note that we have to enclose the variable name in parenthesis.
+
+::::{note}
+The declaration of variables is usually done with `:=`, but `make` does
+support _recursively expanded_ variables as well with `=`.
+Normally, the first kind of declaration is wanted, as they are more predictable
+and do not have a runtime overhead from the recursive expansion.
+::::
+
+We introduced a dependency of the rule all, namely the content of the variable
+`PROG`, also we modified the printout, we want to see all the dependencies
+of this rule, which are stored in the variable `$^`.
+Now for the new rule which we name after the value of the variable `PROG`,
+it does the same thing we did before for the rule _all_, note how the value
+of `$@` is dependent on the rule it is used in.
+
+Again check by running the `make`, you should see:
+
+ echo "my_prog"
+ my_prog
+ echo "all depends on my_prog"
+ all depends on my_prog
+
+The dependency has been correctly resolved and evaluated before performing
+any action on the rule _all_.
+Let's run only the second rule: type `make my_prog` and you will only find
+the first two lines in your terminal.
+
+The next step is to perform some real actions with `make`, we take
+the source code from the previous chapter here and add new rules to our
+`Makefile`:
+
+```make
+OBJS := tabulate.o functions.o
+PROG := my_prog
+
+all: $(PROG)
+
+$(PROG): $(OBJS)
+ gfortran -o $@ $^
+
+$(OBJS): %.o: %.f90
+ gfortran -c -o $@ $<
+```
+
+We define `OBJS` which stands for object files, our program depends on
+those `OBJS` and for each object file we create a rule to make them from
+a source file.
+The last rule we introduced is a pattern matching rule, `%` is the common
+pattern between `tabulate.o` and `tabulate.f90`, which connects our object file
+`tabulate.o` to the source file `tabulate.f90`.
+With this set, we run our compiler, here `gfortran` and translate the source
+file into an object file, we do not create an executable yet due to the `-c`
+flag.
+Note the usage of the `$<` for the first element of the dependencies here.
+
+After compiling all the object files we attempt to link the program, we do not
+use a linker directly, but `gfortran` to produce the executable.
+
+Now we run the build script with `make`:
+
+ gfortran -c -o tabulate.o tabulate.f90
+ tabulate.f90:2:7:
+
+ 2 | use user_functions
+ | 1
+ Fatal Error: Cannot open module file ‘user_functions.mod’ for reading at (1): No such file or directory
+ compilation terminated.
+ make: *** [Makefile:10: tabulate.f90.o] Error 1
+
+We remember that we have dependencies between our source files, therefore we add
+this dependency explicitly to the `Makefile` with
+
+```make
+tabulate.o: functions.o
+```
+
+Now we can retry and find that the build is working correctly. The output should
+look like
+
+ gfortran -c -o functions.o functions.f90
+ gfortran -c -o tabulate.o tabulate.f90
+ gfortran -o my_prog tabulate.o functions.o
+
+You should find _four_ new files in the directory now.
+Run `my_prog` to make sure everything works as expected.
+Let's run `make` again:
+
+ make: Nothing to be done for 'all'.
+
+Using the timestamps of the executable `make` was able to determine, it is
+newer than both `tabulate.o` and `functions.o`, which in turn are newer than
+`tabulate.f90` and `functions.f90`.
+Therefore, the program is already up-to-date with the latest code and no
+action has to be performed.
+
+In the end, we will have a look at a complete `Makefile`.
+
+```make
+# Disable all of make's built-in rules (similar to Fortran's implicit none)
+MAKEFLAGS += --no-builtin-rules --no-builtin-variables
+# configuration
+FC := gfortran
+LD := $(FC)
+RM := rm -f
+# list of all source files
+SRCS := tabulate.f90 functions.f90
+PROG := my_prog
+
+OBJS := $(addsuffix .o, $(SRCS))
+
+.PHONY: all clean
+all: $(PROG)
+
+$(PROG): $(OBJS)
+ $(LD) -o $@ $^
+
+$(OBJS): %.o: %
+ $(FC) -c -o $@ $<
+
+# define dependencies between object files
+tabulate.f90.o: functions.f90.o user_functions.mod
+
+# rebuild all object files in case this Makefile changes
+$(OBJS): $(MAKEFILE_LIST)
+
+clean:
+ $(RM) $(filter %.o, $(OBJS)) $(wildcard *.mod) $(PROG)
+```
+
+Since you are starting with `make` we highly recommend to always include
+the first line, like with Fortran's `implicit none` we do not want to have
+implicit rules messing up our `Makefile` in surprising and harmful ways.
+
+Next, we have a configuration section where we define variables, in case you
+want to switch out your compiler, it can be easily done here.
+We also introduced the `SRCS` variable to hold all source files, which is
+more intuitive than specifying object files.
+We can easily create the object files by appending a `.o` suffix using the
+functions `addsuffix`.
+The `.PHONY` is a special rule, which should be used for all entry points
+of your `Makefile`, here we define two entry point, we already know _all_,
+the new _clean_ rule deletes all the build artifacts again such that we indeed
+start with a clean directory.
+
+Also, we slightly changed the build rule for the object files to account for
+appending the `.o` suffix instead of substituting it.
+Notice that we still need to explicitly define the interdependencies in the
+`Makefile`. We also added a dependency for the object files on the `Makefile`
+itself, in case you change the compiler, this will allow you to safely rebuild.
+
+Now you know enough about `make` to use it for building small projects.
+If you plan to use `make` more extensively, we have compiled a few tips
+for you as well.
+
+::::{tip}
+In this guide, we avoided and disabled a lot of the commonly used `make`
+features that can be particularly troublesome if not used correctly, we highly
+recommend staying away from the builtin rules and variables if you do not feel
+confident working with `make`, but explicitly declare all variables and rules.
+
+You will find that `make` is capable tool to automate short interdependent
+workflows and to build small projects. But for larger projects, you will
+probably soon run against some of it limitations. Usually, `make` is therefore
+not used alone but combined with other tools to generate the `Makefile`
+completely or in parts.
+::::
+
+### Recursively expanded variables
+
+Commonly seen in many projects are recursively expanded variables (declared with
+`=` instead of `:=`). Recursive expansion of your variables allows out-of-order
+declaration and other neat tricks with `make`, since they are defined as rules,
+which are expanded at runtime, rather than being defined while parsing.
+
+For example, declaring and using your Fortran flags with this snippet will work
+completely fine:
+
+```make
+all:
+ echo $(FFLAGS)
+
+FFLAGS = $(include_dirs) -O
+include_dirs += -I./include
+include_dirs += -I/opt/some_dep/include
+```
+
+You should find the expected (or maybe unexpected) printout after running `make`
+
+ echo -I./include -I/opt/some_dep/include -O
+ -I./include -I/opt/some_dep/include -O
+
+::::{tip}
+appending with `+=` to an undefined variable will produce a recursively expanded variable with this state being inherited for all further appending.
+::::
+
+While, it seems like an interesting feature to use, it tends to lead to
+surprising and unexpected outcomes. Usually, when defining variables like your
+compiler, there is little reason to actually use the recursive expansion at all.
+
+The same can easily be achieved using the `:=` declaration:
+
+```make
+all:
+ echo $(FFLAGS)
+
+include_dirs := -I./include
+include_dirs += -I/opt/some_dep/include
+FFLAGS := $(include_dirs) -O
+```
+
+::::{important}
+always think of a `Makefile` as a whole set of rules, it must be parsed completely before any rule can be evaluated.
+::::
+
+You can use whatever kind of variables you like most, mixing them should be done
+carefully, of course. It is important to be aware of the differences between the
+two kinds and the respective implications.
+
+### Comments and whitespace
+
+There are some caveats with whitespace and comments, which might pop up from
+time to time when using `make`. First, `make` does not know of any data
+type except for strings and the default separator is just a space.
+This means `make` will give a hard time trying to build a project which
+has spaces in file names. If you encounter such case, renaming the file
+is possibly the easiest solution at hand.
+
+Another common problem is leading and trailing whitespace, once introduced,
+`make` will happily carry it along and it does in fact make a difference
+when comparing strings in `make`.
+
+Those can be introduced by comments like
+
+```make
+prefix := /usr # path to install location
+install:
+ echo "$(prefix)/lib"
+```
+
+While the comment will be correctly removed by `make`, the trailing two spaces
+are now part of the variable content. Run `make` and check that this is indeed
+the case:
+
+```
+echo "/usr /lib"
+/usr /lib
+```
+
+To solve this issue, you can either move the comment, or strip the whitespace with
+the `strip` function instead. Alternatively, you could try to `join` the
+strings.
+
+```make
+prefix := /usr # path to install location
+install:
+ echo "$(strip $(prefix))/lib"
+ echo "$(join $(join $(prefix), /), lib)"
+```
+
+All in all, none of this solutions will make your `Makefile` more readable,
+therefore, it is prudent to pay extra attention to whitespace and comments when
+writing and using `make`.
+
+## The meson build system
+
+After you have learned the basics of `make`, which we call a low-level build
+system, we will introduce `meson`, a high-level build system.
+While you specify in a low-level build system how to build your program,
+you can use a high-level build system to specify what to build.
+A high-level build system will deal for you with how and generate
+build files for a low-level build system.
+
+There are plenty of high-level build systems available, but we will focus on
+`meson` because it is constructed to be particularly user friendly.
+The default low-level build-system of `meson` is called `ninja`.
+
+Let's have a look at a complete `meson.build` file:
+
+
+
+```python
+project('my_proj', 'fortran', meson_version: '>=0.49')
+executable('my_prog', files('tabulate.f90', 'functions.f90'))
+```
+
+And we are already done, the next step is to configure our low-level build system
+with `meson setup build`, you should see output somewhat similar to this
+
+ The Meson build system
+ Version: 0.53.2
+ Source dir: /home/awvwgk/Examples
+ Build dir: /home/awvwgk/Examples/build
+ Build type: native build
+ Project name: my_proj
+ Project version: undefined
+ Fortran compiler for the host machine: gfortran (gcc 9.2.1 "GNU Fortran (Arch Linux 9.2.1+20200130-2) 9.2.1 20200130")
+ Fortran linker for the host machine: gfortran ld.bfd 2.34
+ Host machine cpu family: x86_64
+ Host machine cpu: x86_64
+ Build targets in project: 1
+
+ Found ninja-1.10.0 at /usr/bin/ninja
+
+The provided information at this point is already more detailed than anything
+we could have provided in a `Makefile`, let's run the build with
+`ninja -C build`, which should show something like
+
+ [1/4] Compiling Fortran object 'my_prog@exe/functions.f90.o'.
+ [2/4] Dep hack
+ [3/4] Compiling Fortran object 'my_prog@exe/tabulate.f90.o'.
+ [4/4] Linking target my_prog.
+
+Find and test your program at `build/my_prog` to ensure it works correctly.
+We note the steps `ninja` performed are the same we would have coded up in a
+`Makefile` (including the dependency), yet we did not have to specify them,
+have a look at your `meson.build` file again:
+
+```python
+project('my_proj', 'fortran', meson_version: '>=0.49')
+executable('my_prog', files('tabulate.f90', 'functions.f90'))
+```
+
+We only specified that we have a Fortran project (which happens to require
+a certain version of `meson` for the Fortran support) and told `meson`
+to build an executable `my_prog` from the files `tabulate.f90` and
+`functions.f90`.
+We had not to tell `meson` how to build the project, it figured this out
+by itself.
+
+::::{note}
+`meson` is a cross-platform build system, the project you just specified
+for your program can be used to compile binaries for your native operating
+system or to cross-compile your project for other platforms.
+Similarly, the `meson.build` file is portable and will work on different
+platforms as well.
+::::
+
+The documentation of `meson` can be found at the
+meson-build webpage.
+
+## Creating a CMake project
+
+Similar to `meson` CMake is a high-level build system as well and commonly
+used to build Fortran projects.
+
+::::{note}
+CMake follows a slightly different strategy and provides you with a complete
+programming language to create your build files.
+This is has the advantage that you can do almost everything with CMake,
+but your CMake build files can also become as complex as the program you are
+building.
+::::
+
+Start by creating the file `CMakeLists.txt` with the content
+
+```cmake
+cmake_minimum_required(VERSION 3.7)
+project("my_proj" LANGUAGES "Fortran")
+add_executable("my_prog" "tabulate.f90" "functions.f90")
+```
+
+Similar to `meson` we are already done with our CMake build file.
+We configure our low-level build files with `cmake -B build -G Ninja`,
+you should see output similar to this
+
+ -- The Fortran compiler identification is GNU 10.2.0
+ -- Detecting Fortran compiler ABI info
+ -- Detecting Fortran compiler ABI info - done
+ -- Check for working Fortran compiler: /usr/bin/f95 - skipped
+ -- Checking whether /usr/bin/f95 supports Fortran 90
+ -- Checking whether /usr/bin/f95 supports Fortran 90 - yes
+ -- Configuring done
+ -- Generating done
+ -- Build files have been written to: /home/awvwgk/Examples/build
+
+You might be surprised that CMake tries to use the compiler `f95`, fortunately
+this is just a symbolic link to `gfortran` on most systems and not the actual
+`f95` compiler.
+To give CMake a better hint you can export the environment variable `FC=gfortran`
+rerunning should show the correct compiler name now
+
+ -- The Fortran compiler identification is GNU 10.2.0
+ -- Detecting Fortran compiler ABI info
+ -- Detecting Fortran compiler ABI info - done
+ -- Check for working Fortran compiler: /usr/bin/gfortran - skipped
+ -- Checking whether /usr/bin/gfortran supports Fortran 90
+ -- Checking whether /usr/bin/gfortran supports Fortran 90 - yes
+ -- Configuring done
+ -- Generating done
+ -- Build files have been written to: /home/awvwgk/Example/build
+
+In a similar manner you could use your Intel Fortran compiler instead to build
+your project (set `FC=ifort`).
+
+CMake provides support for several low-level build files, since the default is
+platform specific, we will just use `ninja` since we already used it together
+with `meson`. As before, build your project with `ninja -C build`:
+
+ [1/6] Building Fortran preprocessed CMakeFiles/my_prog.dir/functions.f90-pp.f90
+ [2/6] Building Fortran preprocessed CMakeFiles/my_prog.dir/tabulate.f90-pp.f90
+ [3/6] Generating Fortran dyndep file CMakeFiles/my_prog.dir/Fortran.dd
+ [4/6] Building Fortran object CMakeFiles/my_prog.dir/functions.f90.o
+ [5/6] Building Fortran object CMakeFiles/my_prog.dir/tabulate.f90.o
+ [6/6] Linking Fortran executable my_prog
+
+Find and test your program at `build/my_prog` to ensure it works correctly.
+The steps `ninja` performed are somewhat different, because there is usually
+more than one way to write the low-level build files to accomplish the task
+of building a project. Fortunately, we do not have to concern ourselves but have
+our build system handle those details for us.
+
+Finally, we will shortly recap on our complete `CMakeLists.txt` to specify
+our project:
+
+```cmake
+cmake_minimum_required(VERSION 3.7)
+project("my_proj" LANGUAGES "Fortran")
+add_executable("my_prog" "tabulate.f90" "functions.f90")
+```
+
+We specified that we have a Fortran project and told CMake to create an executable
+`my_prog` from the files `tabulate.f90` and `functions.f90`.
+CMake knows the details how to build the executable from the specified sources,
+so we do not have to worry about the actual steps in the build process.
+
+::::{tip}
+CMake's official reference can be found at the
+CMake webpage.
+It is organised in manpages, which are also available with your local CMake
+installation as well using `man cmake`. While it covers all functionality of
+CMake, it sometimes covers them only very briefly.
+::::
diff --git a/_sources/learn/building_programs/compiling_source.md.txt b/_sources/learn/building_programs/compiling_source.md.txt
new file mode 100644
index 000000000000..2778e64da5dd
--- /dev/null
+++ b/_sources/learn/building_programs/compiling_source.md.txt
@@ -0,0 +1,103 @@
+# Compiling the source code
+
+The first step in the build process is to compile the source code. The
+output from this step is generally known as the object code — a set of
+instructions for the computer generated from the human-readable source
+code. Different compilers will produce different object codes from the
+same source code and the naming conventions are different.
+
+The consequences:
+
+- If you use a particular compiler for one source file, you need to use
+ the same compiler (or a compatible one) for all other pieces. After
+ all, a program may be built from many different source files and the
+ compiled pieces have to cooperate.
+- Each source file will be compiled and the result is stored in a file
+ with an extension like ".o" or ".obj". It is these object files that are
+ the input for the next step: the link process.
+
+Compilers are complex pieces of software: they have to understand the
+language in much more detail and depth than the average programmer. They
+also need to understand the inner working of the computer. And then,
+over the years they have been extended with numerous options to
+customise the compilation process and the final program that will be
+built.
+
+But the basics are simple enough. Take the gfortran compiler, part of
+the GNU compiler collection. To compile a simple program as the one
+above, that consists of one source file, you run the following command,
+assuming the source code is stored in the file "hello.f90":
+
+```shell
+$ gfortran -c hello.f90
+```
+
+This results in a file "hello.o" (as the gfortran compiler uses ".o" as
+the extension for the object files).
+
+The option "-c" means: only compile the source files. If you were to
+leave it out, then the default action of the compiler is to compile the
+source file and start the linker to build the actual executable program.
+The command:
+
+```shell
+$ gfortran hello.f90
+```
+
+results in an executable file, "a.out" on Linux or "a.exe" on
+Windows.
+
+Some remarks:
+
+- The compiler may complain about the contents of the source file, if it
+ finds something wrong with it — a typo for instance or an unknown
+ keyword. In that case the compilation process is broken off and you will
+ not get an object file or an executable program. For instance, if
+ the word "program" was inadvertently typed as "prgoram":
+
+```shell
+$ gfortran hello3.f90
+hello.f90:1:0:
+
+ 1 | prgoram hello
+ |
+Error: Unclassifiable statement at (1)
+hello3.f90:3:17:
+
+ 3 | end program hello
+ | 1
+Error: Syntax error in END PROGRAM statement at (1)
+f951: Error: Unexpected end of file in 'hello.f90'
+```
+
+Using this compilation report you can correct the source code and try
+again.
+
+- The step without "-c" can only succeed if the source file contains a
+ main program — characterised by the `program` statement in Fortran.
+ Otherwise the link step will complain about a missing "symbol", something
+ along these lines:
+
+```shell
+$ gfortran hello2.f90
+/usr/lib/../lib64/crt1.o: In function `_start':
+(.text+0x20): undefined reference to `main'
+collect2: error: ld returned 1 exit status
+```
+
+The file "hello2.f90" is almost the same as the file "hello.f90", except
+that the keyword `program` has been replaced by the keyword `subroutine`.
+
+The above examples of output from the compiler will differ per compiler
+and platform on which it runs. These examples come from the gfortran
+compiler running in a Cygwin environment on Windows.
+
+Compilers also differ in the options they support, but in general:
+
+- Options for optimising the code — resulting in faster programs or
+ smaller memory footprints;
+- Options for checking the source code — checks that a variable is not
+ used before it has been given a value, for instance or checks if some
+ extension to the language is used;
+- Options for the location of include or module files, see below;
+- Options for debugging.
diff --git a/_sources/learn/building_programs/distributing.md.txt b/_sources/learn/building_programs/distributing.md.txt
new file mode 100644
index 000000000000..c2806a97e764
--- /dev/null
+++ b/_sources/learn/building_programs/distributing.md.txt
@@ -0,0 +1,136 @@
+# Distributing your programs
+
+When you distribute your programs, there are a number of options you can
+choose from:
+
+1. Distribute the entire source code
+2. Distribute a pre-built executable program
+3. Distribute static or dynamic libraries that people can use
+
+**Option 1: Distribute the entire source code**
+
+By far the simplest — for you as a programmer — is this one: you leave it
+up to the user to build it on their own machine. Unfortunately, that
+means you will have to have a user-friendly build system in place and
+the user will have to have access to suitable compilers. For build systems:
+see the previous section.
+
+**Option 2: Distribute a pre-built executable program**
+
+A pre-built program that does not need to be customised, other than via its
+input, will still need to come with the various run-time libraries and will
+be specific to the operating system/environment it was built for.
+
+The set of run-time libraries differs per operating system and compiler version.
+For a freely available compiler like gfortran, the easiest thing is to ask the
+user to install that compiler on their system. In the case of Windows: the Cygwin
+environment may be called for.
+
+Alternatively, you can supply copies of the run-time libraries together with your
+program. Put them in the directory where they can be found at run-time.
+
+Note: On Windows, the Intel Fortran comes with a set of _redistributable_ libraries.
+These will need to be made available.
+
+In general: use a tool like "ldd" or "dependency walker" to find out what
+libraries are required and consult the documentation of the compiler.
+
+If your program does allow customisation, consider using dynamic libraries for this.
+More is said about this below.
+
+**Option 3: Distribute static or dynamic libraries that people can use**
+
+This option is a combination of the first two options. It does put some burden on
+the user, as they must create a main program that calls your routines in the
+proper way, but they do not need to know much about the build system you used.
+You will have to deal with the run-time libraries, though.
+
+If you choose this option, besides the compiled libraries, you will also need to
+supply the module intermediate files. These files are compiler-specific, but so are
+the static libraries you build.
+
+## Distributing the tabulation program
+
+As shown above, the tabulation program can be built with the user-defined function
+in a dynamic library. This enables you to:
+
+- Ship the executable (with the appropriate run-time libraries)
+- Provide a skeleton version of the module, something like:
+
+```fortran
+module user_functions
+ implicit none
+contains
+
+real function f( x )
+!DEC$ ATTRIBUTES DLLEXPORT :: f
+ real, intent(in) :: x
+
+ ! your function body goes here
+
+end function f
+
+end module user_functions
+```
+
+- Provide a basic build script with a command like:
+
+```shell
+gfortran -o functions.dll functions.f90 -shared
+```
+
+or:
+
+```shell
+ifort -exe:functions.dll functions.f90 -dll
+```
+
+As said, you cannot control that the user has done the right thing — any
+DLL "functions.dll" with a function `f` would be accepted, but not necessarily
+lead to a successful run.
+
+An alternative set-up would be to change the main program into a subroutine
+and have the function as an argument:
+
+```fortran
+module tabulation
+ implicit none
+contains
+
+subroutine tabulate( f )
+ interface
+ real function f( x )
+ real, intent(in) :: x
+ end function f
+ end interface
+
+ ! your implementation goes here
+
+end subroutine tabulate
+
+end module tabulation
+```
+
+Then provide a skeleton main program:
+
+```fortran
+program tabulate_f
+ use tabulation
+
+ call tabulate( func1 )
+
+contains
+
+real function func1( x )
+ real, intent(in) :: x
+
+ ! your function body goes here
+
+end function func1
+
+end program tabulate_f
+```
+
+The advantage is that the compiler can check the interface of the
+function that is passed and that the user has more freedom in the use of the
+functionality provided by your library.
diff --git a/_sources/learn/building_programs/include_files.md.txt b/_sources/learn/building_programs/include_files.md.txt
new file mode 100644
index 000000000000..3e17dbab5d65
--- /dev/null
+++ b/_sources/learn/building_programs/include_files.md.txt
@@ -0,0 +1,92 @@
+# Include files and modules
+
+Your program can be contained in various source files, all stored in the
+same directory or organised in some convenient directory tree. The
+details of the organisation depend on personal taste, arrangements made
+by the group of developers you belong to, or simply the history of the
+program. Whatever the directory structure is, you will encounter a
+situation where the compiler needs assistance in order to compile a
+particular source file:
+
+- Fortran (and other languages) has the possibility to include an
+ external file. While this feature has become a bit less useful with the
+ advent of modules, it still has its uses. Quite often, such "include
+ files" are stored in a directory separated from the directories
+ containing the source files, because they are used in several locations.
+ Quite often the name of that directory is "include".
+- As we have seen, compiling source code that defines one or more modules, leads to
+ the compiler generating so-called "module intermediate files" (with the extension ".mod").
+ The compiler needs access to these files to be able to read the interfaces
+ and variables and what not, and based on this information, actually
+ compile the source code that uses the various modules.
+
+Compilers support options like `-I` to indicate where these include
+files and module intermediate files are to be found. Suppose we store
+the two files of our `tabulate` program in the following directory
+structure:
+
+```
+tabulate/
+ main/
+ tabulate.f90
+ sub/
+ functions.f90
+```
+
+Compiling the file "functions.f90" with the commands
+
+```shell
+$ cd sub
+$ gfortran -c functions.f90
+```
+
+leads to this structure:
+
+```
+tabulate/
+ main/
+ tabulate.f90
+ sub/
+ functions.f90
+ user_functions.mod
+ functions.o
+```
+
+To successfully compile and subsequently build the program we need to
+tell the compiler where it can find the file "user_functions.mod":
+
+```shell
+$ cd main
+$ gfortran -c tabulate.f90 -I ../sub
+$ gfortran -o tabulate tabulate.o ../sub/functions.o
+```
+
+The result:
+
+```
+tabulate/
+ main/
+ tabulate.f90
+ tabulate.o
+ tabulate (or tabulate.exe on Windows)
+ sub/
+ functions.f90
+ functions.o
+ user_functions.mod
+```
+
+Notes:
+
+- The details differ per compiler. Sometimes the `-I` option should be
+ followed by a space and then the name of the directory, sometimes the
+ directory should come consecutively.
+- By default the module intermediate files (.mod) are put in the
+ same directory as the object files. When your program code is organised
+ in different subdirectories, they will get scattered over the directory
+ tree, complicating the compilation process. Luckily,
+ many compilers allow you to specify the output location for these
+ files. For gfortran this is `-J`, for instance:
+ `-J../include` (so that the .mod files could all appear in the
+ same directory)
+- For large programs, consisting of many source files, it is important to
+ think through what organisation to use.
diff --git a/_sources/learn/building_programs/index.md.txt b/_sources/learn/building_programs/index.md.txt
new file mode 100644
index 000000000000..c789e843eaef
--- /dev/null
+++ b/_sources/learn/building_programs/index.md.txt
@@ -0,0 +1,58 @@
+# Building programs
+
+Languages like Fortran, C, C++ and Java, to name but a few, share
+certain characteristics: you write code in your language of choice but
+then you have to build an executable program from that source code.
+Other languages are interpreted — the source code is analysed by a
+special program and taken as direct instructions. Two very simple
+examples of that type of language: Windows batch files and Linux shell
+scripts.
+
+In this tutorial we concentrate on the first type of languages, with
+Fortran as the main example. One advantage of compiled languages is that
+the build process that you need to build an executable program, is used
+to transform the human-readable source code into an efficient program
+that can be run on the computer.
+
+Remark: this tutorial gives examples for the Windows and Linux operating
+systems, however the workflow and general principles still apply to macOS.
+
+## Compiled languages
+
+Let us have a look at a simple example:
+
+```fortran
+program hello
+ write(*,*) 'Hello!'
+end program hello
+```
+
+This is just about the simplest program you can write in Fortran and it
+is certainly a variation on one of the most famous programs. Even though
+it is simple to express in source code, a lot of things actually happen
+when the executable that is built from this code runs:
+
+- A process is started on the computer in such a way that it can write
+ to the console — the window (DOS-box, xterm, ...) at which you type the
+ program's name.
+- It writes the text "Hello!" to the console. To do so it must properly
+ interact with the console.
+- When done, it finishes, cleaning up all the resources (memory,
+ connection to the console etc.) it took.
+
+Fortunately, as a programmer in a high-level language you do not need to
+consider all these details. In fact, this is the sort of things that is
+taken care of by the build process: the compiler and the linker.
+
+```{toctree}
+:maxdepth: 2
+:hidden:
+Compiling the source code
+Linking the objects
+Run-time libraries
+Include files and modules
+Managing libraries (static and dynamic libraries)
+Build tools
+An introduction to make
+Distributing your programs
+```
diff --git a/_sources/learn/building_programs/linking_pieces.md.txt b/_sources/learn/building_programs/linking_pieces.md.txt
new file mode 100644
index 000000000000..261949301e57
--- /dev/null
+++ b/_sources/learn/building_programs/linking_pieces.md.txt
@@ -0,0 +1,92 @@
+# Linking the objects
+
+Almost all programs, except for the simplest, are built up from
+different pieces. We are going to examine such a situation in
+more detail.
+
+Here is a general program for tabulating a function (source code in
+"tabulate.f90"):
+
+```fortran
+program tabulate
+ use user_functions
+
+ implicit none
+ real :: x, xbegin, xend
+ integer :: i, steps
+
+ write(*,*) 'Please enter the range (begin, end) and the number of steps:'
+ read(*,*) xbegin, xend, steps
+
+ do i = 0, steps
+ x = xbegin + i * (xend - xbegin) / steps
+ write(*,'(2f10.4)') x, f(x)
+ end do
+end program tabulate
+```
+
+Note the `use` statement — this will be where we define the function `f`.
+
+We want to make the program general, so keep the
+specific source code — the implementation of the function `f` —
+separated from the general source code. There are several ways to
+achieve this, but one is to put it in a different source file. We can
+give the general program to a user and they provide a specific source code.
+
+Assume for the sake of the example that the function is implemented in a
+source file "functions.f90" as:
+
+```fortran
+module user_functions
+ implicit none
+contains
+
+real function f( x )
+ real, intent(in) :: x
+ f = x - x**2 + sin(x)
+end function f
+
+end module user_functions
+```
+
+To build the program with this specific function, we need to compile two
+source files and combine them via the link step into one executable
+program. Because the program "tabulate" depends on the module
+"function", we need to compile the source file containing our module
+first. A sequence of commands to do this is:
+
+```shell
+$ gfortran -c functions.f90
+$ gfortran tabulate.f90 functions.o
+```
+
+The first step compiles the module, resulting in an object file
+"functions.o" and a module intermediate file, "user_functions.mod". This module
+file contains all the information the compiler needs to determine that
+the function `f` is defined in this module and what its interface is. This
+information is important: it enables the compiler to check that you call
+the function in the right way. It might be that you made a mistake and
+called the function with two arguments instead of one. If the compiler
+does not know anything about the function's interface, then it cannot
+check anything.
+
+The second step invokes the compiler in such a way that:
+
+- it compiles the file "tabulate.f90" (using the module file);
+- it invokes the linker to combine the object files tabulate.o and functions.o into an
+ executable program — with the default name "a.out" or "a.exe" (if you
+ want a different name, use the option "-o").
+
+What you do not see in general is that the linker also adds a number of
+extra files in this link step, the run-time libraries. These run-time
+libraries contain all the "standard" stuff — low-level routines that do
+the input and output to screen, the `sin` function and much more.
+
+If you want to see the gory details, add the option "-v". This instructs
+the compiler to report all the steps that are in detail.
+
+The end result, the executable program, contains the compiled source
+code and various auxiliary routines that make it work. It also contains
+references to so-called dynamic run-time libraries (in Windows: DLLs, in
+Linux: shared objects or shared libraries). Without these run-time
+libraries the program will not start.
diff --git a/_sources/learn/building_programs/managing_libraries.md.txt b/_sources/learn/building_programs/managing_libraries.md.txt
new file mode 100644
index 000000000000..6beab912c255
--- /dev/null
+++ b/_sources/learn/building_programs/managing_libraries.md.txt
@@ -0,0 +1,216 @@
+# Managing libraries (static and dynamic libraries)
+
+If you need to manage a program built of dozens of source files (and
+that is not uncommon!), the command-line needed to specify all the
+object files will be very long indeed. This soon becomes tedious or
+even impossible to maintain. So a different solution is called for:
+create your own libraries.
+
+Libraries contain any number of object files in a compact form, so that
+the command-line becomes far shorter:
+
+```shell
+$ gfortran -o tabulate tabulate.f90 functions.o supportlib.a
+```
+
+where "supportlib.a" is a collection of one, two or many object files,
+all compiled and then put into a library. The extension ".a" is used by
+Linux and Linux-like platforms. On Windows the extension ".lib" is used.
+
+Creating your own libraries is not that complicated:
+on Linux, you can achieve this using a utility like `ar`:
+
+```shell
+$ gfortran -c file1.f90 file2.f90
+$ gfortran -c file3.f90 ...
+$ ar r supportlib.a file1.o file2.o
+$ ar r supportlib.a file3.o ...
+```
+
+or on Windows using the `lib` utility:
+
+```shell
+c:\...> ifort -c file1.f90 file2.f90
+c:\...> ifort -c file3.f90 ...
+c:\...> lib /out:supportlib.lib file1.obj file2.obj
+c:\...> lib supportlib.lib file3.obj ...
+```
+
+Note:
+
+- The command `ar` with the option `r` either creates the library (the
+ name appears after the option) or adds new object files to the library
+ (or replaces any existing ones).
+- The command `lib` will create a new library if you use specify the
+ option `/out:` with the name of the new library next to it. To add
+ object files to an existing library, leave out the `/out:` bit.
+- On platforms like Linux there is a particular convention to name
+ libraries. If you name your library like "libname.a" (note the "lib"
+ prefix), then you can refer to it as `-lname` in the link step.
+- Libraries are often sought in directories indicated by an option `-L`
+ or `/LIBPATH`. This saves you from having to specify the exact path for
+ every library.
+
+Using libraries you can build very large programs without
+having to resort to extremely long command lines.
+
+## Static versus dynamic libraries
+
+The above discussion is tacitly assuming that you are using the so-called
+static libraries. Static libraries (or at least parts of their
+contents) become an integral part of the executable program. The only
+way to change the routines incorporated in the program is by rebuilding
+the program with a new version of the library.
+
+A flexible alternative is to use the so-called dynamic libraries. These
+libraries remain outside the executable program and as a consequence
+can be replaced without rebuilding the entire program. Compilers and
+indeed the operating system itself rely heavily on such dynamic
+libraries. You could consider dynamic libraries as a sort of executable
+programs that need a bit of help to be run.
+
+Building dynamic libraries works slightly differently from building
+static libraries: you use the compiler/linker instead of a tool
+like `ar` or `lib`.
+
+On Linux:
+
+```shell
+$ gfortran -fpic -c file1.f90 file2.f90
+$ gfortran -fpic -c file3.f90 ...
+$ gfortran -shared -o supportlib.so file1.o file2.o file3.o ...
+```
+
+On Windows, with the Intel Fortran compiler:
+
+```shell
+$ ifort -c file1.f90 file2.f90
+$ ifort -c file3.f90 ...
+$ ifort -dll -exe:supportlib.dll file1.obj file2.obj file3.obj ...
+```
+
+The differences are that:
+
+- You need to specify a compile option on Linux, for gfortran that is `-fpic`,
+ because the object code is slightly different.
+- You need to tell in the link step that you want a dynamic library (on
+ Linux: a shared object/library, hence the extension ".so"; on Windows:
+ a dynamic link library)
+
+There is one more thing to be aware of: On Windows you must
+explicitly specify that a procedure is to be _exported_, i.e. is visible
+in the dynamic library. There are several ways — depending on the
+compiler you use — to achieve this. One method is via a so-called
+compiler directive:
+
+```fortran
+subroutine myroutine( ... )
+!GCC$ ATTRIBUTES DLLEXPORT:: myroutine
+```
+
+Or, with the Intel Fortran compiler:
+
+```fortran
+subroutine myroutine( ... )
+!DEC$ ATTRIBUTES DLLEXPORT:: myroutine
+```
+
+Besides a dynamic library (DLL), a so-called import library may be
+generated.
+
+Because the details differ per compiler, here are two examples:
+gfortran on Cygwin and Intel Fortran on Windows. In both cases
+we look at the `tabulate` program in the file "tabulate.f90".
+
+## GNU/Linux and gfortran
+
+The `tabulate` program requires a user-defined routine `f`. If we
+let it reside in a dynamic library, say "functions.dll", we can simply
+replace the implementation of the function by putting another dynamic
+library in the directory. No need to rebuild the program as such.
+
+On Cygwin it is not necessary to explicitly export a procedure — all
+publically visible routines are exported when you build a dynamic library.
+Also, no import library is generated.
+
+Since our dynamic library can be built from a single source file, we
+can take a shortcut:
+
+```shell
+$ gfortran -shared -o functions.dll functions.f90
+```
+
+This produces the files "functions.dll" and "user_functions.mod". The
+utility `nm` tells us the exact name of the function `f`:
+
+```shell
+$ nm functions.dll
+...
+000000054f9d7000 B __dynamically_loaded
+ U __end__
+0000000000000200 A __file_alignment__
+000000054f9d1030 T __function_MOD_f
+000000054f9d1020 T __gcc_deregister_frame
+000000054f9d1000 T __gcc_register_frame
+...
+```
+
+It has received a prefix `__function_MOD_` to distinguish it from any
+other routine "f" that might be defined in another module.
+
+The next step is to build the program:
+
+```shell
+$ gfortran -o tabulate tabulate.f90 functions.dll
+```
+
+The DLL and the .mod file are used to build the executable program
+with checks on the function's interface, the right name and the reference
+to "a" DLL, called "functions.dll".
+
+You can replace the shared library "functions.dll" by another one, implementing
+a different function "f". Of course, you need to be careful to use the correct
+interface for this function. The compiler/linker are not invoked anymore, so they
+can do no checking.
+
+## Windows and Intel Fortran
+
+The setup is the same as with Linux, but on Windows it is necessary
+to explicitly export the routines. And an import library is generated —
+this is the library that should be used in the link step.
+
+The source file must contain the compiler directive, otherwise the function `f`
+is not exported:
+
+```fortran
+real function f( x )
+!DEC$ ATTRIBUTES DLLEXPORT :: f
+```
+
+Again we take a shortcut:
+
+```shell
+$ ifort -exe:functions.dll functions.f90 -dll
+```
+
+This produces the files "functions.dll", "user_functions.mod" as well as "functions.lib" (and two
+other files of no importance here). The "dependency walker" program tells us
+that the exact name of the function "f" is `FUNCTION_mp_F`. It is also exported, so that
+it can be found by the linker in the next step:
+
+```
+$ ifort tabulate.f90 functions.lib
+```
+
+Note that we need to specify the name of the export library, not the DLL!
+
+(Note also: the Intel Fortran compiler uses the name of the first source file as the
+name for the executable — here we do without the `-exe` option.)
+
+Just as under Cygwin, the DLL and the .mod file are used to build the executable program
+with checks on the function's interface, the right name and the reference
+to "a" DLL, called "functions.dll".
+
+You can replace the shared library "functions.dll" by another one, but the same
+caution is required: while the implementation can be quite different, the
+function's interface must be the same.
diff --git a/_sources/learn/building_programs/project_make.md.txt b/_sources/learn/building_programs/project_make.md.txt
new file mode 100644
index 000000000000..c08229cdb9f3
--- /dev/null
+++ b/_sources/learn/building_programs/project_make.md.txt
@@ -0,0 +1,478 @@
+# An introduction to make
+
+We briefly discussed the basics of `make`. This chapter gives ideas
+and strategies to scale `make` for larger projects.
+
+Before going into detail with `make`, consider a few points:
+
+1. `make` is a Unix tool and might give you a hard time when porting to non-Unix
+ platforms. That said, there are also different flavors of `make` available,
+ not all might support the features you want to use.
+2. While `make` gives you full control over the build process, it also
+ means you are responsible for the entire build process, and you have to specify the rules for every detail of your project.
+ You might find yourself spending a significant amount of time writing and
+ maintaining your `Makefile` instead of developing your source code.
+3. You can work with your `Makefile`, but think about other developers
+ on your project who may not be familiar with `make`. How much time do you expect them to spend learning your
+ `Makefile` and would they be able to debug or add features?
+4. Pure `make` will not scale. You will soon add auxiliary programs
+ to dynamically or statically generate your `Makefile`. Those introduce
+ dependencies and possible sources of errors. The effort needed to test and document those
+ tools should not be underestimated.
+
+If you think `make` is suitable for your needs, than you can start writing
+your `Makefile`. For this course we will use real world examples from the
+package index, which (at the time of writing) use build systems other
+than `make`. This guide should present a general recommended style to write
+`make`, but also serve as demonstration of useful and interesting features.
+
+::::{tip}
+Even if you find `make` unsuitable to build your project, it is _the_ tool to automate workflows defined by files. Maybe you can leverage its power in a different context.
+::::
+
+## Getting started
+
+For this part we will work with
+ the Fortran CSV module (v1.2.0).
+Our goal is to write a `Makefile` to compile this project to a static library.
+Start by cloning the repository
+
+```
+git clone https://github.com/jacobwilliams/fortran-csv-module -b 1.2.0
+cd fortran-csv-module
+```
+
+::::{tip}
+For this part we will work with the code from tag `1.2.0`, to make it as reproducible as possible. Feel free to use the latest version or another project instead.
+::::
+
+This project uses FoBiS as build system, and you can check the
+`build.sh` for options used with FoBiS. We are about to write a `Makefile`
+for this project. First, we check the directory structure and the source files
+
+ .
+ ├── build.sh
+ ├── files
+ │ ├── test_2_columns.csv
+ │ └── test.csv
+ ├── fortran-csv-module.md
+ ├── LICENSE
+ ├── README.md
+ └── src
+ ├── csv_kinds.f90
+ ├── csv_module.F90
+ ├── csv_parameters.f90
+ ├── csv_utilities.f90
+ └── tests
+ ├── csv_read_test.f90
+ ├── csv_test.f90
+ └── csv_write_test.f90
+
+We find seven different Fortran source files; the four in `src` should
+be compiled and added to a static library while the three in `src/tests`
+contain individual programs that depend on this static library.
+
+Start by creating a simple `Makefile`:
+
+```make
+# Disable the default rules
+MAKEFLAGS += --no-builtin-rules --no-builtin-variables
+
+# Project name
+NAME := csv
+
+# Configuration settings
+FC := gfortran
+AR := ar rcs
+LD := $(FC)
+RM := rm -f
+
+# List of all source files
+SRCS := src/csv_kinds.f90 \
+ src/csv_module.F90 \
+ src/csv_parameters.f90 \
+ src/csv_utilities.f90
+TEST_SRCS := src/tests/csv_read_test.f90 \
+ src/tests/csv_test.f90 \
+ src/tests/csv_write_test.f90
+
+# Create lists of the build artefacts in this project
+OBJS := $(addsuffix .o, $(SRCS))
+TEST_OBJS := $(addsuffix .o, $(TEST_SRCS))
+LIB := $(patsubst %, lib%.a, $(NAME))
+TEST_EXE := $(patsubst %.f90, %.exe, $(TEST_SRCS))
+
+# Declare all public targets
+.PHONY: all clean
+all: $(LIB) $(TEST_EXE)
+
+# Create the static library from the object files
+$(LIB): $(OBJS)
+ $(AR) $@ $^
+
+# Link the test executables
+$(TEST_EXE): %.exe: %.f90.o $(LIB)
+ $(LD) -o $@ $^
+
+# Create object files from Fortran source
+$(OBJS) $(TEST_OBJS): %.o: %
+ $(FC) -c -o $@ $<
+
+# Define all module interdependencies
+csv_kinds.mod := src/csv_kinds.f90.o
+csv_module.mod := src/csv_module.F90.o
+csv_parameters.mod := src/csv_parameters.f90.o
+csv_utilities.mod := src/csv_utilities.f90.o
+src/csv_module.F90.o: $(csv_utilities.mod)
+src/csv_module.F90.o: $(csv_kinds.mod)
+src/csv_module.F90.o: $(csv_parameters.mod)
+src/csv_parameters.f90.o: $(csv_kinds.mod)
+src/csv_utilities.f90.o: $(csv_kinds.mod)
+src/csv_utilities.f90.o: $(csv_parameters.mod)
+src/tests/csv_read_test.f90.o: $(csv_module.mod)
+src/tests/csv_test.f90.o: $(csv_module.mod)
+src/tests/csv_write_test.f90.o: $(csv_module.mod)
+
+# Cleanup, filter to avoid removing source code by accident
+clean:
+ $(RM) $(filter %.o, $(OBJS) $(TEST_OBJS)) $(filter %.exe, $(TEST_EXE)) $(LIB) $(wildcard *.mod)
+```
+
+Invoking `make` should build the static library and the test executables as
+expected:
+
+ gfortran -c -o src/csv_kinds.f90.o src/csv_kinds.f90
+ gfortran -c -o src/csv_parameters.f90.o src/csv_parameters.f90
+ gfortran -c -o src/csv_utilities.f90.o src/csv_utilities.f90
+ gfortran -c -o src/csv_module.F90.o src/csv_module.F90
+ ar rcs libcsv.a src/csv_kinds.f90.o src/csv_module.F90.o src/csv_parameters.f90.o src/csv_utilities.f90.o
+ gfortran -c -o src/tests/csv_read_test.f90.o src/tests/csv_read_test.f90
+ gfortran -o src/tests/csv_read_test.exe src/tests/csv_read_test.f90.o libcsv.a
+ gfortran -c -o src/tests/csv_test.f90.o src/tests/csv_test.f90
+ gfortran -o src/tests/csv_test.exe src/tests/csv_test.f90.o libcsv.a
+ gfortran -c -o src/tests/csv_write_test.f90.o src/tests/csv_write_test.f90
+ gfortran -o src/tests/csv_write_test.exe src/tests/csv_write_test.f90.o libcsv.a
+
+There are a few things to note there, a `make` build usually interlaces the
+build artifacts and the source code, unless you put extra effort into implementing
+a build directory.
+Also, right now the the source files and dependencies are specified explicitly,
+which results in several additional lines even for such a simple project.
+
+## Automatically generated dependencies
+
+The main drawback of `make` for Fortran is the missing capability to
+determine module dependencies. This is usually solved by either adding those
+by hand or automatically scanning the source code with an external tool.
+Some compilers (like the Intel Fortran compiler) also offer to generate dependencies in `make` format.
+
+Before diving into the dependency generation, we will outline the concept of
+a robust take on the dependency problem.
+First, we want an approach that can process all source files independently,
+while each source file provides (`module`) or requires (`use`) modules.
+When generating the dependencies only the name of the source file and the
+module files are known, and no information on the object file names should be
+required.
+
+If you check the dependency section above you will note that all dependencies are
+defined between object files rather than source files. To change this, we can
+generate a map from the source files their respective object files:
+
+```make
+# Define a map from each file name to its object file
+obj = $(src).o
+$(foreach src, $(SRCS) $(TEST_SRCS), $(eval $(src) := $(obj)))
+```
+
+Note the declaration of `obj` as recursively expanded variable, we effectively
+use this mechanism to define a function in `make`. The `foreach` function
+allows us to loop over all source files, while the `eval` function allows us
+to generate `make` statements and evaluate them for this `Makefile`.
+
+We adjust the dependencies accordingly as we can now define the name of the
+object files through the source file names:
+
+```make
+# Define all module interdependencies
+csv_kinds.mod := $(src/csv_kinds.f90)
+csv_module.mod := $(src/csv_module.F90)
+csv_parameters.mod := $(src/csv_parameters.f90)
+csv_utilities.mod := $(src/csv_utilities.f90)
+$(src/csv_module.F90): $(csv_utilities.mod)
+$(src/csv_module.F90): $(csv_kinds.mod)
+$(src/csv_module.F90): $(csv_parameters.mod)
+$(src/csv_parameters.f90): $(csv_kinds.mod)
+$(src/csv_utilities.f90): $(csv_kinds.mod)
+$(src/csv_utilities.f90): $(csv_parameters.mod)
+$(src/tests/csv_read_test.f90): $(csv_module.mod)
+$(src/tests/csv_test.f90): $(csv_module.mod)
+$(src/tests/csv_write_test.f90): $(csv_module.mod)
+```
+
+The same strategy of creating a map is already used for the module files, now
+it is just expanded to the object files as well.
+
+To generate the respective dependency map automatically we will use an
+`awk` script here
+
+```awk
+#!/usr/bin/awk -f
+
+BEGIN {
+ # Fortran is case insensitive, disable case sensitivity for matching
+ IGNORECASE = 1
+}
+
+# Match a module statement
+# - the first argument ($1) should be the whole word module
+# - the second argument ($2) should be a valid module name
+$1 ~ /^module$/ &&
+$2 ~ /^[a-zA-Z][a-zA-Z0-9_]*$/ {
+ # count module names per file to avoid having modules twice in our list
+ if (modc[FILENAME,$2]++ == 0) {
+ # add to the module list, the generated module name is expected
+ # to be lowercase, the FILENAME is the current source file
+ mod[++im] = sprintf("%s.mod = $(%s)", tolower($2), FILENAME)
+ }
+}
+
+# Match a use statement
+# - the first argument ($1) should be the whole word use
+# - the second argument ($2) should be a valid module name
+$1 ~ /^use$/ &&
+$2 ~ /^[a-zA-Z][a-zA-Z0-9_]*,?$/ {
+ # Remove a trailing comma from an optional only statement
+ gsub(/,/, "", $2)
+ # count used module names per file to avoid using modules twice in our list
+ if (usec[FILENAME,$2]++ == 0) {
+ # add to the used modules, the generated module name is expected
+ # to be lowercase, the FILENAME is the current source file
+ use[++iu] = sprintf("$(%s) += $(%s.mod)", FILENAME, tolower($2))
+ }
+}
+
+# Match an include statement
+# - the first argument ($1) should be the whole word include
+# - the second argument ($2) can be everything, as long as delimited by quotes
+$1 ~ /^(#:?)?include$/ &&
+$2 ~ /^["'].+["']$/ {
+ # Remove quotes from the included file name
+ gsub(/'|"/, "", $2)
+ # count included files per file to avoid having duplicates in our list
+ if (incc[FILENAME,$2]++ == 0) {
+ # Add the included file to our list, this might be case-sensitive
+ inc[++ii] = sprintf("$(%s) += %s", FILENAME, $2)
+ }
+}
+
+# Finally, produce the output for make, loop over all modules, use statements
+# and include statements, empty lists are ignored in awk
+END {
+ for (i in mod) print mod[i]
+ for (i in use) print use[i]
+ for (i in inc) print inc[i]
+}
+```
+
+This script makes a few assumptions about the source code it parses, so it will
+not work with all Fortran code (namely submodules are not supported), but for
+this example it will suffice.
+
+::::{tip}
+Using awk
+
+The above script uses the `awk` language, which is designed for the purpose
+of text stream processing and uses a C-like syntax. In `awk` you can define
+groups which are evaluated on certain events, _e.g._ when a line matches a
+specific pattern, usually expressed by a
+ regular expression.
+
+This `awk` script defines five groups, two of them use the special pattern
+`BEGIN` and `END` which are run before the script starts and after the script
+finishes, respectively.
+Before the script starts we make the script case-insensitive since we are dealing
+with Fortran source code here.
+We also use the special variable `FILENAME` to determine which file we are
+currently parsing and to allow processing multiple files at once.
+
+With the three patterns defined we are looking for `module`, `use` and
+`include` statements as the first space delimited entry. With the used
+pattern not all valid Fortran code will be parsed correctly.
+A failing example would be:
+
+```fortran
+use::my_module,only:proc
+```
+
+To make this parsable by the `awk` script we can add another group directly
+after the `BEGIN` group, modifying the stream while processing it with
+
+```awk
+{
+ gsub(/,|:/, " ")
+}
+```
+
+In theory you would need a full Fortran parser to deal with continuation lines
+and other difficulties. This might be possible to implement in `awk` but
+would require a huge script in the end.
+
+Also, keep in mind that generating the dependencies should be fast, an expensive
+parser can produce a significant overhead when generating dependencies for a large
+code base. Making reasonable assumptions can simplify and speed up this step, but
+also introduces an error source in your build tools.
+
+::::
+
+Make the script executable (`chmod +x gen-deps.awk`) and test it with
+`./gen-deps.awk $(find src -name '*.[fF]90')`. You should see output like this:
+
+ csv_utilities.mod = $(src/csv_utilities.f90)
+ csv_kinds.mod = $(src/csv_kinds.f90)
+ csv_parameters.mod = $(src/csv_parameters.f90)
+ csv_module.mod = $(src/csv_module.F90)
+ $(src/csv_utilities.f90) += $(csv_kinds.mod)
+ $(src/csv_utilities.f90) += $(csv_parameters.mod)
+ $(src/csv_kinds.f90) += $(iso_fortran_env.mod)
+ $(src/tests/csv_read_test.f90) += $(csv_module.mod)
+ $(src/tests/csv_read_test.f90) += $(iso_fortran_env.mod)
+ $(src/tests/csv_write_test.f90) += $(csv_module.mod)
+ $(src/tests/csv_write_test.f90) += $(iso_fortran_env.mod)
+ $(src/tests/csv_test.f90) += $(csv_module.mod)
+ $(src/tests/csv_test.f90) += $(iso_fortran_env.mod)
+ $(src/csv_parameters.f90) += $(csv_kinds.mod)
+ $(src/csv_module.F90) += $(csv_utilities.mod)
+ $(src/csv_module.F90) += $(csv_kinds.mod)
+ $(src/csv_module.F90) += $(csv_parameters.mod)
+ $(src/csv_module.F90) += $(iso_fortran_env.mod)
+
+Note that the scripts output will use recursively expanded variables and not
+define any dependencies yet, because out-of-order declaration of variables
+might be necessary and we do not want to create any target by accident.
+You can verify that the same information as in the above handwritten snippet is
+present. The only exception is the additional dependency on the
+`iso_fortran_env.mod`, since it is an undefined variable it will just expand
+to an empty string and not introduce any further dependencies.
+
+Now, you can finally include this piece in your `Makefile` to automate the
+dependency generation:
+
+```make
+# Disable the default rules
+MAKEFLAGS += --no-builtin-rules --no-builtin-variables
+
+# Project name
+NAME := csv
+
+# Configuration settings
+FC := gfortran
+AR := ar rcs
+LD := $(FC)
+RM := rm -f
+GD := ./gen-deps.awk
+
+# List of all source files
+SRCS := src/csv_kinds.f90 \
+ src/csv_module.F90 \
+ src/csv_parameters.f90 \
+ src/csv_utilities.f90
+TEST_SRCS := src/tests/csv_read_test.f90 \
+ src/tests/csv_test.f90 \
+ src/tests/csv_write_test.f90
+
+# Add source and tests directories to search paths
+vpath % .: src
+vpath % .: src/tests
+
+# Define a map from each file name to its object file
+obj = $(src).o
+$(foreach src, $(SRCS) $(TEST_SRCS), $(eval $(src) := $(obj)))
+
+# Create lists of the build artefacts in this project
+OBJS := $(addsuffix .o, $(SRCS))
+DEPS := $(addsuffix .d, $(SRCS))
+TEST_OBJS := $(addsuffix .o, $(TEST_SRCS))
+TEST_DEPS := $(addsuffix .d, $(TEST_SRCS))
+LIB := $(patsubst %, lib%.a, $(NAME))
+TEST_EXE := $(patsubst %.f90, %.exe, $(TEST_SRCS))
+
+# Declare all public targets
+.PHONY: all clean
+all: $(LIB) $(TEST_EXE)
+
+# Create the static library from the object files
+$(LIB): $(OBJS)
+ $(AR) $@ $^
+
+# Link the test executables
+$(TEST_EXE): %.exe: %.f90.o $(LIB)
+ $(LD) -o $@ $^
+
+# Create object files from Fortran source
+$(OBJS) $(TEST_OBJS): %.o: % | %.d
+ $(FC) -c -o $@ $<
+
+# Process the Fortran source for module dependencies
+$(DEPS) $(TEST_DEPS): %.d: %
+ $(GD) $< > $@
+
+# Define all module interdependencies
+include $(DEPS) $(TEST_DEPS)
+$(foreach dep, $(OBJS) $(TEST_OBJS), $(eval $(dep): $($(dep))))
+
+# Cleanup, filter to avoid removing source code by accident
+clean:
+ $(RM) $(filter %.o, $(OBJS) $(TEST_OBJS)) $(filter %.d, $(DEPS) $(TEST_DEPS)) $(filter %.exe, $(TEST_EXE)) $(LIB) $(wildcard *.mod)
+```
+
+Here additional dependency files are generated for each source file individually
+and than included into the main `Makefile`.
+Also, the dependency files are added as dependency to the object files to ensure
+they are generated before the object is compiled. The pipe character in
+the dependencies defines an order of the rules without a timestamp dependency,
+because it is not necessary to recompile an object file in case dependencies are
+regenerated and potentially unchanged.
+
+Again, we make use of the `eval` function to generate the dependencies in a
+`foreach` loop over all object files. Note that we created a map between
+the object files in the dependency files, expanding `dep` once yields the
+object file name, expanding it again yields the object files it depends on.
+
+Building your project with `make` should give an output similar to
+
+ ./gen-deps.awk src/csv_utilities.f90 > src/csv_utilities.f90.d
+ ./gen-deps.awk src/csv_parameters.f90 > src/csv_parameters.f90.d
+ ./gen-deps.awk src/csv_module.F90 > src/csv_module.F90.d
+ ./gen-deps.awk src/csv_kinds.f90 > src/csv_kinds.f90.d
+ gfortran -c -o src/csv_kinds.f90.o src/csv_kinds.f90
+ gfortran -c -o src/csv_parameters.f90.o src/csv_parameters.f90
+ gfortran -c -o src/csv_utilities.f90.o src/csv_utilities.f90
+ gfortran -c -o src/csv_module.F90.o src/csv_module.F90
+ ar rcs libcsv.a src/csv_kinds.f90.o src/csv_module.F90.o src/csv_parameters.f90.o src/csv_utilities.f90.o
+ ./gen-deps.awk src/tests/csv_read_test.f90 > src/tests/csv_read_test.f90.d
+ gfortran -c -o src/tests/csv_read_test.f90.o src/tests/csv_read_test.f90
+ gfortran -o src/tests/csv_read_test.exe src/tests/csv_read_test.f90.o libcsv.a
+ ./gen-deps.awk src/tests/csv_test.f90 > src/tests/csv_test.f90.d
+ gfortran -c -o src/tests/csv_test.f90.o src/tests/csv_test.f90
+ gfortran -o src/tests/csv_test.exe src/tests/csv_test.f90.o libcsv.a
+ ./gen-deps.awk src/tests/csv_write_test.f90 > src/tests/csv_write_test.f90.d
+ gfortran -c -o src/tests/csv_write_test.f90.o src/tests/csv_write_test.f90
+ gfortran -o src/tests/csv_write_test.exe src/tests/csv_write_test.f90.o libcsv.a
+
+Once the dependency files are generated, `make` will only update them if the
+source changes and not require to rebuild them again for every invocation.
+
+::::{tip}
+With correct dependencies you can leverage parallel execution of your `Makefile`, just use the `-j` flag to create multiple `make` processes.
+::::
+
+Since dependencies can now be generated automatically, there is no need to specify
+the source files explicitly, the `wildcard` function can be used to determine
+them dynamically:
+
+```make
+# List of all source files
+SRCS := $(wildcard src/*.f90) \
+ $(wildcard src/*.F90)
+TEST_SRCS := $(wildcard src/tests/*.f90)
+```
diff --git a/_sources/learn/building_programs/runtime_libraries.md.txt b/_sources/learn/building_programs/runtime_libraries.md.txt
new file mode 100644
index 000000000000..1985ebe80b6b
--- /dev/null
+++ b/_sources/learn/building_programs/runtime_libraries.md.txt
@@ -0,0 +1,60 @@
+# Run-time libraries
+
+To illustrate that even a simple program depends on external run-time
+libraries, here is the output from the `ldd` utility that reports such
+dependencies:
+
+```shell
+$ ldd tabulate.exe
+ ntdll.dll => /cygdrive/c/WINDOWS/SYSTEM32/ntdll.dll (0x7ff88f2b0000)
+ KERNEL32.DLL => /cygdrive/c/WINDOWS/System32/KERNEL32.DLL (0x7ff88e450000)
+ KERNELBASE.dll => /cygdrive/c/WINDOWS/System32/KERNELBASE.dll (0x7ff88b9e0000)
+ cygwin1.dll => /usr/bin/cygwin1.dll (0x180040000)
+ cyggfortran-5.dll => /usr/bin/cyggfortran-5.dll (0x3efd20000)
+ cygquadmath-0.dll => /usr/bin/cygquadmath-0.dll (0x3ee0b0000)
+ cyggcc_s-seh-1.dll => /usr/bin/cyggcc_s-seh-1.dll (0x3f7000000)
+```
+
+Other compilers or other versions of the same compiler will probably
+require different dynamic libraries. As long as you run the program on
+the same computer — or, more accurately, within the same environment —
+there should be no problem. However, when such a library cannot be
+found, you will get (hopefully) an error message and the program stops
+immediately.
+
+Therefore it is good to know what libraries are required. On Linux and
+Linux-like environments, the `ldd` utility is a great help. On Windows,
+you may want to use the `dependency walker` (the latest version, which
+works very nicely with Windows 10, is found here: )
+
+Another thing you should know is where the program tries to find these
+libraries. That is a vast subject in its own right and full of
+complications and history. Here we merely scratch the surface:
+
+_On Linux:_
+
+- The environment variable `LD_LIBRARY_PATH` is used. It consists of a
+ list of directories to be searched, each directory separated via colons
+ (:) from the others. For instance: `/usr/lib:/usr/local/lib` — typical
+ system directories.
+- At the link step you can also use an option to set `RPATH`, a list
+ of directories that is put into the executable file itself.
+- Then there are several system directories that are searched.
+
+_On Windows:_
+
+- The directory containing the executable program may also contain
+ dynamic libraries.
+- The environment variable "PATH" is used. Again a list of directories
+ to be searched, but now the separating character is the semicolon (;).
+- A set of system directories is searched.
+
+Unfortunately, the details can change from one version of the operating
+system to the next. The above is merely an indication — use tools like
+"ldd" or "dependency walker" to find out what libraries are loaded and
+where they are found.
+
+If you want to share your program with colleagues or clients or simply
+users all over the world, you will have to take care that, besides the
+program, you also distribute the libraries it depends on. For more
+information: see below.
diff --git a/_sources/learn/intrinsics/array.md.txt b/_sources/learn/intrinsics/array.md.txt
new file mode 100644
index 000000000000..8955568e9b9d
--- /dev/null
+++ b/_sources/learn/intrinsics/array.md.txt
@@ -0,0 +1,8 @@
+# Properties and attributes of arrays
+
+::::{jinja} intrinsics
+{% for name in array %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/bit.md.txt b/_sources/learn/intrinsics/bit.md.txt
new file mode 100644
index 000000000000..103ac5f5b9b6
--- /dev/null
+++ b/_sources/learn/intrinsics/bit.md.txt
@@ -0,0 +1,8 @@
+# Bit-level inquiry and manipulation
+
+::::{jinja} intrinsics
+{% for name in bit %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/cfi.md.txt b/_sources/learn/intrinsics/cfi.md.txt
new file mode 100644
index 000000000000..b0c396306edc
--- /dev/null
+++ b/_sources/learn/intrinsics/cfi.md.txt
@@ -0,0 +1,8 @@
+# Procedures for binding to C interfaces
+
+::::{jinja} intrinsics
+{% for name in cfi %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/character.md.txt b/_sources/learn/intrinsics/character.md.txt
new file mode 100644
index 000000000000..f136540e8c60
--- /dev/null
+++ b/_sources/learn/intrinsics/character.md.txt
@@ -0,0 +1,8 @@
+# Basic procedures for manipulating _character_ variables
+
+::::{jinja} intrinsics
+{% for name in character %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/compiler.md.txt b/_sources/learn/intrinsics/compiler.md.txt
new file mode 100644
index 000000000000..aea194cbaf47
--- /dev/null
+++ b/_sources/learn/intrinsics/compiler.md.txt
@@ -0,0 +1,8 @@
+# Information about compiler and compiler options used for building
+
+::::{jinja} intrinsics
+{% for name in compiler %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/index.md.txt b/_sources/learn/intrinsics/index.md.txt
new file mode 100644
index 000000000000..1726a3130248
--- /dev/null
+++ b/_sources/learn/intrinsics/index.md.txt
@@ -0,0 +1,93 @@
+# Fortran Intrinsics
+
+This is a collection of extended descriptions of the Fortran intrinsics
+based on the reference document
+"[Current F2018 Working Document as of April 2018](http://isotc.iso.org/livelink/livelink?func=ll&objId=19442438&objAction=Open)".
+Vendor-specific extensions are not included.
+
+::::{dropdown} Intrinsics
+:color: primary
+
+```{toctree}
+:maxdepth: 2
+array
+bit
+character
+compiler
+cfi
+math
+model
+numeric
+parallel
+state
+system
+transform
+type
+GNU Free Documentation License
+
+::::
+
+## Overview
+
+The standard documents and most vendor-supplied descriptions of the
+intrinsics are often very brief and concise to the point where the
+functionality of the intrinsics becomes obscure, particularly to someone
+unfamiliar with the procedure.
+
+By describing the procedures here
+
+- in greater detail
+- with a working example
+- providing links to additional resources
+ (including additional documents at fortran-lang.org and related
+ discussions in Fortran Discourse)
+
+these documents strive to clarify the intrinsics for Fortran programmers.
+
+This is a community-driven resource and everyone is encouraged to contribute
+to the documents. For contribution guidelines see [minibook guide](/community/minibooks)
+and the following Copyright guidelines.
+
+## See Also
+
+- The [Fortran stdlib](https://stdlib.fortran-lang.org/) project
+
+- [fpm(1)](https://fortran-lang.org/packages/fpm) packages, many of
+ which are general-purpose libraries/modules
+
+- [M_intrinsics](https://github.com/urbanjost/M_intrinsics) a related project
+ to leverage the descriptions here to generate man-pages and an OS-agnostic CLI
+ (Command Line Interface) program. This includes a tar(1) and zip(1)
+ file of man-pages and a self-contained Fortran program that lets you
+ view the non-graphical plain ASCII portions of the documentation from
+ a terminal interface.
+
+## Text Content Copyrights
+
+Many of the documents presented here are modified versions of
+man-pages from the [Fortran Wiki](https://fortranwiki.org) and as such
+are available under the terms of the GNU Free Documentation License
+[**GFDL**](GNU_Free_Documentation_License.md) with no invariant sections,
+front-cover texts, or back-cover texts.
+
+If you contribute to this site by modifying the files marked as GFDL,
+you thereby agree to license the contributed material to the public
+under the GFDL (version 1.2 or any later version published by the Free
+Software Foundation, with no invariant sections, front-cover texts,
+or back-cover texts).
+
+If you contribute new material you thereby agree to release it under
+the MIT license, and should indicate this by placing MIT on the
+specially-formatted last line. For example, change
+
+```text
+###### fortran-lang intrinsic descriptions
+```
+
+to
+
+```text
+###### fortran-lang intrinsic descriptions (License: MIT) @urbanjost
+```
+
+Written in [Myst-Markdown](https://myst-parser.readthedocs.io/en/latest/)
diff --git a/_sources/learn/intrinsics/math.md.txt b/_sources/learn/intrinsics/math.md.txt
new file mode 100644
index 000000000000..dda72e01f823
--- /dev/null
+++ b/_sources/learn/intrinsics/math.md.txt
@@ -0,0 +1,8 @@
+# General mathematical functions
+
+::::{jinja} intrinsics
+{% for name in math %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/model.md.txt b/_sources/learn/intrinsics/model.md.txt
new file mode 100644
index 000000000000..f2aa1c70efe1
--- /dev/null
+++ b/_sources/learn/intrinsics/model.md.txt
@@ -0,0 +1,8 @@
+# Controlling and querying the current numeric model
+
+::::{jinja} intrinsics
+{% for name in model %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/numeric.md.txt b/_sources/learn/intrinsics/numeric.md.txt
new file mode 100644
index 000000000000..665626cfbfb4
--- /dev/null
+++ b/_sources/learn/intrinsics/numeric.md.txt
@@ -0,0 +1,8 @@
+# Manipulation and properties of numeric values
+
+::::{jinja} intrinsics
+{% for name in numeric %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/parallel.md.txt b/_sources/learn/intrinsics/parallel.md.txt
new file mode 100644
index 000000000000..9b3e17adfc35
--- /dev/null
+++ b/_sources/learn/intrinsics/parallel.md.txt
@@ -0,0 +1,8 @@
+# Parallel programming using co\_arrays and co\_indexed arrays
+
+::::{jinja} intrinsics
+{% for name in parallel %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/state.md.txt b/_sources/learn/intrinsics/state.md.txt
new file mode 100644
index 000000000000..555b27b854b5
--- /dev/null
+++ b/_sources/learn/intrinsics/state.md.txt
@@ -0,0 +1,8 @@
+# General and miscellaneous intrinsics
+
+::::{jinja} intrinsics
+{% for name in state %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/system.md.txt b/_sources/learn/intrinsics/system.md.txt
new file mode 100644
index 000000000000..3604c22d9c1e
--- /dev/null
+++ b/_sources/learn/intrinsics/system.md.txt
@@ -0,0 +1,8 @@
+# Accessing external system information
+
+::::{jinja} intrinsics
+{% for name in system %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/transform.md.txt b/_sources/learn/intrinsics/transform.md.txt
new file mode 100644
index 000000000000..770c3188c94d
--- /dev/null
+++ b/_sources/learn/intrinsics/transform.md.txt
@@ -0,0 +1,8 @@
+# Matrix multiplication, dot product, and array shifts
+
+::::{jinja} intrinsics
+{% for name in transform %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/intrinsics/type.md.txt b/_sources/learn/intrinsics/type.md.txt
new file mode 100644
index 000000000000..0a83294a8ee8
--- /dev/null
+++ b/_sources/learn/intrinsics/type.md.txt
@@ -0,0 +1,60 @@
+# Types and kinds
+
+These intrinsics allow for explicitly casting one type of variable to
+another or can be used to conditionally execute code blocks based on
+variable types when working with polymorphic variables.
+
+## Fortran Data Types
+
+Fortran provides five basic intrinsic data types:
+
+- Integer type
+ : The integer types can hold only whole number values.
+- Real type
+ : Stores floating point numbers, such as 2.0, 3.1415, -100.876, etc.
+- Complex type
+ : A complex number has two parts,
+ the real part and the imaginary part. Two consecutive floating
+ point storage units store the two parts.
+- Logical type
+ : There are only two logical values: .true. and .false.
+- Character type
+ : The character type stores strings. The length of the string
+ can be specified by the **len** specifier. If no length is specified, it is 1.
+
+These "types" can be of many "kinds". Often different numeric kinds
+take up different storage sizes and therefore can represent
+different ranges; but a different kind can have other meanings.
+A _character_ variable might represent ASCII characters or UTF-8 or
+Unicode characters, for example.
+
+You can derive your own data types from these fundamental types as well.
+
+## Implicit Typing
+
+Fortran allows a feature called implicit typing, i.e., you do not have
+to declare some variables before use. By default if a variable is not declared,
+then the first letter of its name will determine its type:
+
+1. Variable names starting with **i-n** (the first two letters of
+ "integer") specify _integer_ variables.
+
+2. All other variable names default to _real_.
+
+However, in most circles it is considered good programming practice to declare all the
+variables. For that to be enforced, you start your variable declaration section with
+a statement that turns off implicit typing:
+the statement
+
+```fortran
+implicit none
+```
+
+For more information refer to the **implicit** statement.
+
+::::{jinja} intrinsics
+{% for name in type %}
+```{include} _pages/{{ name }}.md
+```
+{% endfor %}
+::::
diff --git a/_sources/learn/os_setup/choose_compiler.md.txt b/_sources/learn/os_setup/choose_compiler.md.txt
new file mode 100644
index 000000000000..8e6cb3acc2e6
--- /dev/null
+++ b/_sources/learn/os_setup/choose_compiler.md.txt
@@ -0,0 +1,7 @@
+# Choosing a compiler
+
+A comprehensive list of available compilers is provided [here](/compilers). In this guide, we will focus only on those that are free to install and use.
+
+Of those listed at the link above, open source and free are GFortran (with OpenCoarrays), Flang, and LFortran. NVIDIA and Intel offer their compilers for free and as of the latest update of this tutorial, NVFortran (NVIDIA) is available only for Linux systems, while Intel oneAPI is available for Linux, Windows and macOS systems. Both are well documented and readers can find detailed information about installing and using them on their websites respectively.
+
+In the next chapter, we use GFortran for the tutorial as it is a mature open source compiler. We encourage users to also try other open source and commercial compilers.
diff --git a/_sources/learn/os_setup/ides.md.txt b/_sources/learn/os_setup/ides.md.txt
new file mode 100644
index 000000000000..40d33474a4e5
--- /dev/null
+++ b/_sources/learn/os_setup/ides.md.txt
@@ -0,0 +1,15 @@
+# IDEs
+
+An IDE (Integrated Development Environment) refers to a complete software development environment, where, all those packages that come as external plug-ins in Text-Editors, are already integrated within the software. An IDE is usually optimized towards a specific set of languages. For example it is very common for IDEs to advertise themselves towards either compiled or interpreted languages, or even towards a single language, or depending on the application developed, like scientific or web development.
+IDEs are recommended for beginner programmers, since it is possible to start coding with minimum effort after installation. However, it is quite common, in professional environments, individual developers and teams alike, to choose an IDE for large projects because of some unique features that they may offer over a Text-Editor.
+
+A list of popular IDEs that provide good Fortran support is provided in alphabetical order:
+
+- [AbsoftTools](https://www.absoft.com/technology/absofttools-fortran-ide/): commercial product, cross-platform, comes with Absoft's own Fortran compiler.
+- [Code::Blocks](http://www.codeblocks.org/): free product, cross-platform and supports multiple compilers. Plenty of tutorials online on how to install it and add a Fortran Compiler. As well as a recent presentation, [here](https://www.youtube.com/watch?v=M1RwVGGSAgE&ab_channel=FortranCon), of its capabilities and future prospects at the International Fortran Conference 2020 by its main developer.
+- [Eclipse-Photran](https://marketplace.eclipse.org/content/photran-fortran-ide-eclipse) _Photran is an IDE and refactoring tool for Fortran based on Eclipse and the C/C++ Development Tools_. A free product, cross-platform and supports multiple compilers.
+- [Geany](https://www.geany.org/): a free product, cross platform and supports multiple compilers.
+- [NAG Fortran Builder](https://www.nag.com/content/nag-fortran-builder-0) is a commercial product, available in Windows and MacOS and supports NAG's own Fortran Compiler.
+- [Plato](https://www.silverfrost.com/16/ftn95/plato.aspx) is a commercial product, cross-platform, comes with Silverfrost's Fortran FTN95 own Fortran compiler.
+- [SimplyFortran](https://simplyfortran.com/) is a commercial product, cross-platform with support of the GNU Fortran compiler.
+- [Visual Studio](https://visualstudio.microsoft.com/) its _Community Edition 2019_ is a free product, available in Windows and macOS and supports only Intel's Fortran compiler, now bundled with many other free-to-use HPC tools under _Intel oneAPI_.
diff --git a/_sources/learn/os_setup/index.md.txt b/_sources/learn/os_setup/index.md.txt
new file mode 100644
index 000000000000..cc4af6756480
--- /dev/null
+++ b/_sources/learn/os_setup/index.md.txt
@@ -0,0 +1,33 @@
+
+
+
A beginner's tutorial on the software that needs to be installed to start with Fortran development
+
+
+---
+
+_Authors: Stavros Meskos, Laurence Kedward, Arjen Markus, Ondřej Čertík, Milan Curcic_
+
+_Last update: 16-Feb-2021_
+
+---
+
+# Setting up your OS
+
+In this mini-book we address the very first problem that many new Fortran programmers encounter. Before everything, you will need to choose a compiler and install it. Then you will need a text editor or perhaps an IDE (Integrated Development Environment). There are many options, most of them available in all major OSs (operating systems). However, the process to install and configure them greatly differs between Windows, Linux, and macOS. There are several Fortran compilers. Here, we pick those that meet certain criteria and provide a guide on how to install them in all the aforementioned OSs. A list of popular text editors and IDEs and information on how to choose between them is presented as well.
+
+::::{note}
+If you have already set up your environment, you may skip this tutorial and move forward with the Quickstart Fortran Tutorial to start coding your first `Hello World` program or with the Building programs mini-book to understand how a compiler works.
+::::
+
+---
+
+_The choice of text editors and IDEs has been controversial among the developers. What you choose is a matter of personal taste. Every solution comes with its own pros and cons. For that reason, in this guide, we will not push the reader towards one or another direction. We will, however, present a list of the most popular tools._
+
+```{toctree}
+:hidden:
+Choosing a compiler
+Installing GFortran
+Text Editors
+IDEs
+Smart Tips
+```
diff --git a/_sources/learn/os_setup/install_gfortran.md.txt b/_sources/learn/os_setup/install_gfortran.md.txt
new file mode 100644
index 000000000000..c6df10ce3cdd
--- /dev/null
+++ b/_sources/learn/os_setup/install_gfortran.md.txt
@@ -0,0 +1,149 @@
+# Installing GFortran
+
+GFortran is the name of the [GNU Fortran project](https://gcc.gnu.org/fortran/). The main [wiki](https://gcc.gnu.org/wiki/GFortran) page offers many helpful links about GFortran, as well as Fortran in general. In this guide, the installation process for GFortran on Windows, Linux, macOS and OpenBSD is presented in a beginner-friendly format based on the information from [GFortranBinaries](https://gcc.gnu.org/wiki/GFortranBinaries).
+
+## Windows
+
+Three sources provide quick and easy way to install GFortran compiler on Windows:
+
+1. [http://www.equation.com](http://www.equation.com/servlet/equation.cmd?fa=fortran), provides 32 and 64-bit x86
+ executables for GCC version 12.1.
+2. [TDM GCC](https://jmeubank.github.io/tdm-gcc/articles/2021-05/10.3.0-release), provides 32 and 64-bit x86 executables for GCC version 10.3.
+3. [MinGW-w64](https://www.mingw-w64.org/downloads/#mingw-builds) provides a 64-bit x86 executable for GCC version 12.2.
+
+In all the above choices, the process is straightforward—just download the installer and follow the installation wizard.
+
+### Unix-like development on Windows
+
+For those familiar with a unix-like development environment, several emulation options are available on Windows each of which provide packages for gfortran:
+
+- **Cygwin:** A runtime environment that provides POSIX compatibility to Windows.
+- **MSYS2:** A collection of Unix-like development tools, based on modern Cygwin and MinGW-w64.
+- **Windows Subsystem for Linux (WSL):** An official compatibility layer for running Linux binary executables on Windows. With [Windows Subsystem for Linux GUI](https://github.com/microsoft/wslg) one can run text editors and other graphical programs.
+
+All of the above approaches provide access to common shells such as bash and development tools including GNU coreutils, Make, CMake, autotools, git, grep, sed, awk, ssh, etc.
+
+We recommend the WSL environment for those looking for a Unix-like development environment on Windows.
+
+## Linux
+
+### Debian-based (Debian, Ubuntu, Mint, etc...)
+
+Check whether you have gfortran already installed
+
+```bash
+which gfortran
+```
+
+If nothing is returned then gfortran is not installed.
+To install gfortran type:
+
+```bash
+sudo apt install gfortran
+```
+
+to check what version was installed type:
+
+```bash
+gfortran --version
+```
+
+You can install multiple versions up to version 10 (on Ubuntu 22.04) by typing the version number immediately after "gfortran", e.g.:
+
+```bash
+sudo apt install gfortran-8
+```
+
+To install newer versions on older Ubuntu releases, you will first need to add the following repository, update, and then install:
+
+```bash
+sudo add-apt-repository ppa:ubuntu-toolchain-r/test
+sudo apt update
+sudo apt install gfortran-10
+```
+
+Finally, you can switch between different versions or set the default one with the **update-alternatives** ([see manpage](https://manpages.ubuntu.com/manpages/jammy/en/man1/update-alternatives.1.html)). There are many online tutorials on how to use this feature. A well structured one using as an example C and C++ can be found [here](https://linuxconfig.org/how-to-switch-between-multiple-gcc-and-g-compiler-versions-on-ubuntu-22-04-lts-jammy-jellyfish), you can apply the same logic by replacing either `gcc` or `g++` with `gfortran`.
+
+### RPM-based (Red Hat Enterprise Linux, CentOS, Fedora, openSUSE)
+
+```bash
+sudo yum install gcc-gfortran
+```
+
+Since Fedora 22 and Red Hat Enterprise Linux 8, `dnf` is the default package manager:
+
+```bash
+sudo dnf install gcc-gfortran
+```
+
+### Arch-based (Arch Linux, EndeavourOS, Manjaro, etc...)
+
+```bash
+sudo pacman -S gcc-fortran
+```
+
+## macOS
+
+### Xcode
+
+If you have Xcode installed, open a terminal window and type:
+
+```bash
+xcode-select --install
+```
+
+### Binaries
+
+Go to [fxcoudert/gfortran-for-macOS](https://github.com/fxcoudert/gfortran-for-macOS/releases) to directly install binaries.
+
+### Homebrew
+
+```bash
+brew install gcc
+```
+
+### Fink
+
+GNU-gcc Package [link](https://pdb.finkproject.org/pdb/browse.php?summary=GNU+Compiler+Collection+Version)
+
+### MacPorts
+
+Search for available gcc versions:
+
+```bash
+port search gcc
+```
+
+Install a gcc version:
+
+```bash
+sudo port install gcc10
+```
+
+## OpenBSD
+
+```bash
+pkg_add g95
+```
+
+On OpenBSD, the GFortran executable is named `egfortran`. To test it, type:
+
+```bash
+egfortran -v
+```
+
+---
+
+## OpenCoarrays
+
+[OpenCoarrays](http://www.opencoarrays.org/) is an open-source software project that produces an application binary interface (ABI) used by the GNU Compiler Collection (GCC) Fortran front-end to build executable programs that leverage the parallel programming features of Fortran 2018. Since OpenCoarrays is not a separate compiler, we include it here, under gfortran.
+
+While with gfortran you can compile perfectly valid code using coarrays, the generated binaries will only run in a single image (_image_ is a Fortran term for a parallel process), that is, in serial mode. OpenCoarrays allows running code in parallel on shared- and distributed-memory machines, similar to MPI:
+
+```bash
+cafrun -n
+```
+
+The process of installation is provided in a clear and comprehensive manner on the official site.
+
+We emphasize that native installation on Windows is not possible. It is only possible through WSL.
diff --git a/_sources/learn/os_setup/text_editors.md.txt b/_sources/learn/os_setup/text_editors.md.txt
new file mode 100644
index 000000000000..1b7047f10a0b
--- /dev/null
+++ b/_sources/learn/os_setup/text_editors.md.txt
@@ -0,0 +1,52 @@
+# Text Editors
+
+After you have installed your compiler, you will need a text editor to write your code. Any text editor can serve this purpose, even the built-in Notepad on Windows. However, there are specialized editors for programming languages. These editors come with many useful features like auto-complete, syntax-highlighting, auto-indentation, brace-matching, and many more, with few of them pre-installed and the majority in form of external plug-ins. This means that by default these features are not installed in the editor, but it's up to you to search for them through a package manager and install and configure them manually.
+
+Here's a list of the most popular text editors that support Fortran syntax, in alphabetical order:
+
+- [Atom](https://atom.io/)
+- [Emacs](https://www.gnu.org/software/emacs/)
+- [NotePad++](https://notepad-plus-plus.org/)
+- [SublimeText](https://www.sublimetext.com/)
+- [Vim](https://www.vim.org/) and [Neovim](https://neovim.io/)
+- [Visual Studio Code](https://code.visualstudio.com/)
+
+A comprehensive list with more choices is provided in [fortranwiki.org](http://fortranwiki.org/fortran/show/Source+code+editors).
+
+Things to consider before choosing a text editor:
+
+- **Ergonomics:** This is purely subjective and concerns how easy, uninterrupted the UI (User Interface) feels to the developer while using the editor.
+- **Extensibility:** As mentioned above, text editors come with many features as external packages. The variety, the installation process, the documentation, and user-friendliness of the packages all fall under this category.
+- **Speed:** With how powerful modern hardware can be, the speed of editors is becoming of minor importance. However, for the less powerful systems, you may want to consider this as well. Heavyweight editors may impact the writing performance. For example, you can expect Atom and VSCode to run slower than the lightweight editors like Vim or Emacs.
+- **Learning curve:** Last but not least, new users should consider how easy it is to get used to a new editor. Vim and Emacs have a steep learning curve and are notoriously difficult for newcomers. They offer a uniquely different experience than any other editor by forcing you to use the keyboard for all editing tasks.
+
+## Configuring VS Code
+
+With the editor opened, at the main UI, at the buttoned-column on the left, there is a _four-square-shaped_ icon to open the Marketplace for extensions.
+Install [Modern Fortran](https://marketplace.visualstudio.com/items?itemName=krvajalm.linter-gfortran) for syntax highlighting, linting and Language Server support and formatting.
+
+### Additional Tools
+
+The following extensions are not essential but most users might find them useful:
+
+- [GitLens](https://marketplace.visualstudio.com/items?itemName=eamodio.gitlens) for advanced Git visualization and operations.
+- [CMake](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools) for full-featured CMake integration in VS Code.
+- [Remote Development](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack) for working with containers, on a remote machines, or in the Windows Subsystem for Linux (WSL).
+- [Even Better TOML by tamasfe](https://marketplace.visualstudio.com/items?itemName=tamasfe.even-better-toml). For Fortran developers that are using the new [fpm](https://github.com/fortran-lang/fpm) _Fortran Package Manager_, a TOML language support might come in handy.
+
+## Configuring SublimeText
+
+A well structured gist that provides instructions on how to set up SublimeText for Fortran developement is given [here](https://gist.github.com/sestelo/6b01e1405c1d0fa7f0ecdc951caaa995).
+
+## Configuring Atom
+
+Atom's configuration process is similar to VSCode one. At the main interface, if the _Welcome Guide_ page is already opened for you, just click the **Install a Package** option, otherwise you can find the same option through the navigation bar at the top by clicking _Packages_. In doing so a new page under _Settings_ opens where you can just start typing the package you want to install.
+
+One package that includes many Fortran features is [IDE-FORTRAN by hansec](https://atom.io/packages/ide-fortran). It needs the following packages to be installed:
+
+- [atom-ide ui by facebook-atom](https://atom.io/packages/atom-ide-ui)
+- [language-fortran by dparkins](https://atom.io/packages/language-fortran)
+
+Additionally just like in VSCode it needs [Python](https://www.python.org/) and [Fortran Language Server](https://github.com/hansec/fortran-language-server) to be installed.
+
+For version control a very popular package is [Git-Plus by akonwi](https://atom.io/packages/git-plus).
diff --git a/_sources/learn/os_setup/tips.md.txt b/_sources/learn/os_setup/tips.md.txt
new file mode 100644
index 000000000000..65b17da4a9c7
--- /dev/null
+++ b/_sources/learn/os_setup/tips.md.txt
@@ -0,0 +1,10 @@
+# Smart Tips
+
+To conclude, we give a few tips that may help you to choose a compiler and an editor or an IDE.
+
+- Check [this site](https://www.fortran.uk/fortran-compiler-comparisons/) for a comprehensive comparison of Fortran compilers.
+- Since NVFortran version 17.1, the support for compute capability 2.0 (Fermi) and lower has been removed. This is important because, at any time, only the latest compiler version is free to download. Users with older GPUs will not be able to run CUDA Fortran with the current (20.7) or future versions. Read [this wiki](https://www.wikiwand.com/en/CUDA#/GPUs_supported) to find your GPU's compute capability and cross-check with the latest CUDA SDK that supports it.
+- There are many online Fortran compilers. These are websites that offer a basic text editor and allow you to compile and run your code on a remote server. They are particularly useful for quick prototyping and testing. Although we promised neutrality, we recommend that you check out the open-source and free [Compiler Explorer](https://godbolt.org/), an amazing tool with unique features.
+- Arguably the most popular text editor, according to recent online surveys, is the Visual Studio Code, developed by Microsoft.
+- The most popular free IDEs are the Code::Blocks and Geany. Many commercial IDEs give up to 30 days of free trial. Keep in mind that the prices of commercial IDEs may vary, and some may be quite affordable. Finally, if you are a student, an open-source developer, or a …hobbyist _Fortraner_ do not hesitate to contact those companies and request a discount. There have been cases, e.g., in r/fortran, where representatives, from at least one company, have offered discount codes to individuals looking for affordable complete solutions (IDE + compiler).
+- Finally, please join us on [Fortran Discourse](https://fortran-lang.discourse.group/) and do not hesitate to post your questions and request for further information.
diff --git a/_sources/learn/quickstart/arrays_strings.md.txt b/_sources/learn/quickstart/arrays_strings.md.txt
new file mode 100644
index 000000000000..bfa6b52ba65a
--- /dev/null
+++ b/_sources/learn/quickstart/arrays_strings.md.txt
@@ -0,0 +1,181 @@
+# Arrays and strings
+
+More often than not, we need to store and operate on long lists of numbers as opposed to just the single scalar variables
+that we have been using so far; in computer programming such lists are called _arrays_.
+
+Arrays are _multidimensional_ variables that contain more than one value
+where each value is accessed using one or more indices.
+
+> Arrays in Fortran are _one-based_ by default; this means
+> that the first element along any dimension is at index 1.
+
+# Array declaration
+
+We can declare arrays of any type. There are two common notations for declaring array variables:
+using the `dimension` attribute or by appending the array dimensions in parentheses to the variable name.
+
+**Example:** static array declaration
+
+```fortran
+program arrays
+ implicit none
+
+ ! 1D integer array
+ integer, dimension(10) :: array1
+
+ ! An equivalent array declaration
+ integer :: array2(10)
+
+ ! 2D real array
+ real, dimension(10, 10) :: array3
+
+ ! Custom lower and upper index bounds
+ real :: array4(0:9)
+ real :: array5(-5:5)
+
+end program arrays
+```
+
+## Array slicing
+
+A powerful feature of the Fortran language is its built-in support for array operations;
+we can perform operations on all or part of an array using array _slicing_ notation:
+
+**Example:** array slicing
+
+```fortran
+program array_slice
+ implicit none
+
+ integer :: i
+ integer :: array1(10) ! 1D integer array of 10 elements
+ integer :: array2(10, 10) ! 2D integer array of 100 elements
+
+ array1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] ! Array constructor
+ array1 = [(i, i = 1, 10)] ! Implied do loop constructor
+ array1(:) = 0 ! Set all elements to zero
+ array1(1:5) = 1 ! Set first five elements to one
+ array1(6:) = 1 ! Set all elements after five to one
+
+ print *, array1(1:10:2) ! Print out elements at odd indices
+ print *, array2(:,1) ! Print out the first column in a 2D array
+ print *, array1(10:1:-1) ! Print an array in reverse
+
+end program array_slice
+```
+
+> Fortran arrays are stored in _column-major_ order; the first
+> index varies fastest.
+
+## Allocatable (dynamic) arrays
+
+So far we have specified the size of our array in our program code---this
+type of array is known as a _static_ array since its size is fixed when
+we compile our program.
+
+Quite often, we do not know how big our array needs to be until we run our program, for example, if we are reading data from a file of unknown size.
+
+For this problem, we need `allocatable` arrays.
+These are _allocated_ while the program is running once we know how big the array needs to be.
+
+**Example:** allocatable arrays
+
+```fortran
+program allocatable
+ implicit none
+
+ integer, allocatable :: array1(:)
+ integer, allocatable :: array2(:,:)
+
+ allocate(array1(10))
+ allocate(array2(10,10))
+
+ ! ...
+
+ deallocate(array1)
+ deallocate(array2)
+
+end program allocatable
+```
+
+Allocatable local arrays are deallocated automatically
+when they go out of scope.
+
+## Character strings
+
+**Example:** static character string
+
+```fortran
+program string
+ implicit none
+
+ character(len=4) :: first_name
+ character(len=5) :: last_name
+ character(10) :: full_name
+
+ first_name = 'John'
+ last_name = 'Smith'
+
+ ! String concatenation
+ full_name = first_name//' '//last_name
+
+ print *, full_name
+
+end program string
+```
+
+**Example:** allocatable character string
+
+```fortran
+program allocatable_string
+ implicit none
+
+ character(:), allocatable :: first_name
+ character(:), allocatable :: last_name
+
+ ! Explicit allocation statement
+ allocate(character(4) :: first_name)
+ first_name = 'John'
+
+ ! Allocation on assignment
+ last_name = 'Smith'
+
+ print *, first_name//' '//last_name
+
+end program allocatable_string
+```
+
+## Array of strings
+
+An array of strings can be expressed in Fortran as an array of `character` variables.
+All elements in a `character` array have equal length.
+However, strings of varying lengths can be provided as input to the array constructor, as shown in the example below.
+They will be truncated or right-padded with spaces if they are longer or shorter, respectively, than the declared length of the `character` array.
+Finally, we use the intrinsic function `trim` to remove any excess spaces when printing the values to the standard output.
+
+**Example:** string array
+
+```fortran
+program string_array
+ implicit none
+ character(len=10), dimension(2) :: keys, vals
+
+ keys = [character(len=10) :: "user", "dbname"]
+ vals = [character(len=10) :: "ben", "motivation"]
+
+ call show(keys, vals)
+
+ contains
+
+ subroutine show(akeys, avals)
+ character(len=*), intent(in) :: akeys(:), avals(:)
+ integer :: i
+
+ do i = 1, size(akeys)
+ print *, trim(akeys(i)), ": ", trim(avals(i))
+ end do
+
+ end subroutine show
+
+end program string_array
+```
diff --git a/_sources/learn/quickstart/derived_types.md.txt b/_sources/learn/quickstart/derived_types.md.txt
new file mode 100644
index 000000000000..aa94943ddc82
--- /dev/null
+++ b/_sources/learn/quickstart/derived_types.md.txt
@@ -0,0 +1,331 @@
+# Derived Types
+
+As discussed previously in [Variables](variables), there are five built-in data types in Fortran. A _derived type_ is a special form of data type that can encapsulate other built-in types as well as other derived types. It could be considered equivalent to _struct_ in the C and C++ programming languages.
+
+## A quick take on derived types
+
+Here's an example of a basic derived type:
+
+```fortran
+type :: t_pair
+ integer :: i
+ real :: x
+end type
+```
+
+The syntax to create a variable of type `t_pair` and access its members is:
+
+```fortran
+! Declare
+type(t_pair) :: pair
+! Initialize
+pair%i = 1
+pair%x = 0.5
+```
+
+> The percentage symbol `%` is used to access the members of a derived type.
+
+In the above snippet, we declared an instance of a derived type and initialized its members explicitly.
+You can also initialize derived type members by invoking the derived type constructor.
+
+Example using the derived type constructor:
+
+```fortran
+pair = t_pair(1, 0.5) ! Initialize with positional arguments
+pair = t_pair(i=1, x=0.5) ! Initialize with keyword arguments
+pair = t_pair(x=0.5, i=1) ! Keyword arguments can go in any order
+```
+
+Example with default initialization:
+
+```fortran
+type :: t_pair
+ integer :: i = 1
+ real :: x = 0.5
+end type
+
+type(t_pair) :: pair
+pair = t_pair() ! pair%i is 1, pair%x is 0.5
+pair = t_pair(i=2) ! pair%i is 2, pair%x is 0.5
+pair = t_pair(x=2.7) ! pair%i is 1, pair%x is 2.7
+```
+
+## Derived types in detail
+
+The full syntax of a derived type with all optional properties is presented below:
+
+```
+type [,attribute-list] :: name [(parameterized-declaration-list)]
+ [parameterized-definition-statements]
+ [private statement or sequence statement]
+ [member-variables]
+contains
+ [type-bound-procedures]
+end type
+```
+
+## Options to declare a derived type
+
+`attribute-list` may refer to the following:
+
+- _access-type_ that is either `public` or `private`
+- `bind(c)` offers interoperability with C programming language
+- `extends(`_parent_`)`, where _parent_ is the name of a previously declared derived type from which the current derived type will inherit all its members and functionality
+- `abstract` -- an object oriented feature that is covered in the advanced programming tutorial
+
+> If the attribute `bind(c)` or the statement `sequence` is used, then a derived type cannot have the attribute `extends` and vice versa.
+
+The `sequence` attribute may be used only to declare that the following members should be accessed in the same order as they are defined within the derived type.
+
+Example with `sequence`:
+
+```fortran
+type :: t_pair
+ sequence
+ integer :: i
+ real :: x
+end type
+! Initialize
+type(t_pair) :: pair
+pair = t_pair(1, 0.5)
+```
+
+> The use of the statement `sequence` presupposes that the data types defined below are neither of `allocatable` nor of `pointer` type. Furthermore, it does not imply that these data types will be stored in memory in any particular form, i.e., there is no relation to the `contiguous` attribute.
+
+The _access-type_ attributes `public` and `private`, if used, declare that all member-variables declared below will be automatically assigned the attribute accordingly.
+
+The attribute `bind(c)` is used to achieve compatibility between Fortran's derived type and C's struct.
+
+Example with `bind(c)`:
+
+```fortran
+module f_to_c
+ use iso_c_bindings, only: c_int
+ implicit none
+
+ type, bind(c) :: f_type
+ integer(c_int) :: i
+ end type
+
+end module f_to_c
+```
+
+matches the following C struct type:
+
+```c
+struct c_struct {
+ int i;
+};
+```
+
+> A fortran derived type with the attribute `bind(c)` cannot have the `sequence` and `extends` attributes. Furthermore it cannot contain any Fortran `pointer` or `allocatable` types.
+
+`parameterized-declaration-list` is an optional feature. If used, then the parameters must be listed in place of `[parameterized-definition-statements]` and must be either `len` or `kind` parameters or both.
+
+Example of a derived type with `parameterized-declaration-list` and with the attribute `public`:
+
+```fortran
+module m_matrix
+ implicit none
+ private
+
+ type, public :: t_matrix(rows, cols, k)
+ integer, len :: rows, cols
+ integer, kind :: k = kind(0.0)
+ real(kind=k), dimension(rows, cols) :: values
+ end type
+
+end module m_matrix
+
+program test_matrix
+ use m_matrix
+ implicit none
+
+ type(t_matrix(rows=5, cols=5)) :: m
+
+end program test_matrix
+```
+
+> In this example the parameter `k` has already been assigned a default value of `kind(0.0)` (single-precision floating-point). Therefore, it can be omitted, as is the case here in the declaration inside the main program.
+
+> By default, derived types and their members are public. However, in this example, the attribute `private` is used at the beginning of the module. Therefore, everything within the module will be by default `private` unless explicitly declared as `public`. If the type `t_matrix` was not given the attribute `public` in the above example, then the compiler would throw an error inside `program test`.
+
+The attribute `extends` was added in the F2003 standard and introduces an important feature of the object oriented paradigm (OOP), namely inheritance. It allows code reusability by letting child types derive from extensible parent types: `type, extends(parent) :: child`. Here, `child` inherits all the members and functionality from `type :: parent`.
+
+Example with the attribute `extends`:
+
+```fortran
+module m_employee
+ implicit none
+ private
+ public t_date, t_address, t_person, t_employee
+ ! Note another way of using the public attribute:
+ ! gathering all public data types in one place.
+
+ type :: t_date
+ integer :: year, month, day
+ end type
+
+ type :: t_address
+ character(len=:), allocatable :: city, road_name
+ integer :: house_number
+ end type
+
+ type, extends(t_address) :: t_person
+ character(len=:), allocatable :: first_name, last_name, e_mail
+ end type
+
+ type, extends(t_person) :: t_employee
+ type(t_date) :: hired_date
+ character(len=:), allocatable :: position
+ real :: monthly_salary
+ end type
+
+end module m_employee
+
+program test_employee
+ use m_employee
+ implicit none
+ type(t_employee) :: employee
+
+ ! Initialization
+
+ ! t_employee has access to type(t_date) members not because of extends
+ ! but because a type(t_date) was declared within t_employee.
+ employee%hired_date%year = 2020
+ employee%hired_date%month = 1
+ employee%hired_date%day = 20
+
+ ! t_employee has access to t_person, and inherits its members due to extends.
+ employee%first_name = 'John'
+ employee%last_name = 'Doe'
+
+ ! t_employee has access to t_address, because it inherits from t_person,
+ ! which in return inherits from t_address.
+ employee%city = 'London'
+ employee%road_name = 'BigBen'
+ employee%house_number = 1
+
+ ! t_employee has access to its defined members.
+ employee%position = 'Intern'
+ employee%monthly_salary = 0.0
+
+end program test_employee
+```
+
+## Options to declare members of a derived type
+
+`[member-variables]` refers to the declaration of all the member data types. These data types can be of any built-in data type, and/or of other derived types, as already showcased in the above examples. However, member-variables can have their own extensive syntax, in form of:
+`type [,member-attributes] :: name[attr-dependent-spec][init]`
+
+`type`: any built-in type or other derived type
+
+`member-attributes` (optional):
+
+- `public` or `private` access attributes
+- `protected` access attribute
+- `allocatable` with or without `dimension` to specify a dynamic array
+- `pointer`, `codimension`, `contiguous`, `volatile`, `asynchronous`
+
+Examples of common cases:
+
+```fortran
+type :: t_example
+ ! 1st case: simple built-in type with access attribute and [init]
+ integer, private :: i = 0
+ ! private hides it from use outside of the t_example's scope.
+ ! The default initialization [=0] is the [init] part.
+
+ ! 2nd case: protected
+ integer, protected :: i
+ ! In contrary to private, protected allows access to i assigned value outside of t_example
+ ! but is not definable, i.e. a value may be assigned to i only within t_example.
+
+ ! 3rd case: dynamic 1-D array
+ real, allocatable, dimension(:) :: x
+ ! the same as
+ real, allocatable :: x(:)
+ ! This parentheses' usage implies dimension(:) and is one of the possible [attr-dependent-spec].
+end type
+```
+
+> The following attributes: `pointer`, `codimension`, `contiguous`, `volatile`, `asynchronous` are advanced features that will not be addressed in the _Quickstart_ tutorial. However, they are presented here, in order for the readers to know that these features do exist and be able to recognize them. These features will be covered in detail in the upcoming _Advanced programing_ mini-book.
+
+## Type-bound procedures
+
+A derived type can contain functions or subroutines that are _bound_ to it. We'll refer to them as _type-bound procedures_. Type-bound procedures follow the `contains` statement that, in turn, follows all member variable declarations.
+
+> It is impossible to describe type-bound procedures in full without delving into OOP features of modern Fortran. For now we'll focus on a simple example to show their basic use.
+
+Here's an example of a derived type with a basic type-bound procedure:
+
+```fortran
+module m_shapes
+ implicit none
+ private
+ public t_square
+
+ type :: t_square
+ real :: side
+ contains
+ procedure :: area ! procedure declaration
+ end type
+
+contains
+
+ ! Procedure definition
+ real function area(self) result(res)
+ class(t_square), intent(in) :: self
+ res = self%side**2
+ end function
+
+end module m_shapes
+
+program main
+ use m_shapes
+ implicit none
+
+ ! Variables' declaration
+ type(t_square) :: sq
+ real :: x, side
+
+ ! Variables' initialization
+ side = 0.5
+ sq%side = side
+
+ x = sq%area()
+ ! self does not appear here, it has been passed implicitly
+
+ ! Do stuff with x...
+
+end program main
+```
+
+What is new:
+
+- `self` is an arbitrary name that we chose to represent the instance of the derived type `t_square` inside the type-bound function. This allows us to access its members and to automatically pass it as an argument when we invoke a type-bound procedure.
+- We now use `class(t_square)` instead of `type(t_square)` in the interface of the `area` function. This allows us to invoke the `area` function with any derived type that extends `t_square`. The keyword `class` introduces the OOP feature polymorphism.
+
+In the above example, the type-bound procedure `area` is defined as a function and can be invoked only in an expression, for example `x = sq%area()` or `print *, sq%area()`. If you define it instead as a subroutine, you can invoke it from its own `call` statement:
+
+```fortran
+! Change within module
+contains
+ subroutine area(self, x)
+ class(t_square), intent(in) :: self
+ real, intent(out) :: x
+ x = self%side**2
+ end subroutine
+
+! ...
+
+! Change within main program
+call sq%area(x)
+
+! Do stuff with x...
+```
+
+In contrast to the example with the type-bound function, we now have two arguments:
+
+- `class(t_square), intent(in) :: self` -- the instance of the derived type itself
+- `real, intent(out) :: x` -- used to store the calculated area and return to the caller
diff --git a/_sources/learn/quickstart/hello_world.md.txt b/_sources/learn/quickstart/hello_world.md.txt
new file mode 100644
index 000000000000..a5d891a1aa21
--- /dev/null
+++ b/_sources/learn/quickstart/hello_world.md.txt
@@ -0,0 +1,66 @@
+# Hello world
+
+In this part of the tutorial, we will write our first Fortran program:
+the ubiquitous ["Hello, World!"](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program) example.
+
+However, before we can write our program, we need to ensure that we have
+a Fortran compiler set up.
+
+> Fortran is a _compiled language_, which means that, once written, the source code must be passed through a
+> compiler to produce a machine executable that can be run.
+
+# Compiler setup
+
+In this tutorial, we'll work with the free and open source
+[GNU Fortran compiler (gfortran)](https://gcc.gnu.org/fortran/),
+which is part of the
+[GNU Compiler Collection (GCC)](https://gcc.gnu.org/).
+
+To install gfortran on Linux, use your system package manager.
+On macOS, you can install gfortran using [Homebrew](https://brew.sh/) or [MacPorts](https://www.macports.org/).
+On Windows, you can get native binaries [here](http://www.equation.com/servlet/equation.cmd?fa=fortran).
+
+To check if you have _gfortran_ setup correctly, open a terminal and run the following command:
+
+```shell
+$> gfortran --version
+```
+
+this should output something like:
+
+```
+GNU Fortran 7.5.0
+Copyright (C) 2017 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+```
+
+## Hello world
+
+Once you have set up your compiler, open a new file in your favourite code editor and enter the following:
+
+```fortran
+program hello
+ ! This is a comment line; it is ignored by the compiler
+ print *, 'Hello, World!'
+end program hello
+```
+
+Having saved your program to `hello.f90`, compile at the command line with:
+
+```shell
+$> gfortran hello.f90 -o hello
+```
+
+> `.f90` is the standard file extension for modern Fortran source files.
+> The 90 refers to the first modern Fortran standard in 1990.
+
+To run your compiled program:
+
+```shell
+$> ./hello
+Hello, World!
+```
+
+Congratulations, you've written, compiled and run your first Fortran program!
+In the next part of this tutorial, we will introduce variables for storing data.
diff --git a/_sources/learn/quickstart/index.md.txt b/_sources/learn/quickstart/index.md.txt
new file mode 100644
index 000000000000..6cefd11f1d96
--- /dev/null
+++ b/_sources/learn/quickstart/index.md.txt
@@ -0,0 +1,20 @@
+# Quickstart tutorial
+
+This quickstart tutorial gives an overview of the Fortran programming language
+and its syntax for common structured programming concepts including:
+types, variables, arrays, control flow and functions.
+
+The contents of this tutorial are shown in the navigation bar on the left with the current page highlighted bold.
+
+Use the _Next_ button at the bottom to start the tutorial with a _Hello World_ example.
+
+```{toctree}
+:maxdepth: 2
+:hidden:
+Hello world
+Variables
+Arrays and strings
+Operators and flow control
+Organising code structure
+Derived Types
+```
diff --git a/_sources/learn/quickstart/operators_control_flow.md.txt b/_sources/learn/quickstart/operators_control_flow.md.txt
new file mode 100644
index 000000000000..a1618d968305
--- /dev/null
+++ b/_sources/learn/quickstart/operators_control_flow.md.txt
@@ -0,0 +1,231 @@
+# Operators and flow control
+
+One of the powerful advantages of computer algorithms, compared to simple mathematical formulae,
+comes in the form of program _branching_ whereby the program can decide which instructions to
+execute next based on a logical condition.
+
+There are two main forms of controlling program flow:
+
+- _Conditional_ (if): choose program path based on a boolean (true or false) value
+
+- _Loop_: repeat a portion of code multiple times
+
+# Logical operators
+
+Before we use a conditional branching operator, we need to be able to form
+a logical expression.
+
+To form a logical expression, the following set of relational operators are available:
+
+| Operator | Alternative | Description |
+| :-------------: | :----------------: | --------------------------------------------------------------- |
+| `==` | `.eq.` | Tests for equality of two operands |
+| `/=` | `.ne.` | Test for inequality of two operands |
+| `> ` | `.gt.` | Tests if left operand is strictly greater than right operand |
+| `< ` | `.lt.` | Tests if left operand is strictly less than right operand |
+| `>=` | `.ge.` | Tests if left operand is greater than or equal to right operand |
+| `<=` | `.le.` | Tests if left operand is less than or equal to right operand |
+
+
+
+as well as the following logical operators:
+
+| Operator | Description |
+| :-------------: | -------------------------------------------------------------------- |
+| `.and.` | TRUE if both left and right operands are TRUE |
+| `.or.` | TRUE if either left or right or both operands are TRUE |
+| `.not.` | TRUE if right operand is FALSE |
+| `.eqv.` | TRUE if left operand has same logical value as right operand |
+| `.neqv.` | TRUE if left operand has the opposite logical value as right operand |
+
+
+
+## Conditional construct (`if`)
+
+In the following examples, a conditional `if` construct is used to print out a
+message to describe the nature of the `angle` variable:
+
+**Example:** single branch `if`
+
+```fortran
+if (angle < 90.0) then
+ print *, 'Angle is acute'
+end if
+```
+
+In this first example, the code within the `if` construct is _only executed if_ the
+test expression (`angle < 90.0`) is true.
+
+::::{tip}
+It is good practice to indent code within constructs such as `if` and `do`
+to make code more readable.
+::::
+
+We can add an alternative branch to the construct using the `else` keyword:
+
+**Example:** two-branch `if`-`else`
+
+```fortran
+if (angle < 90.0) then
+ print *, 'Angle is acute'
+else
+ print *, 'Angle is obtuse'
+end if
+```
+
+Now there are two _branches_ in the `if` construct, but _only one branch is executed_ depending
+on the logical expression following the `if` keyword.
+
+We can actually add any number of branches using `else if` to specify more conditions:
+
+**Example:** multi-branch `if`-`else if`-`else`
+
+```fortran
+if (angle < 90.0) then
+ print *, 'Angle is acute'
+else if (angle < 180.0) then
+ print *, 'Angle is obtuse'
+else
+ print *, 'Angle is reflex'
+end if
+```
+
+When multiple conditional expressions are used, each conditional expression is tested only if none of the previous
+expressions have evaluated to true.
+
+## Loop constructs (`do`)
+
+In the following example, a `do` loop construct is used to print out the numbers in
+a sequence.
+The `do` loop has an integer _counter_ variable which is used to track which iteration of the loop
+is currently executing. In this example we use a common name for this counter variable: `i`.
+
+When we define the start of the `do` loop, we use our counter variable name followed by an equals (`=`) sign
+to specify the start value and final value of our counting variable.
+
+**Example:** `do` loop
+
+```fortran
+integer :: i
+
+do i = 1, 10
+ print *, i
+end do
+```
+
+**Example:** `do` loop with skip
+
+```fortran
+integer :: i
+
+do i = 1, 10, 2
+ print *, i ! Print odd numbers
+end do
+```
+
+### Conditional loop (`do while`)
+
+A condition may be added to a `do` loop with the `while` keyword. The loop will be executed while the condition given
+in `while()` evaluates to `.true.`.
+
+**Example:** `do while()` loop
+
+```fortran
+integer :: i
+
+i = 1
+do while (i < 11)
+ print *, i
+ i = i + 1
+end do
+! Here i = 11
+```
+
+### Loop control statements (`exit` and `cycle`)
+
+Most often than not, loops need to be stopped if a condition is met. Fortran provides two executable statements to deal
+with such cases.
+
+`exit` is used to quit the loop prematurely. It is usually enclosed inside an `if`.
+
+**Example:** loop with `exit`
+
+```fortran
+integer :: i
+
+do i = 1, 100
+ if (i > 10) then
+ exit ! Stop printing numbers
+ end if
+ print *, i
+end do
+! Here i = 11
+```
+
+On the other hand, `cycle` skips whatever is left of the loop and goes into the next cycle.
+
+**Example:** loop with `cycle`
+
+```fortran
+integer :: i
+
+do i = 1, 10
+ if (mod(i, 2) == 0) then
+ cycle ! Don't print even numbers
+ end if
+ print *, i
+end do
+```
+
+::::{note}
+When used within nested loops, the `cycle` and `exit` statements operate on the innermost loop.
+::::
+
+### Nested loop control: tags
+
+A recurring case in any programming language is the use of nested loops. Nested loops refer to loops that exist within another loop. Fortran allows the programmer to _tag_ or _name_ each loop. If loops are tagged, there are two potential benefits:
+
+1. The readability of the code may be improved (when the naming is meaningful).
+2. `exit` and `cycle` may be used with tags, which allows for very fine-grained control of the loops.
+
+**Example:** tagged nested loops
+
+```fortran
+integer :: i, j
+
+outer_loop: do i = 1, 10
+ inner_loop: do j = 1, 10
+ if ((j + i) > 10) then ! Print only pairs of i and j that add up to 10
+ cycle outer_loop ! Go to the next iteration of the outer loop
+ end if
+ print *, 'I=', i, ' J=', j, ' Sum=', j + i
+ end do inner_loop
+end do outer_loop
+```
+
+### Parallelizable loop (`do concurrent`)
+
+The `do concurrent` loop is used to explicitly specify that the _inside of the loop has no interdependencies_; this informs the compiler that it may use parallelization/_SIMD_ to speed up execution of the loop and conveys programmer intention more clearly. More specifically, this means
+that any given loop iteration does not depend on the prior execution of other loop iterations. It is also necessary that any state changes that may occur must only happen within each `do concurrent` loop.
+These requirements place restrictions on what can be placed within the loop body.
+
+> Simply replacing a `do` loop with a `do concurrent` does not guarantee parallel execution.
+> The explanation given above does not detail all the requirements that need to be met in order to write a correct `do concurrent` loop.
+> Compilers are also free to do as they see fit, meaning they may not optimize the loop (e.g., a small number of iterations doing a simple calculation, like the
+> below example).
+> In general, compiler flags are required to activate possible parallelization for `do concurrent` loops.
+
+**Example:** `do concurrent()` loop
+
+```fortran
+real, parameter :: pi = 3.14159265
+integer, parameter :: n = 10
+real :: result_sin(n)
+integer :: i
+
+do concurrent (i = 1:n) ! Careful, the syntax is slightly different
+ result_sin(i) = sin(i * pi/4.)
+end do
+
+print *, result_sin
+```
diff --git a/_sources/learn/quickstart/organising_code.md.txt b/_sources/learn/quickstart/organising_code.md.txt
new file mode 100644
index 000000000000..3e2d8b31bf83
--- /dev/null
+++ b/_sources/learn/quickstart/organising_code.md.txt
@@ -0,0 +1,173 @@
+# Organising code structure
+
+Most programming languages allow you to collect commonly-used code into
+_procedures_ that can be reused by _calling_ them from other sections of code.
+
+Fortran has two forms of procedure:
+
+- **Subroutine**: invoked by a `call` statement
+- **Function**: invoked within an expression or assignment to which it returns a value
+
+Both subroutines and functions have access to variables in the parent scope by _argument association_;
+unless the `value` attribute is specified, this is similar to call by reference.
+
+# Subroutines
+
+The subroutine input arguments, known as _dummy arguments_, are specified in parentheses after the subroutine name;
+the dummy argument types and attributes are declared within the body of the subroutine just like local variables.
+
+**Example:**
+
+```fortran
+! Print matrix A to screen
+subroutine print_matrix(n,m,A)
+ implicit none
+ integer, intent(in) :: n
+ integer, intent(in) :: m
+ real, intent(in) :: A(n, m)
+
+ integer :: i
+
+ do i = 1, n
+ print *, A(i, 1:m)
+ end do
+
+end subroutine print_matrix
+```
+
+Note the additional `intent` attribute when declaring the dummy arguments; this optional attribute signifies to the compiler whether the argument
+is ''read-only'' (`intent(in)`) ''write-only'' (`intent(out)`) or ''read-write'' (`intent(inout)`) within the procedure.
+In this example, the subroutine does not modify its arguments, hence all arguments are `intent(in)`.
+
+> It is good practice to always specify the `intent` attribute for
+> dummy arguments; this allows the compiler to check for unintentional errors and provides self-documentation.
+
+We can call this subroutine from a program using a `call` statement:
+
+```fortran
+program call_sub
+ implicit none
+
+ real :: mat(10, 20)
+
+ mat(:,:) = 0.0
+
+ call print_matrix(10, 20, mat)
+
+end program call_sub
+```
+
+> This example uses a so-called _explicit-shape_ array argument since we have passed additional variables to describe
+> the dimensions of the array `A`; this will not be necessary if we place our subroutine in a module as described later.
+
+## Functions
+
+```fortran
+! L2 Norm of a vector
+function vector_norm(n,vec) result(norm)
+ implicit none
+ integer, intent(in) :: n
+ real, intent(in) :: vec(n)
+ real :: norm
+
+ norm = sqrt(sum(vec**2))
+
+end function vector_norm
+```
+
+> In production code, the intrinsic function `norm2` should be used.
+
+To execute this function:
+
+```fortran
+program run_fcn
+ implicit none
+
+ real :: v(9)
+ real :: vector_norm
+
+ v(:) = 9
+
+ print *, 'Vector norm = ', vector_norm(9,v)
+
+end program run_fcn
+```
+
+> It is good programming practice for functions not to modify their arguments---that is, all function arguments should be `intent(in)`.
+> Such functions are known as `pure` functions.
+> Use subroutines if your procedure needs to modify its arguments.
+
+## Modules
+
+Fortran modules contain definitions that are made accessible to programs, procedures, and other modules through the `use` statement.
+They can contain data objects, type definitions, procedures, and interfaces.
+
+- Modules allow controlled scoping extension whereby entity access is made explicit
+- Modules automatically generate explicit interfaces required for modern procedures
+
+> It is recommended to always place functions and subroutines
+> within modules.
+
+**Example:**
+
+```fortran
+module my_mod
+ implicit none
+
+ private ! All entities are now module-private by default
+ public public_var, print_matrix ! Explicitly export public entities
+
+ real, parameter :: public_var = 2
+ integer :: private_var
+
+contains
+
+ ! Print matrix A to screen
+ subroutine print_matrix(A)
+ real, intent(in) :: A(:,:) ! An assumed-shape dummy argument
+
+ integer :: i
+
+ do i = 1, size(A,1)
+ print *, A(i,:)
+ end do
+
+ end subroutine print_matrix
+
+end module my_mod
+```
+
+> Compare this `print_matrix` subroutine with that written outside of a module
+> we no longer have to explicitly pass the matrix dimensions and can instead take
+> advantage of _assumed-shape_ arguments since the module will generate the required
+> explicit interface for us. This results in a much simpler subroutine interface.
+
+To `use` the module within a program:
+
+```fortran
+program use_mod
+ use my_mod
+ implicit none
+
+ real :: mat(10, 10)
+
+ mat(:,:) = public_var
+
+ call print_matrix(mat)
+
+end program use_mod
+```
+
+**Example:** explicit import list
+
+```fortran
+use my_mod, only: public_var
+```
+
+**Example:** aliased import
+
+```fortran
+use my_mod, only: printMat=>print_matrix
+```
+
+> Each module should be written in a separate `.f90` source file. Modules need to be compiled prior to any program units that `use` them.
diff --git a/_sources/learn/quickstart/variables.md.txt b/_sources/learn/quickstart/variables.md.txt
new file mode 100644
index 000000000000..8197915d8dba
--- /dev/null
+++ b/_sources/learn/quickstart/variables.md.txt
@@ -0,0 +1,196 @@
+# Variables
+
+Variables store information that can be manipulated by the program.
+Fortran is a _strongly typed_ language, which means that each variable
+must have a type.
+
+There are 5 built-in data types in Fortran:
+
+- `integer` -- for data that represent whole numbers, positive or negative
+- `real` -- for floating-point data (not a whole number)
+- `complex` -- pair consisting of a real part and an imaginary part
+- `character` -- for text data
+- `logical` -- for data that represent boolean (true or false) values
+
+Before we can use a variable, we must _declare_ it; this tells the compiler
+the variable type and any other variable attributes.
+
+> Fortran is a _statically typed_ language, which means the type of each
+> variable is fixed when the program is compiled---variable types cannot change while the program is running.
+
+# Declaring variables
+
+The syntax for declaring variables is:
+
+```
+ ::
+```
+
+where `` is one of the built-in variable types listed above and
+`` is the name that you would like to call your variable.
+
+Variable names must start with a letter and can consist of letters, numbers and underscores.
+In the following example we declare a variable for each of the built-in types.
+
+**Example:** variable declaration
+
+```fortran
+program variables
+ implicit none
+
+ integer :: amount
+ real :: pi
+ complex :: frequency
+ character :: initial
+ logical :: isOkay
+
+end program variables
+```
+
+> Fortran code is **case-insensitive**; you don't have to worry about the
+> capitalisation of your variable names, but it's good practice to keep it consistent.
+
+Note the additional statement at the beginning of the program: `implicit none`.
+This statement tells the compiler that all variables will be explicitly declared; without
+this statement variables will be implicitly typed according to the letter they begin with.
+
+> Always use the `implicit none` statement at
+> the beginning of each program and procedure. Implicit typing is considered bad practice in
+> modern programming since it hides information leading to more program errors.
+
+Once we have declared a variable, we can assign and reassign values to it using the assignment operator `=`.
+
+**Example:** variable assignment
+
+```fortran
+amount = 10
+pi = 3.1415927
+frequency = (1.0, -0.5)
+initial = 'A'
+isOkay = .false.
+```
+
+Characters are surrounded by either single (`'`) or double quotes (`"`).
+
+Logical or boolean values can be either `.true.` or `.false.`.
+
+> Watch out" content="for assignment at declaration: `integer :: amount = 1`.
+> **This is NOT a normal initialisation;** it implies the `save` attribute which means that the variable retains
+> its value between procedure calls. Good practice is to initialise your variables separately to their declaration.
+
+## Standard input / output
+
+In our _Hello World_ example, we printed text to the command window.
+This is commonly referred to as writing to `standard output` or `stdout`.
+
+We can use the `print` statement introduced earlier to print variable values to `stdout`:
+
+```fortran
+print *, 'The value of amount (integer) is: ', amount
+print *, 'The value of pi (real) is: ', pi
+print *, 'The value of frequency (complex) is: ', frequency
+print *, 'The value of initial (character) is: ', initial
+print *, 'The value of isOkay (logical) is: ', isOkay
+```
+
+In a similar way, we can read values from the command window
+using the `read` statement:
+
+```fortran
+program read_value
+ implicit none
+ integer :: age
+
+ print *, 'Please enter your age: '
+ read(*,*) age
+
+ print *, 'Your age is: ', age
+
+end program read_value
+```
+
+This input source is commonly referred to as `standard input` or `stdin`.
+
+## Expressions
+
+The usual set of arithmetic operators are available, listed in order of precedence:
+
+| Operator | Description |
+| :-------------: | -------------- |
+| `**` | Exponent |
+| `*` | Multiplication |
+| `/ ` | Division |
+| `+` | Addition |
+| `-` | Subtraction |
+
+
+
+**Example:**
+
+```fortran
+program arithmetic
+ implicit none
+
+ real :: pi
+ real :: radius
+ real :: height
+ real :: area
+ real :: volume
+
+ pi = 3.1415927
+
+ print *, 'Enter cylinder base radius:'
+ read(*,*) radius
+
+ print *, 'Enter cylinder height:'
+ read(*,*) height
+
+ area = pi * radius**2
+ volume = area * height
+
+ print *, 'Cylinder radius is: ', radius
+ print *, 'Cylinder height is: ', height
+ print *, 'Cylinder base area is: ', area
+ print *, 'Cylinder volume is: ', volume
+
+end program arithmetic
+```
+
+## Floating-point precision
+
+The desired floating-point precision can be explicitly declared using a `kind` parameter.
+The `iso_fortran_env` intrinsic module provides `kind` parameters for the common 32-bit and 64-bit floating-point types.
+
+**Example:** explicit real `kind`
+
+```fortran
+program float
+ use, intrinsic :: iso_fortran_env, only: sp=>real32, dp=>real64
+ implicit none
+
+ real(sp) :: float32
+ real(dp) :: float64
+
+ float32 = 1.0_sp ! Explicit suffix for literal constants
+ float64 = 1.0_dp
+
+end program float
+```
+
+> Always use a `kind` suffix for floating-point literal constants.
+
+**Example:** C-interoperable `kind`
+
+```fortran
+program float
+ use, intrinsic :: iso_c_binding, only: sp=>c_float, dp=>c_double
+ implicit none
+
+ real(sp) :: float32
+ real(dp) :: float64
+
+end program float
+```
+
+In the next part we will learn how to use arrays for storing more than one
+value in a variable.
diff --git a/_sources/news.md.txt b/_sources/news.md.txt
new file mode 100644
index 000000000000..85c63e760252
--- /dev/null
+++ b/_sources/news.md.txt
@@ -0,0 +1 @@
+## News
diff --git a/_sources/news/2020/02-28-J3-february-meeting.md.txt b/_sources/news/2020/02-28-J3-february-meeting.md.txt
new file mode 100644
index 000000000000..5b30bb22768c
--- /dev/null
+++ b/_sources/news/2020/02-28-J3-february-meeting.md.txt
@@ -0,0 +1,93 @@
+---
+date: 2020-02-28
+category: newsletter
+author: Ondřej Čertík and Zach Jibben
+...
+
+# J3 February 2020 Meeting
+
+The J3 Fortran Committee meeting took place in Las Vegas, NV, on February 24-28, 2020.
+
+## Attendance
+
+The following people / companies attended:
+
+Voting members:
+
+1. Intel: Jon Steidel
+2. HPE/Cray: Bill Long
+3. NVIDIA: Peter Klausler, Gary Klimowicz
+4. IBM: Daniel Chen
+5. ARM: Srinath Vadlamani
+6. NCAR: Dan Nagle, Magne Haveraaen
+7. NASA: Tom Clune
+8. JPL: Van Sneider
+9. LANL: Zach Jibben, Ondřej Čertík
+10. ORNL: Reuben Budiardja
+11. LBNL: Brian Friesen
+12. Sandia: Damian Rouson
+13. Lionel: Steven Lionel, Malcolm Cohen, Vipul Parekh
+14. Corbett: Bob Corbett
+
+Others:
+
+15. AMD: Richard Bleikamp
+16. WG23: Stephen Michell (convenor), Erhard Ploedereder (member)
+17. Structural Integrity: Brad Richardson
+
+## Proposals Discussed at Plenary
+
+### Monday 2/24
+
+### Tuesday 2/25
+
+- [#22] : Default values of optional arguments ()
+
+### Wednesday 2/26
+
+- [#157] : Rank-agnostic array element and section denotation (, )
+- [#158] : TYPEOF and CLASSOF ()
+- [#1] : Namespace for modules ()
+- Interpretation: FORM TEAM and failed images ()
+- Interpretation: Collective subroutines and STAT= ()
+
+### Thursday 2/27
+
+- Interpretation: events that cause variables to become undefined ()
+- Edits for SIMPLE procedures ()
+- BFLOAT16 ()
+- [#146] : Interpretation: allocatable component finalization ()
+
+### Friday 2/28
+
+- [#157] : Rank-agnostic syntax (). Passed unanimously with minor changes.
+- [#156] : Protected components (). Withdrawn to address conflicting interests.
+- [#160] : Edits for auto-allocate characters (). Passed unanimously with minor changes.
+- Edits for procedure pointer association (). Passed unanimously.
+- [#157] : Edits for rank-agnostic bounds (). Withdrawn because some edits were missing and need to be added. There were concerns about fitting into the framework of generics later on.
+- [#157] : Edits for rank-agnostic array element and section denotation (). Failed (5 v 7). Missing edits, and disagreement on types vs rank-1 integers, the options need to be explored more.
+- [#157] : Edits for rank-agnostic allocation and pointer assignment (). Passed unanimously with minor changes.
+- Interpretation: Public namelist and private variable (). Straw vote (0 yes, 8 no, 9 undecided). Passed unanimously with "no" alternative.
+- Interpretation F18/015 (). Passed unanimously.
+
+## Skipped
+
+This was on the plan but we did not get to it:
+
+- [#5] : US 27 POINTER dummy arguments, INTENT, and target modification ()
+- [#19] : Short-circuiting proposal
+
+## More Details
+
+More details available at
+[j3-fortran/fortran_proposals #155](https://github.com/j3-fortran/fortran_proposals/issues/155) and at the official [minutes](https://j3-fortran.org/doc/year/20/minutes221.txt) from the meeting.
+
+[#1]: https://github.com/j3-fortran/fortran_proposals/issues/1
+[#5]: https://github.com/j3-fortran/fortran_proposals/issues/5
+[#19]: https://github.com/j3-fortran/fortran_proposals/issues/19
+[#22]: https://github.com/j3-fortran/fortran_proposals/issues/22
+[#146]: https://github.com/j3-fortran/fortran_proposals/issues/146
+[#156]: https://github.com/j3-fortran/fortran_proposals/issues/156
+[#157]: https://github.com/j3-fortran/fortran_proposals/issues/157
+[#158]: https://github.com/j3-fortran/fortran_proposals/issues/158
+[#160]: https://github.com/j3-fortran/fortran_proposals/issues/160
diff --git a/_sources/news/2020/04-06-Announcing-FortranCon-2020.md.txt b/_sources/news/2020/04-06-Announcing-FortranCon-2020.md.txt
new file mode 100644
index 000000000000..f737cc8fd402
--- /dev/null
+++ b/_sources/news/2020/04-06-Announcing-FortranCon-2020.md.txt
@@ -0,0 +1,31 @@
+---
+layout: post
+date: 2020-04-06
+category: newsletter
+...
+
+# FortranCon 2020
+
+FortranCon 2020, the first international conference targeting the Fortran
+programming language, will take place on July 2-4, 2020, in Zürich, Switzerland.
+
+
+
+FortranCon aims to bring together developers of Fortran libraries,
+applications, and language itself to share their experience and ideas.
+The conference is organized in two full days of speaker presentations
+on July 2 and 3, and a half-day workshop with lectures and hands-on sessions
+on July 4.
+Click [here](https://tcevents.chem.uzh.ch/event/12/abstracts/) to submit
+an abstract.
+
+The keynote presentation will be delivered by Steve Lionel
+([@doctorfortran](https://twitter.com/doctorfortran)), convener of the
+US Fortran Standards Committee.
+
+The [registration](https://tcevents.chem.uzh.ch/event/12/registrations/)
+is **free of charge**, with June 1, 2020 as the deadline.
+Virtual participation will be enabled for speakers and attendees unable to
+travel.
+
+Read more about FortranCon 2020 [here](https://tcevents.chem.uzh.ch/event/12/).
diff --git a/_sources/news/2020/04-18-Fortran-Webinar.md.txt b/_sources/news/2020/04-18-Fortran-Webinar.md.txt
new file mode 100644
index 000000000000..ec9882d22347
--- /dev/null
+++ b/_sources/news/2020/04-18-Fortran-Webinar.md.txt
@@ -0,0 +1,28 @@
+---
+date: 2020-04-18
+title: Open Source Directions Fortran webinar
+category: newsletter
+...
+
+# Open Source Directions Fortran webinar
+
+Ondřej Čertík ([@ondrejcertik](https://twitter.com/ondrejcertik)) and
+Milan Curcic ([@realmilancurcic](https://twitter.com/realmilancurcic)) spoke
+yesterday about the future of Fortran in Episode 40 of the Open Source
+Directions Webinar.
+We discussed the current state of the language, how it's currently developed,
+and what we can do today to build the Fortran community, ecosystem of packages,
+and developer tools.
+
+Watch the episode now:
+
+
+
+Special thanks to our hosts Melissa Mendonça
+([@melissawm](https://twitter.com/melissawm)) and Madicken Munk
+([@munkium](https://twitter.com/munkium)), as well as
+[OpenTeams](https://openteams.com) and [QuanSight](https://www.quansight.com/)
+for having us.
+
+You can find all previous episodes of the Open Source Directions webinar
+[here](https://www.quansight.com/open-source-directions).
diff --git a/_sources/news/2020/05-01-Fortran-Newsletter-May-2020.md.txt b/_sources/news/2020/05-01-Fortran-Newsletter-May-2020.md.txt
new file mode 100644
index 000000000000..6aeafc7b88be
--- /dev/null
+++ b/_sources/news/2020/05-01-Fortran-Newsletter-May-2020.md.txt
@@ -0,0 +1,112 @@
+---
+category: newsletter
+date: 2020-05-01
+author: Milan Curcic
+...
+
+# Fortran newsletter: May 2020
+
+```fortran
+print *, 'Hello, World!'
+```
+
+Welcome to the first monthly Fortran newsletter.
+It will come out on the first calendar day of every month,
+detailing Fortran news from the previous month.
+
+## This website
+
+If you came to this newsletter from elsewhere, welcome to the new Fortran website.
+We built this site mid-April and hope for it to be _the_ home of Fortran on the internet,
+which traditionally there hasn't been any to date.
+Look around and [let us know](https://github.com/fortran-lang/fortran-lang.github.io/issues)
+if you have any suggestions for improvement.
+Specifically, [Learn](/learn) and [Packages](/packages) are the pages that
+we'll be focusing on in the coming months.
+Please help us make them better!
+
+## Standard Library
+
+Here's what's new in Fortran Standard Library:
+
+- [#172](https://github.com/fortran-lang/stdlib/pull/172)
+ New function `cov` in the `stdlib_experimental_stats` module to compute covariance of array elements.
+ Read the full specification [here](https://github.com/fortran-lang/stdlib/blob/HEAD/src/stdlib_experimental_stats.md#cov---covariance-of-array-elements).
+
+- [#168](https://github.com/fortran-lang/stdlib/pull/168)
+ Specify recommended order of attributes for dummy arguments in the
+ [Stdlib style guide](https://github.com/fortran-lang/stdlib/blob/HEAD/STYLE_GUIDE.md).
+
+- [#173](https://github.com/fortran-lang/stdlib/pull/173)
+ Minor bug fix.
+
+- [#170](https://github.com/fortran-lang/stdlib/pull/170)
+ WIP: Addition of `diag`, `eye`, and `trace` functions to make working with
+ matrices easier.
+
+## Package Manager
+
+In the past month we've seen the first working implementation of the [Fortran Package Manager (FPM)](https://github.com/fortran-lang/fpm).
+Specifically:
+
+- FPM supports three commands:
+ - `fpm build`--compiles and links your application and/or library.
+ - `fpm test`--runs tests if your package has any test programs.
+ - `fpm run`--runs the application if your package has an executable program.
+- FPM can build an executable program, a library, or a combination of both.
+- Currently only gfortran is supported as the compiler backend. FPM will suport other compilers soon.
+
+Read the [FPM packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md)
+to learn how to build your package with FPM.
+
+FPM is still in very early development, and we need as much help as we can get.
+Here's how you can help today:
+
+- Try to use it. Does it work? No? Let us know!
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for FPM.
+- Improve the documentation.
+
+The short term goal of FPM is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## WG5 Convenor candidates
+
+Last month was also the deadline for the [WG5](https://wg5-fortran.org/)
+convenor candidates to apply for the next 3-year term (2021-2024).
+There are two candidates:
+
+- [Steve Lionel](https://stevelionel.com), who is also the current WG5 convenor,
+ announced running for another term.
+ Read Steve's [post](https://stevelionel.com/drfortran/2020/04/25/doctor-fortran-in-forward)
+ about how he has guided the standardization process over the past three years and his direction for the future.
+
+- [Ondřej Čertík](https://ondrejcertik.com) has also announced announced to run
+ for the WG5 convenor.
+ Read Ondřej's [announcement](https://ondrejcertik.com/blog/2020/04/running-for-wg5-convenor-announcement/)
+ and [platform](https://github.com/certik/wg5_platform_2020)
+ that detail current issues with Fortran language development and how to
+ overcome them going forward.
+
+## Events
+
+- [OpenTeams](https://openteams.com) and [QuanSight](https://quansight.com) hosted Ondřej Čertík and Milan Curcic
+ in the Episode 40 of the Open Source Directions Webinar.
+ They talked about the current state and future of Fortran, as well as about building the Fortran community and developer tools.
+ Read more about it and watch the video [here](/newsletter/2020/04/18/Fortran-Webinar/).
+- [FortranCon 2020](https://tcevents.chem.uzh.ch/event/12) will take place on July 2-4 in Zurich, Switzerland.
+ Virtual participation is enabled for both attendees and speakers.
+ Registration is free and due by June 1, 2020.
+- J3/WG5 joint meeting will take place on October 12-16 in Las Vegas, Nevada.
+ You can submit a proposal for the Standards committee [here](https://github.com/j3-fortran/fortran_proposals).
+ For reference, you can read the [notes from the February meeting](/newsletter/2020/02/28/J3-february-meeting).
+
+## Who's hiring?
+
+- [Intel Corporation (Santa Clara, CA): Software Engineer, Fortran](https://g.co/kgs/aogdeh)
+- [Intel Corporation (Hillsboro, OR): Software Engineer, Fortran](https://g.co/kgs/5X3d2Y)
+- [Pozent (York, PA): Fortran Technical Lead](https://g.co/kgs/yuaohU)
+- [American Cybersystems, Inc. (Binghamton, NY): Software Engineer (Fortran, C/C++, Ada, C#, Java, Radar)](https://g.co/kgs/VAWjWk)
+- [BravoTech (Dallas, TX): C++ / Fortran Developer](https://g.co/kgs/eLsn63)
+- [Siemens (Milford, OH): CAE Software Engineer (Fortran or C++) Design and Topology Optimization](https://g.co/kgs/eYftiA)
diff --git a/_sources/news/2020/06-01-Fortran-Newsletter-June-2020.md.txt b/_sources/news/2020/06-01-Fortran-Newsletter-June-2020.md.txt
new file mode 100644
index 000000000000..b836c6f70ff3
--- /dev/null
+++ b/_sources/news/2020/06-01-Fortran-Newsletter-June-2020.md.txt
@@ -0,0 +1,129 @@
+---
+category: newsletter
+date: 2020-06-01
+author: Jeremie Vandenplas, Brad Richardson, Milan Curcic and Ondřej Čertík
+...
+
+# Fortran newsletter: June 2020
+
+Welcome to the June 2020 edition of the monthly Fortran newsletter.
+The newsletter comes out on the first calendar day of every month
+and details Fortran news from the previous month.
+
+## fortran-lang.org
+
+The Fortran website has been up since mid-April, and we've already got great
+feedback from the community.
+In the past month we've updated the [Compilers](/compilers) page which is now
+comprehensive and includes all major open source and commercial compilers.
+The [Learn](/learn) page has also seen significant updates—it's been
+reorganized for easier navigation and currently features a quickstart tutorial,
+Fortran books, and other online resources.
+
+If you haven't yet, please explore the website and [let us know](https://github.com/fortran-lang/fortran-lang.org/issues)
+if you have any suggestions for improvement.
+Specifically, we'll be focusing on the [Learn](/learn) page and its mini-books
+in the coming months.
+Please help us make them better!
+
+Here are some specific items that we worked on:
+
+- [#90](https://github.com/fortran-lang/fortran-lang.org/pull/90)
+ WIP: Mini-book on building programs
+- [#83](https://github.com/fortran-lang/fortran-lang.org/pull/83)
+ Improving the structure and navigation of the [Learn](/learn) pages
+- [#46](https://github.com/fortran-lang/fortran-lang.org/pull/46)
+ Build website previews from pull requests
+
+## Fortran Discourse
+
+On May 4 we launched the [Fortran Discourse](https://fortran-lang.discourse.group), an online discussion board
+for anything and everything Fortran related.
+You can use it discuss the Fortran language, ask for help, announce events and/or personal projects, or just lurk
+around.
+There are already quite a few interesting discussions going on.
+Join us!
+
+## Fortran Standard Library
+
+Recently we launched a [website](https://stdlib.fortran-lang.org) for the API documentation of the Fortran Standard Library.
+The [website](https://stdlib.fortran-lang.org) is automaticaly generated by [FORD](https://github.com/Fortran-FOSS-Programmers/ford#readme).
+[Code of Conduct](https://stdlib.fortran-lang.org/page/contributing/CodeOfConduct.html), [licence](https://stdlib.fortran-lang.org/page/License.html), and [workflow](https://stdlib.fortran-lang.org/page/contributing/Workflow.html) for contributing to the Fortran Standard Library can also be found on the [website](https://stdlib.fortran-lang.org/).
+
+Here's what's new in the Fortran Standard Library:
+
+- [#191](https://github.com/fortran-lang/stdlib/pull/191)
+ WIP: Function for computing Pearson correlations among elements of
+ an array in the `stdlib_experimental_stats` module
+- [#189](https://github.com/fortran-lang/stdlib/pull/189)
+ WIP: Procedures for sparse matrices operations. Ongoing discussion on the API can be found
+ [here](https://github.com/fortran-lang/stdlib/wiki/Stdlib-Sparse-matrix-API).
+- [#183](https://github.com/fortran-lang/stdlib/pull/183)
+ Automatic API-doc generation and deployment of this [stdlib website](https://stdlib.fortran-lang.org)
+- [#170](https://github.com/fortran-lang/stdlib/pull/170)
+ Addition of the new functions `diag`, `eye`, and `trace` functions to make working with
+ matrices easier.
+ Read the full specifications [here](https://stdlib.fortran-lang.org/page/specs/stdlib_experimental_linalg.html).
+
+## Package Manager
+
+In this past month support for dependencies between packages has been added
+to the [Fortran Package Manager (fpm)](https://github.com/fortran-lang/fpm).
+You can specify either a path to another folder on your machine with an fpm package,
+or a git repository (and optionally a specific branch, tag or commit) that
+contains the package. fpm will then take care of fetching the dependency for you
+(if necessary) and any packages it depends on, and compiling and linking it into
+your project. Check out an example [hello world package](https://gitlab.com/everythingfunctional/hello_fpm)
+that uses this functionality.
+
+fpm is still in very early development, and we need as much help as we can get.
+Here's how you can help today:
+
+- Try to use it. Does it work? No? Let us know! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm.
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm.
+- Improve the documentation.
+
+The short term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+Specific items that are new this month:
+
+- [#82](https://github.com/fortran-lang/fpm/pull/82)
+ You can now add remote git repositories as Fortran dependencies to your project.
+- [#73](https://github.com/fortran-lang/fpm/pull/73)
+ Improved output messages for the user
+
+## Events
+
+- We hosted the very first Fortran Monthly call on May 14.
+ The turnout was astonishing--over 23 people joined.
+ You can read the notes from the call [here](https://fortran-lang.discourse.group/t/fortran-monthly-call-may-2020).
+ We'll have another one this month.
+ Subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+ join the [Discourse](https://fortran-lang.discourse.group) to stay tuned.
+- [FortranCon 2020](https://tcevents.chem.uzh.ch/event/12) will take place on July 2-4 in Zurich, Switzerland.
+ Virtual participation is enabled for both attendees and speakers.
+ Registration is free and due by June 1, 2020.
+ There are quite a few submissions from the fortran-lang community:
+ A talk on [stdlib](https://github.com/fortran-lang/talks/tree/HEAD/FortranCon2020-stdlib) by Jeremie Vandenplas,
+ one about the [Fortran Package Manager (fpm)](https://github.com/fortran-lang/talks/tree/HEAD/FortranCon2020-fpm) by Brad Richardson,
+ a talk on [LFortran compiler](https://gitlab.com/lfortran/talks/fortrancon-2020-talk) by Ondřej Čertík,
+ as well as one about [building the Fortran community](https://github.com/fortran-lang/talks/tree/HEAD/FortranCon2020-community)
+ by Milan Curcic.
+- J3/WG5 joint meeting, originally slated for October 12-16 in Las Vegas, Nevada, has been [cancelled](https://mailman.j3-fortran.org/pipermail/j3/2020-May/012034.html).
+ However, the work on proposals for the Fortran Standard doesn't stop.
+ You can submit a proposal for the Standards committee [here](https://github.com/j3-fortran/fortran_proposals).
+ For reference, you can read the [notes from the February meeting](/newsletter/2020/02/28/J3-february-meeting).
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of the four repositories
+[fortran-lang/stdlib](https://github.com/fortran-lang/stdlib),
+[fortran-lang/fpm](https://github.com/fortran-lang/fpm),
+[fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org),
+[j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals):
+
+Ondřej Čertík ([@certik](https://github.com/certik)), Milan Curcic ([@milancurcic](https://github.com/milancurcic)), Laurence Kedward ([@LKedward](https://github.com/LKedward)), Jeremie Vandenplas ([@jvdp1](https://github.com/jvdp1)), Brad Richardson ([@everythingfunctional](https://github.com/everythingfunctional)), Izaak "Zaak" Beekman ([@zbeekman](https://github.com/zbeekman)), Martin Diehl ([@MarDiehl](https://github.com/MarDiehl)), [@arjenmarkus](https://github.com/arjenmarkus), Van Snyder ([@vansnyder](https://github.com/vansnyder)), [@FortranFan](https://github.com/FortranFan), [@epagone](https://github.com/epagone), Ivan ([@ivan-pi](https://github.com/ivan-pi)), Neil Carlson ([@nncarlson](https://github.com/nncarlson)), Ashwin Vishnu ([@ashwinvis](https://github.com/ashwinvis)), Williams A. Lima ([@ghwilliams](https://github.com/ghwilliams)), Peter Klausler ([@klausler](https://github.com/klausler)), Chris MacMackin ([@cmacmackin](https://github.com/cmacmackin)), Pedro Costa ([@p-costa](https://github.com/p-costa)), [@mobius-eng](https://github.com/mobius-eng), Salvatore Filippone ([@sfilippone](https://github.com/sfilippone)), [@ShamanTcler](https://github.com/ShamanTcler), Amit Kumar ([@aktech](https://github.com/aktech)), Bálint Aradi ([@aradi](https://github.com/aradi)), Melissa Weber Mendonça ([@melissawm](https://github.com/melissawm)), Jacob Williams ([@jacobwilliams](https://github.com/jacobwilliams)), Rohit Goswami ([@HaoZeke](https://github.com/HaoZeke)), Amir Shahmoradi ([@shahmoradi](https://github.com/shahmoradi)), Bill Long ([@longb](https://github.com/longb)).
diff --git a/_sources/news/2020/07-01-Fortran-Newsletter-July-2020.md.txt b/_sources/news/2020/07-01-Fortran-Newsletter-July-2020.md.txt
new file mode 100644
index 000000000000..3b1ca39c657e
--- /dev/null
+++ b/_sources/news/2020/07-01-Fortran-Newsletter-July-2020.md.txt
@@ -0,0 +1,111 @@
+---
+category: newsletter
+date: 2020-07-01
+author: Milan Curcic, Laurence Kedward, and Jérémie Vandenplas
+...
+
+# Fortran newsletter: July 2020
+
+Welcome to the July 2020 edition of the monthly Fortran newsletter.
+The newsletter comes out on the first calendar day of every month
+and details Fortran news from the previous month.
+
+## fortran-lang.org
+
+Work has continued on the Fortran-lang website, including a new community page and additional tutorial content:
+
+- [#98](https://github.com/fortran-lang/fortran-lang.org/pull/98): updated the [Quickstart mini-book](https://fortran-lang.org/learn/quickstart/derived_types) tutorial with a comprehensive overview of derived types;
+
+- [#99](https://github.com/fortran-lang/fortran-lang.org/pull/99): added a second mini-book tutorial to the [Learn](https://fortran-lang.org/learn) page on building compiled programs and libraries;
+
+- [#100](https://github.com/fortran-lang/fortran-lang.org/pull/100): added a new top-level web-page for Fortran-lang community projects.
+ The page gives useful information and links for new contributors, as well as acknowledging each of our many existing contributors.
+ Check it out at .
+
+Ongoing work:
+
+- [#101](https://github.com/fortran-lang/fortran-lang.org/issues/101): Code style for Fortran examples in the tutorials.
+ See the corresponding community poll and discussion on [Discourse](https://fortran-lang.discourse.group/t/should-tutorials-on-fortran-lang-org-follow-a-consistent-style-for-code-listings/134);
+
+- [#112](https://github.com/fortran-lang/fortran-lang.org/issues/112): Plan for core language tutorials.
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+**Did you know** you don't need to know HTML or any fancy languages to contribute to the website;
+all of the online tutorials and most of the website content are written in [markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet), a simple markup language for formatting text - don't worry if you haven't used it before, it's very easy to pick up!
+
+## Fortran Standard Library
+
+What's new in the Fortran Standard Library:
+
+- [#209](https://github.com/fortran-lang/stdlib/pull/209)
+ Implements Simpson's rule for 1-d arrays (`simps` and `simps_weights`) in the
+ quadrature module (`stdlib_experimental_quadrature`).
+- [#205](https://github.com/fortran-lang/stdlib/pull/205)
+ Tests for and improved standard conformance.
+
+Some miscellaneous fixes and improvements:
+
+- [#208](https://github.com/fortran-lang/stdlib/pull/208)
+ Fixes to support Intel Fortran compilers
+- [#210](https://github.com/fortran-lang/stdlib/pull/210)
+ Fixes to support NAG compiler
+- [#207](https://github.com/fortran-lang/stdlib/pull/207)
+ [#211](https://github.com/fortran-lang/stdlib/pull/211)
+ Other minor fixes and improvements
+
+## Fortran Package Manager
+
+What's new in fpm:
+
+- [#99](https://github.com/fortran-lang/fpm/pull/99)
+ fpm now lets you specify a custom build script or a Makefile to use.
+ This will help building packages that use a custom structure and/or external
+ dependencies in other languages.
+- [#89](https://github.com/fortran-lang/fpm/pull/89)
+ Allow specifying specific tests or executables to run via command-line arguments.
+- [#85](https://github.com/fortran-lang/fpm/pull/85)
+ Enables having specific dependencies for tests and executables.
+- [#97](https://github.com/fortran-lang/fpm/pull/97)
+ [#100](https://github.com/fortran-lang/fpm/pull/100)
+ [#101](https://github.com/fortran-lang/fpm/pull/101)
+ Minor improvements to the README.
+
+fpm is still in very early development, and we need as much help as we can get.
+Here's how you can help today:
+
+- Try to use it. Does it work? No? Let us know! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm.
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm.
+- Improve the documentation.
+
+The short term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Events
+
+- We had our second Fortran Monthly call on June 19.
+ You can read watch the recording below:
+
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+- [FortranCon 2020](https://tcevents.chem.uzh.ch/event/12) began today (July 2),
+ with many interesting talks.
+ See the talk schedule [here](https://tcevents.chem.uzh.ch/event/12/timetable/#20200702.detailed).
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of the four repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib),
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm),
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org),
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals):
+
+
diff --git a/_sources/news/2020/08-01-Fortran-Newsletter-August-2020.md.txt b/_sources/news/2020/08-01-Fortran-Newsletter-August-2020.md.txt
new file mode 100644
index 000000000000..ee5e32db9618
--- /dev/null
+++ b/_sources/news/2020/08-01-Fortran-Newsletter-August-2020.md.txt
@@ -0,0 +1,163 @@
+---
+category: newsletter
+date: 2020-08-01
+author: Ondřej Čertík, Milan Curcic, Laurence Kedward, Jérémie Vandenplas, Arjen Markus and Gary Klimowicz
+...
+
+# Fortran newsletter: August 2020
+
+Welcome to the August 2020 edition of the monthly Fortran newsletter.
+The newsletter comes out on the first calendar day of every month
+and details Fortran news from the previous month.
+
+## fortran-lang.org
+
+We continued the work on the Fortran-lang website, including:
+
+- [#116](https://github.com/fortran-lang/fortran-lang.org/pull/116): updates to the Quickstart tutorial on loop control and syntax
+
+- [#120](https://github.com/fortran-lang/fortran-lang.org/pull/120): updated the
+ [Book section](https://fortran-lang.org/learn/) with a comprehensive list of
+ books about Fortran
+
+- [#121](https://github.com/fortran-lang/fortran-lang.org/pull/121), [#122](https://github.com/fortran-lang/fortran-lang.org/pull/122), [#127](https://github.com/fortran-lang/fortran-lang.org/pull/127), [#128](https://github.com/fortran-lang/fortran-lang.org/pull/128): additional packages added to the Fortran-lang.org [packages](https://fortran-lang.org/packages) page
+
+Ongoing work:
+
+- [#117](https://github.com/fortran-lang/fortran-lang.org/issues/117): Adding a
+ Benchmarks section, a new dedicated repository was created at
+ https://github.com/fortran-lang/benchmarks and many details have been
+ discussed in [issues](https://github.com/fortran-lang/benchmarks/issues) there
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+What's new in the Fortran Standard Library:
+
+- [#223](https://github.com/fortran-lang/stdlib/pull/223): the structure of the Fortran Standard Library has been modified for clarity and ease of use. With these changes, both experimental and stable procedures will reside together in the same modules. The status of the procedures (experimental vs stable) are documented in the code, in the specs, and in the [API docs](https://stdlib.fortran-lang.org/)
+
+Main ongoing discussions:
+
+- [#225](https://github.com/fortran-lang/stdlib/issues/225): Name convention for derived types in `stdlib`
+- [#224](https://github.com/fortran-lang/stdlib/issues/224): Handling and propagating errors inside `stdlib`
+- [#221](https://github.com/fortran-lang/stdlib/issues/221): API for a bitset data type
+- [#201](https://github.com/fortran-lang/stdlib/issues/201): API for file system operations
+
+## Fortran Package Manager
+
+What's new in fpm:
+
+- We created the [fpm-registry](https://github.com/fortran-lang/fpm-registry) repository,
+ which serves as a registry of fpm-enabled Fortran packages.
+ Please see the README there to learn how to contribute a package.
+ For now, the registry is simply a list of fpm-enabled Fortran packages that you can use as a dependency in your `fpm.toml` file.
+ Soon, this registry will be used to generate detailed metadata that will be used by fpm to allow you to search for packages from the command-line, e.g. `fpm search ` or similar.
+- [#146](https://github.com/fortran-lang/fpm/issues/146): We discussed the design of the new Fortran implementation of fpm in a video call. We agreed on the need for an intermediate package model which will allow for clean separation of fpm frontends (user interface, parsing, and semantics) and fpm backends (fpm itself, CMake, Make, etc.).
+- [#131](https://github.com/fortran-lang/fpm/pull/131),
+ [#132](https://github.com/fortran-lang/fpm/pull/132),
+ [#139](https://github.com/fortran-lang/fpm/pull/139),
+ [#140](https://github.com/fortran-lang/fpm/pull/140),
+ [#142](https://github.com/fortran-lang/fpm/pull/142),
+ [#145](https://github.com/fortran-lang/fpm/pull/145),
+ [#147](https://github.com/fortran-lang/fpm/pull/147),
+ [#148](https://github.com/fortran-lang/fpm/pull/148),
+ [#151](https://github.com/fortran-lang/fpm/pull/151):
+ We merged several pull requests toward the Fortran fpm implementation. The Haskell implementation has moved to the `fpm/bootstrap` directory, and the Fortran implementation is developed in `fpm/fpm`. The Fortran fpm is, of course, an fpm package itself so it can be built by the Haskell fpm. Soon, it will be able to be build by itself.
+
+fpm is still in very early development, and we need as much help as we can get.
+Here's how you can help today:
+
+- Try to use it. Does it work? No? Let us know! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm.
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm.
+- Improve the documentation.
+
+The short term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Fortran benchmarks
+
+We created the [benchmarks repository](https://github.com/fortran-lang/benchmarks) with the goal to design and implement a comprehensive set of benchmarks.
+The benchmarks will aim to compare the performance of various Fortran compilers, as well as the performance of canonical algorithms implemented in Fortran and different languages.
+If you'd like to contribute in any way, be it the design, implementation, or testing of benchmarks, please join the ongoing discussion [here](https://github.com/fortran-lang/benchmarks/issues).
+
+## Classic Flang
+
+We've begun to evaluate pull requests and merge them into the original Flang
+compiler again. There is now a biweekly call to discuss issues and plans for
+Classic Flang. The next call will be Wednesday, August 12, 8:30 AM Pacific time.
+The notes from previous calls, upcoming agenda and a link to join the call can
+be found [here](https://docs.google.com/document/d/1-OuiKx4d7O6eLEJDBDKSRnSiUO2rgRR-c2Ga4AkrzOI).
+
+In the last call, AMD reviewed their outstanding pull requests for Fortran debug
+metadata enhancements.
+
+## LLVM Flang
+
+Work continues on LLVM Flang, concentrating on semantics, lowering and runtime
+sufficient to compile and run Fortran 77 programs. We are fixing bugs we find in
+running FCVS and other test suites that use F77.
+
+We cominue upstreaming the lowering code from the fir-dev fork (MLIR-based
+Fortran IR) into the llvm-project repository. Arm is working on changes to
+support a driver program to replace the throwaway driver we currently have.
+
+AMD has been contributing parser and semantic processing for OpenMP constructs
+like task wait, barrier and parallel constructs.
+
+Changes have been made to default parse/unparse/compile processing to default to
+gfortran (not NVIDIA Fortran).
+
+Valentin Clement has been committing initial changes for OpenACC support.
+
+## LFortran
+
+What's new in LFortran:
+
+- The initial prototype C++ backend can translate Fortran's `do concurrent` to C++'s `Kokkos::parallel_for`: [https://twitter.com/lfortranorg/status/1280764915242811393](https://twitter.com/lfortranorg/status/1280764915242811393)
+- LFortran has a Twitter account for latest updates: [@lfortranorg](https://twitter.com/lfortranorg)
+- Work is progressing on the production version of LFortran that is written in C++
+- 22 Merge Requests were merged and 4 issues fixed in July 2020. Some notable ones:
+ - [#163](https://gitlab.com/lfortran/lfortran/-/issues/163): Implement basic Fortran to C++ translation backend
+ - [!410](https://gitlab.com/lfortran/lfortran/-/merge_requests/410): Make simple calculations work via LLVM in interactive mode
+ - [!402](https://gitlab.com/lfortran/lfortran/-/merge_requests/402): Build ASR (Abstract Semantic Representation) properly for subroutines and functions
+
+The short term goal is to get the C++ based production version of LFortran
+matching most of the features from the Python prototype version and make a
+public release. The long term goal is to build a modern Fortran compiler that
+works with any production code and allows it to run efficiently on modern
+hardware (CPUs and GPUs), both interactively and compiling to binaries, and
+provide the basis for other tools such as the Fortran to C++ translation, editor
+support, automatic documentation generation (and doctesting like in Python),
+automatic formatting and others.
+
+## Events
+
+- [FortranCon 2020](https://tcevents.chem.uzh.ch/event/12) was held July 2 - 4.
+ with many interesting talks.
+ See the talk schedule
+ [here](https://tcevents.chem.uzh.ch/event/12/timetable/#20200702.detailed).
+ All presentations have been recorded and will be soon made available online by the FortranCon organizers.
+
+- We had our third Fortran Monthly call on July 16.
+ You can read watch the recording below:
+
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of the four repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib),
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm),
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org),
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals):
+
+
diff --git a/_sources/news/2020/09-01-Fortran-Newsletter-September-2020.md.txt b/_sources/news/2020/09-01-Fortran-Newsletter-September-2020.md.txt
new file mode 100644
index 000000000000..41b909e21b9a
--- /dev/null
+++ b/_sources/news/2020/09-01-Fortran-Newsletter-September-2020.md.txt
@@ -0,0 +1,161 @@
+---
+category: newsletter
+date: 2020-09-01
+author: Milan Curcic, Ondřej Čertík, Gary Klimowicz, Brad Richardson, Jérémie Vandenplas, Thomas König, and Laurence Kedward
+...
+
+# Fortran newsletter: September 2020
+
+Welcome to the September 2020 edition of the monthly Fortran newsletter.
+The newsletter comes out on the first calendar day of every month
+and details Fortran news from the previous month.
+
+## fortran-lang.org
+
+We continued the work on the Fortran-lang website, specifically:
+
+- [#133](https://github.com/fortran-lang/fortran-lang.org/pull/133):
+ Listing fpm packages on the Packages page of the website
+
+Ongoing work:
+
+- [#117](https://github.com/fortran-lang/fortran-lang.org/issues/117): Adding a
+ Benchmarks section, a new dedicated repository was created at
+ https://github.com/fortran-lang/benchmarks and many details have been
+ discussed in [issues](https://github.com/fortran-lang/benchmarks/issues) there
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+There hasn't been new stdlib development in August, however ongoing work and discussions continue:
+
+- [#227](https://github.com/fortran-lang/stdlib/issues/227): API proposal for logging facilities in stdlib
+- [#225](https://github.com/fortran-lang/stdlib/issues/225): Name convention for derived types in stdlib
+- [#224](https://github.com/fortran-lang/stdlib/issues/224): Handling and propagating errors inside stdlib
+- [#221](https://github.com/fortran-lang/stdlib/issues/221): API for a bitset data type
+- [#201](https://github.com/fortran-lang/stdlib/issues/201): API for file system operations
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Ongoing work in fpm:
+
+- [#146](https://github.com/fortran-lang/fpm/issues/146) (WIP):
+ Implementing internal dependencies and build backend in the Fortran fpm
+
+fpm is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Try to use it. Does it work? No? Let us know! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm.
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Fortran benchmarks
+
+We created the [benchmarks repository](https://github.com/fortran-lang/benchmarks) with the goal to design and implement a comprehensive set of benchmarks.
+The benchmarks will aim to compare the performance of various Fortran compilers, as well as the performance of canonical algorithms implemented in Fortran and different languages.
+If you'd like to contribute in any way, be it the design, implementation, or testing of benchmarks, please join the ongoing discussion [here](https://github.com/fortran-lang/benchmarks/issues).
+
+## Compilers
+
+### GFortran
+
+GFortran 10.2 has been released, a bugfix release for 10.1.
+Bugs fixed include PR94361, a memory leak with finalizers.
+
+The development version of `gfortran` now supports the
+full OpenMP 4.5 specification. This will be released
+with GCC 11, but of course people can already download
+and test it.
+
+### Classic Flang
+
+We're evaluating pull requests and merging them into the original Flang
+compiler again. We pulled in 4 changes in the past couple of weeks, and expect
+to merge in a few more each week. One upcoming change is the support for LLVM 10,
+which requires the use of a new fork, the _classic-flang-llvm-project_
+fork of the LLVM monorepo. See
+[PR#1](https://github.com/flang-compiler/classic-flang-llvm-project/pull/1)
+for details.
+
+The Classic Flang biweekly call has been set up to discuss issues and plans
+for the next pull requests to be validated and merged. Our next calls will be
+Wednesday, September 9 and 23, 8:30 AM Pacific time. The notes from previous
+calls, upcoming agenda and a link to join the call can be found
+[here](https://docs.google.com/document/d/1-OuiKx4d7O6eLEJDBDKSRnSiUO2rgRR-c2Ga4AkrzOI).
+
+### LLVM Flang
+
+Work continues on LLVM Flang, concentrating on semantics, lowering and runtime
+sufficient to compile and run Fortran 77 programs. We are fixing bugs we find
+in running FCVS and other F77 test suites (and the F77 parts of non-F77
+suites).
+
+In conjunction with the MLIR-based code from the _fir-dev_ fork (the Fortran
+IR used for lowering), Flang can compile and run most F77 programs. We
+continue to work on refactoring necessary to upstream this fork into LLVM
+flang proper.
+
+Arm is working on changes to support a driver program to replace the temporary
+driver we currently use.
+
+Valentin Clement continues to contribute parsing and semantics changes for
+OpenACC support.
+
+### LFortran
+
+What's new in LFortran:
+
+- 143 Merge Requests were merged and 22 issues fixed in August 2020
+- The C++ backend can now translate to C++ and compile many simple Fortran programs
+- The parser can now parse a large subset of Fortran (if you find something that
+ cannot be parsed, please [report](https://gitlab.com/lfortran/lfortran/-/issues) a bug). Not all the information is yet
+ represented in the AST (so later stages of the compiler also work on a smaller
+ subset), but one should not get parse errors anymore for most valid codes.
+- Initial `lfortran fmt` subcommand for formatting Fortran files, you can
+ provide feedback
+ [here](https://fortran-lang.discourse.group/t/feedback-for-lfortran-fmt-to-format-fortran-source-code/281).
+- A new command `lfortran kernel` can run LFortran as a Jupyter kernel.
+- LFortran itself gives a nice Python like stacktrace (on Linux and macOS) in
+ Debug mode when an unhandled excetion happens or a segfault.
+
+Our goal for September is to get LFortran working for a much larger subset of
+Fortran and allow it to compile and run via the C++ translation backend (the
+LLVM backend will follow soon after).
+
+You can follow LFortran on Twitter for latest updates: [@lfortranorg](https://twitter.com/lfortranorg).
+
+## Events
+
+- We had our fourth Fortran Monthly call on August 20.
+ You can watch the recording below:
+
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib),
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm),
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry),
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org),
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks),
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals):
+
+
diff --git a/_sources/news/2020/10-01-Fortran-Newsletter-October-2020.md.txt b/_sources/news/2020/10-01-Fortran-Newsletter-October-2020.md.txt
new file mode 100644
index 000000000000..ee9cc1f175ef
--- /dev/null
+++ b/_sources/news/2020/10-01-Fortran-Newsletter-October-2020.md.txt
@@ -0,0 +1,193 @@
+---
+category: newsletter
+date: 2020-10-01
+author: Milan Curcic, Ondřej Čertík, Gary Klimowicz, Brad Richardson, Jérémie Vandenplas, and Laurence Kedward
+...
+
+# Fortran newsletter: October 2020
+
+Welcome to the October 2020 edition of the monthly Fortran newsletter.
+The newsletter comes out on the first calendar day of every month
+and details Fortran news from the previous month.
+
+# fortran-lang.org
+
+This month we've had only one minor change to the website:
+
+- [#136](https://github.com/fortran-lang/fortran-lang.org/pull/136):
+ Small fix in the opening sentence on the compilers page
+
+Ongoing work:
+
+- [#117](https://github.com/fortran-lang/fortran-lang.org/issues/117): Adding a
+ Benchmarks section, a new dedicated repository was created at
+ https://github.com/fortran-lang/benchmarks and many details have been
+ discussed in [issues](https://github.com/fortran-lang/benchmarks/issues) there.
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+This month we've had an improvement to the `stdlib_ascii` module,
+as well as addition of logging facilities.
+
+- [#238](https://github.com/fortran-lang/stdlib/pull/238): Improvements to the `stdlib_stats` module by adding explicit conversions.
+- [#228](https://github.com/fortran-lang/stdlib/pull/228): Implementation of the `stdlib_logger` module.
+ It provides a global logger instance for easy use in user applications, as well as a `logger_type` derived type
+ if multiple concurrent loggers are needed.
+ See the [logger specification](https://stdlib.fortran-lang.org/page/specs/stdlib_logger.html)
+ to learn more.
+
+Work in progress:
+
+- [#239](https://github.com/fortran-lang/stdlib/pull/239): Implementation of the `stdlib_bitsets` module. It provides a bitset data type.
+- [#235](https://github.com/fortran-lang/stdlib/pull/235): Improvements to the `stdlib_ascii` module
+
+Otherwise, ongoing discussions continue:
+
+- [#225](https://github.com/fortran-lang/stdlib/issues/225): Name convention for derived types in stdlib
+- [#224](https://github.com/fortran-lang/stdlib/issues/224): Handling and propagating errors inside stdlib
+- [#221](https://github.com/fortran-lang/stdlib/issues/221): API for a bitset data type
+- [#201](https://github.com/fortran-lang/stdlib/issues/201): API for file system operations
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+This month has seen over a dozen additions and improvements to the Fortran implementation of fpm:
+
+- [#186](https://github.com/fortran-lang/fpm/issues/186): Implement version string validation and comparison
+- [#185](https://github.com/fortran-lang/fpm/issues/185): Update CI workflow
+- [#182](https://github.com/fortran-lang/fpm/issues/182): CLI interface to further development of subcommands
+- [#180](https://github.com/fortran-lang/fpm/issues/180): Recursive source discovery
+- [#178](https://github.com/fortran-lang/fpm/issues/178): Add more example packages
+- [#177](https://github.com/fortran-lang/fpm/issues/177): Allow selective testing of single suites and tests
+- [#175](https://github.com/fortran-lang/fpm/issues/175): Updated formatting of Markdown documents
+- [#174](https://github.com/fortran-lang/fpm/issues/174): Cache Haskell Stack build in CI
+- [#171](https://github.com/fortran-lang/fpm/issues/171): Increase test coverage of fpm manifest
+- [#170](https://github.com/fortran-lang/fpm/issues/170): Source parsing tests
+- [#163](https://github.com/fortran-lang/fpm/issues/163): Use different strategy to fetch git dependencies
+- [#162](https://github.com/fortran-lang/fpm/issues/162): Updated OS type identification
+- [#160](https://github.com/fortran-lang/fpm/issues/160): Add contributing guidelines
+ (you can read them [here](https://github.com/fortran-lang/fpm/CONTRIBUTING.md))
+- [#157](https://github.com/fortran-lang/fpm/issues/157): Implement reading of fpm.toml
+- [#155](https://github.com/fortran-lang/fpm/issues/155): Internal dependencies and build backend
+
+Work in progress:
+
+- [#193](https://github.com/fortran-lang/fpm/issues/193) (WIP): Local path dependencies
+- [#190](https://github.com/fortran-lang/fpm/issues/190) (WIP): Auto discovery of executables
+- [#189](https://github.com/fortran-lang/fpm/issues/189) (WIP): Implement `fpm new`
+
+fpm is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Try to use it. Does it work? No? Let us know! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm.
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Classic Flang
+
+We continue to evaluate and merge pull requests into the original Flang
+compiler again. We pulled in several changes in the past month.
+
+One important merge was support for LLVM 10,
+which required the use of a new fork, the _classic-flang-llvm-project_
+fork of the LLVM monorepo. See
+[PR#1](https://github.com/flang-compiler/classic-flang-llvm-project/pull/1)
+for details.
+
+Other recently merged pull requests into Classic Flang include:
+
+- [PR#658: Fix in preprocessing for Flexi app](https://github.com/flang-compiler/flang/pull/658)
+- [PR#737: TRAILZ function added to the fortran compiler](https://github.com/flang-compiler/flang/pull/737)
+- [PR#756: Fix ICE interf:new_symbol_and_link symbol not found](https://github.com/flang-compiler/flang/pull/756)
+- [PR#888: flang gen-exec does not show routine variables with parameter attribute; there are multiple pull requests that this includes (details below)](https://github.com/flang-compiler/flang/pull/888)
+- [PR#916: Fix off-by-one error in minimum integers](https://github.com/flang-compiler/flang/pull/916)
+- [PR#921: Correction of representation of string (character type) constants](https://github.com/flang-compiler/flang/pull/921)
+
+The Classic Flang biweekly call has been set up to discuss issues and plans
+for the next pull requests to be validated and merged. Our next calls will be
+Wednesday, October 7 and 21, 8:30 AM Pacific time. The notes from previous
+calls, upcoming agenda and a link to join the call can be found
+[here](https://docs.google.com/document/d/1-OuiKx4d7O6eLEJDBDKSRnSiUO2rgRR-c2Ga4AkrzOI).
+
+### LLVM Flang
+
+Work continues on LLVM Flang, concentrating on semantics, lowering and runtime
+sufficient to compile and run Fortran 77 programs.
+
+In conjunction with the MLIR-based code from the _fir-dev_ fork (the Fortran
+IR used for lowering), Flang can compile and run most F77 programs,
+including the Fortran Compiler Validation Suite (FCVS).
+We continue to work on refactoring necessary to upstream the _fir-dev_ fork into LLVM
+flang proper.
+
+Arm has contributed changes toward a full-fledged driver for flang.
+
+AMD continues to add support for OpenMP semantics and lowering.
+
+Valentin Clement continues to contribute parsing and semantics changes for
+OpenACC support. This will be the topic of the next Flang Technical Community call
+on Monday, October 5, 8:30 AM Pacific Time.
+
+Michael Kruse continues to add support for building Flang on Windows with MSVC.
+
+### LFortran
+
+What's new in LFortran:
+
+- 59 Merge Requests were merged and 3 issues fixed in September 2020
+- The FortranCon 2020 LFortran video now [available](https://www.youtube.com/watch?v=tW9tUxVMnzc)
+- LFortran, now imlemented in C++, has surpassed the Python prototype from a
+ year ago
+- The Jupyter notebook now works as it used to with the Python prototype
+- A new notebook added showcasing how to visualize AST, ASR and C++ translation
+ in Jupyter ([!624](https://gitlab.com/lfortran/lfortran/-/merge_requests/624))
+- X86 backend to generate direct x86-32 machine code (very fast compilation in
+ Debug mode)
+- Further parser improvements
+- Initial Fortran modules support
+- Initial support for using GFortran modules
+ ([!632](https://gitlab.com/lfortran/lfortran/-/merge_requests/632))
+- Better compiler error messages
+ ([!617](https://gitlab.com/lfortran/lfortran/-/merge_requests/617))
+- The interactive prompt (REPL) now understands arrow keys
+ ([!603](https://gitlab.com/lfortran/lfortran/-/merge_requests/603))
+
+You can follow LFortran on Twitter for latest updates: [@lfortranorg](https://twitter.com/lfortranorg).
+
+## Events
+
+- We had our fourth Fortran Monthly call on September 25.
+ You can watch the recording below:
+
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib),
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm),
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry),
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org),
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks),
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals):
+
+
diff --git a/_sources/news/2020/11-01-Fortran-Newsletter-November-2020.md.txt b/_sources/news/2020/11-01-Fortran-Newsletter-November-2020.md.txt
new file mode 100644
index 000000000000..4471544bc1b0
--- /dev/null
+++ b/_sources/news/2020/11-01-Fortran-Newsletter-November-2020.md.txt
@@ -0,0 +1,190 @@
+---
+category: newsletter
+date: 2020-11-01
+author: Milan Curcic, Sebastian Ehlert, Laurence Kedward, Jeremie Vandenplas, Ivan Pribec, Ondřej Čertík, Gary Klimowicz, Brad Richardson
+...
+
+# Fortran newsletter: November 2020
+
+Welcome to the November 2020 edition of the monthly Fortran newsletter.
+The newsletter comes out on the first calendar day of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had a few additions and improvements to the website:
+
+- [#152](https://github.com/fortran-lang/fortran-lang.org/pull/152):
+ New mini-book on setting up the Fortran development environment.
+ You can read it [here](https://fortran-lang.org/learn/os_setup).
+- [#147](https://github.com/fortran-lang/fortran-lang.org/pull/147):
+ Automated posting to @fortranlang Twitter using twitter-together.
+- [#155](https://github.com/fortran-lang/fortran-lang.org/pull/155):
+ Fix for a security vulnerability reported by the GitHub Security Team.
+- The following packages were added to the
+ [Package Index](https://fortran-lang.org/packages):
+ atomsk, ddPCM, DFTB+, DFT-D4, ELPA, ELSI, FortJSON, fypp, HANDE, libmbd, libnegf,
+ mpifx, NTPoly, NWChem, OpenMolcas, PoisFFT, QMD-PROGRESS, scalapackfx,
+ tapenade, wannier90, and xtb.
+- [#145](https://github.com/fortran-lang/fortran-lang.org/pull/145),
+ [#146](https://github.com/fortran-lang/fortran-lang.org/pull/146),
+ [#154](https://github.com/fortran-lang/fortran-lang.org/pull/154),
+ [#158](https://github.com/fortran-lang/fortran-lang.org/pull/158):
+ Minor fixes and improvements.
+
+Ongoing work:
+
+- [#160](https://github.com/fortran-lang/fortran-lang.org/pull/160) (WIP):
+ In-depth introduction for Fortran with Make.
+- [#156](https://github.com/fortran-lang/fortran-lang.org/pull/156) (WIP):
+ Updating the mini-book on building programs.
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+This month progress was made on a few pull requests:
+
+- [#239](https://github.com/fortran-lang/stdlib/pull/239): Implementation of the `stdlib_bitsets` module. It provides a bitset data type.
+- [#240](https://github.com/fortran-lang/stdlib/pull/240): Implementation of the `stdlib_stats_distribution` module. It provides probability distribution and statistical functions.
+- [#243](https://github.com/fortran-lang/stdlib/pull/243): A proposition to support newline characters in the message provided to the logger.
+
+Don't hesitate to test and review these pull requests!
+
+Otherwise, ongoing discussions continue;
+
+- [#220](https://github.com/fortran-lang/stdlib/pull/220): API for file system operations: directory manipulation
+- [#241](https://github.com/fortran-lang/stdlib/pull/241): Include a `split` function (202X feature)
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+What's new:
+
+- [#213](https://github.com/fortran-lang/fpm/issues/213): Bootstrap fpm submodule support
+- [#208](https://github.com/fortran-lang/fpm/issues/208): Minor fixes to `list_files` and `mkdir` in `fpm_filesystem`
+- [#206](https://github.com/fortran-lang/fpm/issues/206): Add installation script in `install.sh`
+- [#193](https://github.com/fortran-lang/fpm/issues/193): Local and remote package dependencies (Fortran fpm can now build itself)
+- [#190](https://github.com/fortran-lang/fpm/issues/190): Auto discovery of executables
+- [#189](https://github.com/fortran-lang/fpm/issues/189),
+ [#204](https://github.com/fortran-lang/fpm/issues/204),
+ [#203](https://github.com/fortran-lang/fpm/issues/203): Implement `fpm new` in Fortran fpm
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP): First feature-complete release of the Fortran implementation.
+- [#221](https://github.com/fortran-lang/fpm/issues/221) (WIP): Test and executable runner options
+- [#220](https://github.com/fortran-lang/fpm/issues/220) (WIP): Compiler and flags
+- [#216](https://github.com/fortran-lang/fpm/issues/216) (WIP): Remove bashism from install.sh
+- [#209](https://github.com/fortran-lang/fpm/issues/209) (WIP): Add automatic documentation for Fortran fpm
+- [#202](https://github.com/fortran-lang/fpm/issues/202) (WIP): Create package manifest with toml-f build interface
+
+fpm is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Try to use it. Does it work? No? Let us know! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm.
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Classic Flang
+
+We continue to evaluate and merge pull requests into the original Flang
+compiler again. We pulled in several changes in October.
+
+Recently merged pull requests into Classic Flang include:
+
+- [PR#660: Enable support for simd directives](https://github.com/flang-compiler/flang/pull/660)
+- [PR#878: [DebugInfo]: Fix for missing DISPFlagOptimized in debug metadata](https://github.com/flang-compiler/flang/pull/878)
+- [PR#910: Fix f90_correct tests](https://github.com/flang-compiler/flang/pull/910)
+- [PR#922: Fix private flag overwrite in find_def_in_most_recent_scope()](https://github.com/flang-compiler/flang/pull/922)
+- [PR#927: f90_correct: exclude tests failing with LLVM 10 on OpenPOWER](https://github.com/flang-compiler/flang/pull/927)
+- [PR#930: Fix HTML docs generation](https://github.com/flang-compiler/flang/pull/930)
+- [PR#931: [flang2] Fix segmentation faults (#421)](https://github.com/flang-compiler/flang/pull/931)
+- [PR#932: [flang1] Do not assume unempty derived types](https://github.com/flang-compiler/flang/pull/932)
+- [PR#938: [flang2] Fixing possible crash due to ivl being NULL in dinit.cpp](https://github.com/flang-compiler/flang/pull/938)
+
+The Classic Flang biweekly call has been set up to discuss issues and plans
+for the next pull requests to be validated and merged. Our next calls will be
+Wednesday, November 4 and 18, 8:00 AM Pacific time (note the time change).
+The notes from previous calls, upcoming agenda and a link to join the call can be found
+[here](https://docs.google.com/document/d/1-OuiKx4d7O6eLEJDBDKSRnSiUO2rgRR-c2Ga4AkrzOI).
+
+### LLVM Flang
+
+Work continues on LLVM Flang, concentrating on semantics, lowering and runtime.
+
+In conjunction with the MLIR-based code from the _fir-dev_ fork (the Fortran
+IR used for lowering), Flang can compile and run most F77 programs,
+including the Fortran Compiler Validation Suite (FCVS).
+
+Pat McCormick is working on an RFC for the merge of the lowering code
+in the fir-dev fork into LLVM master.
+The goal is to expedite this in a way that is acceptable to the Flang community,
+so we can do further work in the single master branch.
+
+Arm continues to contribute changes toward a full-fledged driver for flang.
+
+AMD continues to add support for OpenMP semantics and lowering.
+
+Valentin Clement continues to contribute parsing and semantics changes for
+OpenACC support.
+
+Michael Kruse continues to add support for building Flang on Windows with MSVC
+to the point that he can build and test Flang on Windows.
+
+### LFortran
+
+What's new in LFortran:
+
+- 9 Merge Requests were merged and 5 issues fixed in October 2020
+- We gave LFortran
+ [talk](https://cfp.jupytercon.com/2020/schedule/presentation/169/lfortran-interactive-llvm-based-fortran-compiler-for-modern-architectures/)
+ at JupyterCon 2020
+- A prototype compiler implementation of conditional expressions for the
+ October 2020 Fortran Standards Committee meeting
+ ([!645](https://gitlab.com/lfortran/lfortran/-/merge_requests/645))
+- Better code formatting support (`lfortran fmt`)
+- Improvements to AST
+- Capture stdout on Windows in a Jupyter notebook
+ ([!642](https://gitlab.com/lfortran/lfortran/-/merge_requests/642))
+
+You can follow LFortran on Twitter for latest updates: [@lfortranorg](https://twitter.com/lfortranorg).
+
+## Events
+
+- The US Fortran Standards Committee held a virtual meeting from October 12-14.
+ You can read the summary and the discussion [here](https://github.com/j3-fortran/fortran_proposals/issues/185) and all the documents [here](https://j3-fortran.org/doc/meeting/222).
+
+- We had our 5th Fortran Monthly call on October 27.
+ You can watch the recording below:
+
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2020/12-01-Fortran-Newsletter-December-2020.md.txt b/_sources/news/2020/12-01-Fortran-Newsletter-December-2020.md.txt
new file mode 100644
index 000000000000..350a7eb8c915
--- /dev/null
+++ b/_sources/news/2020/12-01-Fortran-Newsletter-December-2020.md.txt
@@ -0,0 +1,186 @@
+---
+category: newsletter
+date: 2020-12-01
+author: Milan Curcic, Jérémie Vandenplas, Laurence Kedward, Gary Klimowicz, Ondřej Čertík
+...
+
+# Fortran newsletter: December 2020
+
+Welcome to the December 2020 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had a few updates to the website:
+
+- [#156](https://github.com/fortran-lang/fortran-lang.org/pull/156):
+ Updates to the mini-book on building Fortran programs, including the addition of
+ short guides on Meson and CMake.
+ You can read the mini-book [here](https://fortran-lang.org/learn/building_programs).
+- [#169](https://github.com/fortran-lang/fortran-lang.org/pull/169):
+ Add PSBLAS to the package index.
+
+Ongoing work:
+
+- [#160](https://github.com/fortran-lang/fortran-lang.org/pull/160) (WIP):
+ In-depth introduction for Fortran with Make.
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in `stdlib`:
+
+- [#239](https://github.com/fortran-lang/stdlib/pull/239): Implementation of bitsets in `stdlib_bitsets`.
+- [#243](https://github.com/fortran-lang/stdlib/pull/243),
+ [#245](https://github.com/fortran-lang/stdlib/pull/245),
+ [#252](https://github.com/fortran-lang/stdlib/pull/253),
+ [#255](https://github.com/fortran-lang/stdlib/pull/255): Various improvements to `stdlib_logger`.
+- [#245](https://github.com/fortran-lang/stdlib/pull/245),
+ [#250](https://github.com/fortran-lang/stdlib/pull/250): Minor fixes to the CI.
+
+Work in progress:
+
+- (WIP) [#240](https://github.com/fortran-lang/stdlib/pull/240): Implementation of the `stdlib_stats_distribution` module. It provides probability distribution and statistical functions.
+- (WIP) [#189](https://github.com/fortran-lang/stdlib/pull/189): Initial implementation of sparse matrices.
+
+Don't hesitate to test and review these pull requests!
+
+Otherwise, ongoing discussions continue:
+
+- [#220](https://github.com/fortran-lang/stdlib/issues/220): API for file system operations: directory manipulation
+- [#241](https://github.com/fortran-lang/stdlib/issues/241): Include a `split` function (202X feature)
+- [#254](https://github.com/fortran-lang/stdlib/issues/254): Proposition to add a logger for debug phases and levels among the different logs.
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in `fpm`:
+
+- [#259](https://github.com/fortran-lang/fpm/pull/259): Update the instructions for building from source in README.md.
+- [#246](https://github.com/fortran-lang/fpm/pull/246): Automated binary releases in CI.
+- [#233](https://github.com/fortran-lang/fpm/pull/233): Allow linking with external libraries.
+- [#224](https://github.com/fortran-lang/fpm/pull/224): Add a reference document for the package manifest (fpm.toml).
+- [#221](https://github.com/fortran-lang/fpm/pull/221),
+ [#239](https://github.com/fortran-lang/fpm/pull/239): Runner options for test and app executables.
+- [#220](https://github.com/fortran-lang/fpm/pull/220): Implement compiler and flags settings in Haskell fpm.
+- [#209](https://github.com/fortran-lang/fpm/pull/209):
+ [#237](https://github.com/fortran-lang/fpm/pull/237): Developer API docs.
+- [#216](https://github.com/fortran-lang/fpm/pull/216),
+ [#225](https://github.com/fortran-lang/fpm/pull/225),
+ [#226](https://github.com/fortran-lang/fpm/pull/226),
+ [#229](https://github.com/fortran-lang/fpm/pull/229),
+ [#236](https://github.com/fortran-lang/fpm/pull/236),
+ [#240](https://github.com/fortran-lang/fpm/pull/240),
+ [#247](https://github.com/fortran-lang/fpm/pull/240): Other fixes and improvements.
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP): First feature-complete release of the Fortran implementation.
+- (WIP) [#230](https://github.com/fortran-lang/fpm/pull/230),
+ [#261](https://github.com/fortran-lang/fpm/pull/261): Specification of the fpm CLI.
+- (WIP) [#232](https://github.com/fortran-lang/fpm/pull/232): Allowing the `extra` section in fpm.toml.
+- (WIP) [#248](https://github.com/fortran-lang/fpm/pull/248): Refactor backend for incremental rebuilds.
+- (WIP) [#251](https://github.com/fortran-lang/fpm/pull/251): Dependency management.
+- (WIP) [#255](https://github.com/fortran-lang/fpm/pull/255): Setting the compiler and specifying test or app target.
+- (WIP) [#257](https://github.com/fortran-lang/fpm/pull/257): Implement `fpm install`.
+- (WIP) [#260](https://github.com/fortran-lang/fpm/pull/260): Fix CI to test release build.
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Classic Flang
+
+We continue to evaluate and merge pull requests into Classic Flang. Recently merged pull requests into Classic Flang include:
+
+- [PR#883: Flang generated executable does not show result variable of function](https://github.com/flang-compiler/flang/pull/883)
+- [PR#933: Updating X-flag entries for internal command line option "-x 49"](https://github.com/flang-compiler/flang/pull/933)
+- [PR#939: Publish Arm's internal documentation](https://github.com/flang-compiler/flang/pull/939)
+- [PR#941: [DebugInfo] Internal subprogram variable is not accessible for printing in gdb](https://github.com/flang-compiler/flang/pull/941)
+- [PR#942: Implement UNROLL(n) directive](https://github.com/flang-compiler/flang/pull/942)
+- [PR#943: Enable github Actions for push to master and pull requests to master](https://github.com/flang-compiler/flang/pull/943)
+- [PR#945: libpgmath: Stop using pgstdinit.h](https://github.com/flang-compiler/flang/pull/945)
+- [PR#946: Call check_member() for PD_is_contiguous](https://github.com/flang-compiler/flang/pull/946)
+- [PR#951: Fix for ICE in atomic instruction generation](https://github.com/flang-compiler/flang/pull/951)
+
+Pull requests merged into the supporting projects:
+
+- [classic flang LLVM monorepo PR#5: [Driver] Reduce downstream delta](https://github.com/flang-compiler/classic-flang-llvm-project/pull/5)
+- [classic flang LLVM monorepo PR#6: Removing a few CI pipelines](https://github.com/flang-compiler/classic-flang-llvm-project/pull/6)
+- [classic flang LLVM monorepo PR#7: Github Actions added to pre-compile artifacts for flang](https://github.com/flang-compiler/classic-flang-llvm-project/pull/7)
+- [llvm mirror PR#87: Enable github actions for llvm](https://github.com/flang-compiler/llvm/pull/87)
+- [flang-driver PR#94: Enable github actions](https://github.com/flang-compiler/flang-driver/pull/94)
+
+The Classic Flang biweekly call has been set up to discuss issues and plans
+for the next pull requests to be validated and merged. Our next calls are Wednesday, December 16 and 30, 8:00 AM Pacific time. The notes from previous calls, upcoming agenda and a link to join the call can be found
+[here](https://docs.google.com/document/d/1-OuiKx4d7O6eLEJDBDKSRnSiUO2rgRR-c2Ga4AkrzOI).
+
+### LLVM Flang
+
+Work continues on LLVM Flang, concentrating on semantics, lowering and runtime. Significant contributions are being made for OpenMP and OpenACC support.
+
+In conjunction with the MLIR-based code from the _fir-dev_ fork (the Fortran IR used for lowering), Flang can compile and run most F77 programs, including the Fortran Compiler Validation Suite (FCVS).
+
+Pat McCormick is (still) working on an RFC for the merge of the lowering code
+in the fir-dev fork into LLVM master. (This was interrupted by Supercomputing 2020 and other ECP duties.) The goal is to expedite this in a way that is acceptable to the Flang community, so we can do further work in the single master branch.
+
+Recent updates include:
+
+- Johannes Doerfert has created a web page at https://flang.llvm.org; you can find call and Slack logistics there
+- Nichols Romero has an llvm-dev RFC for adding Fortran tests to the llvm-tests project: http://lists.llvm.org/pipermail/llvm-dev/2020-November/146873.html
+- Andzrej Warzynski has a flang-dev RFC regarding flang option names: http://lists.llvm.org/pipermail/flang-dev/2020-November/000588.html
+- Andzrej Warzynski has a cfe-dev RFC regarding refactoring clang to help flang driver become independent of clang: http://lists.llvm.org/pipermail/cfe-dev/2020-November/067263.html
+- Changed representation of CHARACTER data in type system to make more consistent with other types (for arrays)
+- Changed COMPLEX expression representation to provide better handling in lowering
+- More improvements for supporting Fortran 77 programs
+- Implemented runtime support for basic ALLOCATE/DEALLOCATE and further work
+- Continued implementation of table-driven runtime for derived types; posted documentation
+- Continued implementation of array expression lowering
+- Improved error checks on forward references
+- More updates to flang driver (option handling; -E can now be used to invoke just the Flang preprocessor)
+- OpenACC semantic checks for modifiers on enter/exit data, set directives
+- OpenACC lowering (enter/exit data, update, init, shutdown, wait directives)
+- OpenMP structure checker updates; semantic checks for copyin clause; schedule class
+
+## Events
+
+- Brian Friesen (Lawrence Berkeley National Laboratory) was selected to be the new Chair of PL22.3 (J3, US Standards Committee).
+ Brian will serve in his first term until November 2023. Congratulations, Brian!
+- We had our 6th Fortran Monthly call on November 17.
+ You can watch the recording below:
+
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/01-01-Fortran-Newsletter-January-2021.md.txt b/_sources/news/2021/01-01-Fortran-Newsletter-January-2021.md.txt
new file mode 100644
index 000000000000..1388a5c7ee20
--- /dev/null
+++ b/_sources/news/2021/01-01-Fortran-Newsletter-January-2021.md.txt
@@ -0,0 +1,239 @@
+---
+category: newsletter
+date: 2021-01-01
+author: Jérémie Vandenplas, Sebastian Ehlert, Laurence Kedward, Milan Curcic, Gary Klimowicz, Ondřej Čertík
+...
+
+# Fortran newsletter: January 2021
+
+Happy New Year!
+Welcome to the January 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had a few updates to the website:
+
+- [#178](https://github.com/fortran-lang/fortran-lang.org/pull/178),
+ [#188](https://github.com/fortran-lang/fortran-lang.org/pull/188):
+ Fix build preview
+- [#179](https://github.com/fortran-lang/fortran-lang.org/pull/179):
+ Fix word spelling error in quickstart page
+- [#173](https://github.com/fortran-lang/fortran-lang.org/pull/173),
+ [#180](https://github.com/fortran-lang/fortran-lang.org/pull/180),
+ [#186](https://github.com/fortran-lang/fortran-lang.org/pull/186):
+ Add missing packages from the list of popular Fortran projects to the package index
+- [#182](https://github.com/fortran-lang/fortran-lang.org/pull/182):
+ Update compilers page following Intel oneAPI release
+- [#160](https://github.com/fortran-lang/fortran-lang.org/pull/160),
+ [#171](https://github.com/fortran-lang/fortran-lang.org/pull/171):
+ In-depth introduction for Fortran with Make.
+
+Ongoing work:
+
+- [#187](https://github.com/fortran-lang/fortran-lang.org/pull/187) (WIP):
+ Correct compiler page and tutorial regarding Intel oneAPI and PGI to NVIDIA
+- [#174](https://github.com/fortran-lang/fortran-lang.org/issues/174) (WIP):
+ We are searching for a representative Fortran code snippet for the website and are looking forward to suggestions.
+- [#190](https://github.com/fortran-lang/fortran-lang.org/pull/190) (WIP):
+ Add links to fpm contributing guidelines
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in `stdlib`:
+
+- [#256](https://github.com/fortran-lang/stdlib/pull/256): Add the method `log_debug` to `stdlib_logger`
+- [#257](https://github.com/fortran-lang/stdlib/pull/257): Improve CMake check for F18 error stop
+- [#260](https://github.com/fortran-lang/stdlib/pull/260): Add Intel oneAPI Fortran compiler to CI
+- [#261](https://github.com/fortran-lang/stdlib/pull/261): Add a level option to ignore logging messages
+- [#263](https://github.com/fortran-lang/stdlib/pull/263),
+ [#267](https://github.com/fortran-lang/stdlib/pull/267): Minor fixes to CI
+- [#270](https://github.com/fortran-lang/stdlib/pull/270): Add GFortran 10 to CI
+- [#275](https://github.com/fortran-lang/stdlib/pull/275): Add MSYS2 systems to Windows CI
+- [#282](https://github.com/fortran-lang/stdlib/pull/282): Add a note about memory issues when compiling stdlib with the support of arrays to up 15 ranks
+- [#283](https://github.com/fortran-lang/stdlib/pull/283): Improve the compilation load by splitting submodules
+
+Work in progress:
+
+- [#269](https://github.com/fortran-lang/stdlib/pull/269) (WIP): Implementation of a module for handling lists of strings
+- [#271](https://github.com/fortran-lang/stdlib/pull/271) (WIP),
+ [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP),
+ [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP),
+ [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP),
+ [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP): Implementation of the `stdlib_stats_distribution` modules. It provides probability distribution and statistical functions.
+- [#284](https://github.com/fortran-lang/stdlib/pull/284) (WIP): Required changes to be able to use `stdlib` as a subproject in CMake
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP): Initial implementation of sparse matrices.
+
+Don't hesitate to test and review these pull requests!
+
+Otherwise, ongoing discussions continue about usability of `stdlib`
+([#7](https://github.com/fortran-lang/stdlib/issues/7),
+[#215](https://github.com/fortran-lang/stdlib/issues/215),
+[#279](https://github.com/fortran-lang/stdlib/issues/279),
+[#280](https://github.com/fortran-lang/stdlib/issues/280),
+[#285](https://github.com/fortran-lang/stdlib/issues/285)),
+and new implementations for `stdlib`
+([#135](https://github.com/fortran-lang/stdlib/issues/135),
+[#212](https://github.com/fortran-lang/stdlib/issues/212),
+[#234](https://github.com/fortran-lang/stdlib/issues/234),
+[#241](https://github.com/fortran-lang/stdlib/issues/241),
+[#258](https://github.com/fortran-lang/stdlib/issues/258),
+[#259](https://github.com/fortran-lang/stdlib/issues/259),
+[#262](https://github.com/fortran-lang/stdlib/issues/262),
+[#268](https://github.com/fortran-lang/stdlib/issues/268),
+[#277](https://github.com/fortran-lang/stdlib/issues/277)).
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in `fpm`:
+
+- [Alpha release version 0.1.3](https://github.com/fortran-lang/fpm/releases/tag/v0.1.3)
+- [setup-fpm action](https://github.com/marketplace/actions/setup-fpm):
+ GitHub Action to setup the Fortran Package Manager on Ubuntu, MacOS and Windows runners
+- [Discussion board](https://github.com/fortran-lang/fpm/discussions):
+ For questions & answers, sharing of ideas, showing off projects and, of course, discussions around fpm
+- [#248](https://github.com/fortran-lang/fpm/pull/248):
+ Refactor backend for incremental rebuilds
+- [#266](https://github.com/fortran-lang/fpm/pull/251):
+ Dependency management and `fpm update` subcommand
+- [#255](https://github.com/fortran-lang/fpm/pull/255)
+ Setting the compiler and specifying test or app target
+- [#262](https://github.com/fortran-lang/fpm/pull/262):
+ Add -fcoarray=single to default gfortran flags
+- [#257](https://github.com/fortran-lang/fpm/pull/257):
+ Implement `fpm install`
+- [#260](https://github.com/fortran-lang/fpm/pull/260):
+ Fix CI to test release build
+- [#267](https://github.com/fortran-lang/fpm/pull/267):
+ Fix enumeration of non-library link objects
+- [#268](https://github.com/fortran-lang/fpm/pull/268):
+ Fix dependency tracking issue in bootstrap version
+- [#271](https://github.com/fortran-lang/fpm/pull/271):
+ Fix Windows run and test commands
+- [#273](https://github.com/fortran-lang/fpm/pull/273):
+ Update developer documentation (manifest + command line)
+- [#274](https://github.com/fortran-lang/fpm/pull/274):
+ Update README with link to setup-fpm github action.
+- [#280](https://github.com/fortran-lang/fpm/pull/280):
+ Create specification for example section
+- [#281](https://github.com/fortran-lang/fpm/pull/281):
+ Cleanup: Remove archived Rust prototype
+- [#284](https://github.com/fortran-lang/fpm/pull/284):
+ Document model and backend for developers
+- [#285](https://github.com/fortran-lang/fpm/pull/285):
+ CI: update naming of release binaries
+- [#286](https://github.com/fortran-lang/fpm/pull/286):
+ Implement check for duplicated program names
+- [#289](https://github.com/fortran-lang/fpm/pull/289):
+ Add support for same compilers as Fortran version to Haskell version
+- [#291](https://github.com/fortran-lang/fpm/pull/291):
+ Initial implementation of `fpm build --show-model`
+- [#292](https://github.com/fortran-lang/fpm/pull/292):
+ Specify the correct help for `fpm run -h`
+- [#293](https://github.com/fortran-lang/fpm/pull/293):
+ Fix: missing error check after `new_package` call
+- [#294](https://github.com/fortran-lang/fpm/pull/294):
+ Add: support for detecting .f and .F files
+- [#300](https://github.com/fortran-lang/fpm/pull/300):
+ Remove -coarray=single option from ifort compiler default options
+- [#303](https://github.com/fortran-lang/fpm/pull/303):
+ Fixes to source parsing
+- [#304](https://github.com/fortran-lang/fpm/pull/304):
+ Remove note on not supported dependencies in program targets
+- [#307](https://github.com/fortran-lang/fpm/pull/307):
+ Fix: program object file collision
+- [#315](https://github.com/fortran-lang/fpm/pull/315):
+ Remove: -ffast-math in gfortran default release flags
+- [#322](https://github.com/fortran-lang/fpm/pull/322):
+ Group sources by package in the model
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP):
+ First feature-complete release of the Fortran implementation.
+- [#230](https://github.com/fortran-lang/fpm/pull/230),
+ [#261](https://github.com/fortran-lang/fpm/pull/261) (WIP):
+ Specification of the fpm CLI.
+- [#316](https://github.com/fortran-lang/fpm/pull/316) (WIP):
+ Update subcommand "new" to reflect the addition of support for examples
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Classic Flang
+
+There are several pull requests out for evaluation.
+
+Only one pull request was merged in December:
+
+- [PR#951 Fix for ICE in atomic instruction generation](https://github.com/flang-compiler/flang/pull/951)
+
+### LLVM Flang
+
+Alexis-Perry Holby (aperry@lanl.gov) has taken over the Flang biweekly calls.
+An invitation was sent to the _flang-dev_ LLVM email list on December 22nd.
+Call notes will be sent to the _flang-dev_ email list and also recorded [here](https://docs.google.com/document/d/10T-S2J3GrahpG4Ooif93NSTz2zBW0MQc_RlwHi0-afY).
+
+Recent development updates:
+
+- Semantic analysis fix for index-names of `FORALL` statements
+- Continued work on parser support for `ALLOCATE`
+- Build tidying
+- OpenMP semantic checks: atomic, flush
+- Continued work on new driver
+- Fix for list-directed REAL output editing
+- Bug fixes: USE of USE of generic, crash in folding (#48437), crash in OpenMP semantic check (#48308), `IMPLICIT_NONE(EXTERNAL)`
+- Implement `STORAGE_SIZE()`, `SIZEOF()`, and `C_SIZEOF()`
+- OpenACC: update serial construct clauses for 3.1, enforce restriction on routine directive and clauses
+- OpenMP: adding important clauses to OmpClause, task reduction clause
+
+## Events
+
+- We had our 7th Fortran Monthly call on December 15.
+ You can watch the recording below:
+
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+- [Episode 6](https://adspthepodcast.com/2021/01/01/Episode-6.html) of the
+ Algorithms+Data Structures=Programs (ADSP) Podcast discussed Fortran and
+ the recent fortran-lang developments.
+- [First year of Fortran-lang](https://medium.com/modern-fortran/first-year-of-fortran-lang-d8796bfa0067) by Milan Curcic.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/02-01-Fortran-Newsletter-February-2021.md.txt b/_sources/news/2021/02-01-Fortran-Newsletter-February-2021.md.txt
new file mode 100644
index 000000000000..77e9c7851e22
--- /dev/null
+++ b/_sources/news/2021/02-01-Fortran-Newsletter-February-2021.md.txt
@@ -0,0 +1,198 @@
+---
+category: newsletter
+date: 2021-02-01
+author: Sebastian Ehlert, Milan Curcic, Laurence Kedward, Jérémie Vandenplas, Alexis Perry-Holby
+...
+
+# Fortran newsletter: February 2021
+
+Welcome to the February 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had a few updates to the website:
+
+- [#190](https://github.com/fortran-lang/fortran-lang.org/pull/190):
+ Add links to fpm contributing guidelines
+
+Ongoing work:
+
+- [#191](https://github.com/fortran-lang/fortran-lang.org/pull/191) (WIP):
+ Fix author/maintainer output in fpm registry
+- [#187](https://github.com/fortran-lang/fortran-lang.org/pull/187) (WIP):
+ Correct compiler page and tutorial regarding Intel oneAPI and PGI to NVIDIA
+- [#174](https://github.com/fortran-lang/fortran-lang.org/issues/174) (WIP):
+ We are searching for a representative Fortran code snippet for the website and are looking forward to suggestions.
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in `stdlib`:
+
+- [#303](https://github.com/fortran-lang/stdlib/pull/303),
+ [#301](https://github.com/fortran-lang/stdlib/pull/301),
+ [#294](https://github.com/fortran-lang/stdlib/pull/294):
+ Fixes and improvements for the manual Makefile build
+- [#293](https://github.com/fortran-lang/stdlib/pull/293):
+ Write a more verbose introduction to building stdlib
+- [#291](https://github.com/fortran-lang/stdlib/pull/291):
+ Export package files (CMake and pkg-config)
+- [#290](https://github.com/fortran-lang/stdlib/pull/290):
+ Rename CMake project from stdlib to fortran_stdlib
+- [#288](https://github.com/fortran-lang/stdlib/pull/288):
+ Follow GNU install conventions
+- [#284](https://github.com/fortran-lang/stdlib/pull/284):
+ Required changes to be able to use `stdlib` as a subproject in CMake
+- [CMake example](https://github.com/fortran-lang/stdlib-cmake-example):
+ Integration of the Fortran standard library in CMake projects
+
+Work in progress:
+
+- [#304](https://github.com/fortran-lang/stdlib/pull/304) (WIP):
+ Add supported compilers MinGW 8, 9, 10
+- [#269](https://github.com/fortran-lang/stdlib/pull/269) (WIP):
+ Implementation of a module for handling lists of strings
+- [#271](https://github.com/fortran-lang/stdlib/pull/271) (WIP),
+ [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP),
+ [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP),
+ [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP),
+ [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Implementation of the `stdlib_stats_distribution` modules.
+ It provides probability distribution and statistical functions.
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of sparse matrices.
+
+Don't hesitate to test and review these pull requests!
+
+Otherwise, ongoing discussions continue about usability of `stdlib`
+([#7](https://github.com/fortran-lang/stdlib/issues/7),
+[#215](https://github.com/fortran-lang/stdlib/issues/215),
+[#279](https://github.com/fortran-lang/stdlib/issues/279),
+[#280](https://github.com/fortran-lang/stdlib/issues/280),
+[#285](https://github.com/fortran-lang/stdlib/issues/285)),
+and new implementations for `stdlib`
+([#135](https://github.com/fortran-lang/stdlib/issues/135),
+[#212](https://github.com/fortran-lang/stdlib/issues/212),
+[#234](https://github.com/fortran-lang/stdlib/issues/234),
+[#241](https://github.com/fortran-lang/stdlib/issues/241),
+[#258](https://github.com/fortran-lang/stdlib/issues/258),
+[#259](https://github.com/fortran-lang/stdlib/issues/259),
+[#262](https://github.com/fortran-lang/stdlib/issues/262),
+[#268](https://github.com/fortran-lang/stdlib/issues/268),
+[#277](https://github.com/fortran-lang/stdlib/issues/277)).
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in `fpm`:
+
+- [#342](https://github.com/fortran-lang/fpm/pull/342):
+ Fix broken link in contributing guidelines
+- [#337](https://github.com/fortran-lang/fpm/pull/337):
+ Allow hyphens in fpm project names in "fpm new"
+- [#335](https://github.com/fortran-lang/fpm/pull/335):
+ Fix: performance regression
+- [#334](https://github.com/fortran-lang/fpm/pull/334):
+ Remove a name clash in the fpm testsuite
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP):
+ First feature-complete release of the Fortran implementation.
+- [#230](https://github.com/fortran-lang/fpm/pull/230),
+ [#261](https://github.com/fortran-lang/fpm/pull/261) (WIP):
+ Specification of the fpm CLI.
+- [#316](https://github.com/fortran-lang/fpm/pull/316) (WIP):
+ Update subcommand "new" to reflect the addition of support for examples
+- [#345](https://github.com/fortran-lang/fpm/pull/345) (WIP):
+ Update: fpm_backend with dynamic openmp scheduling
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Classic Flang
+
+There are a number of pull requests out for evaluation.
+
+A total of 12 pull requests were merged in January.
+
+- [PR#932 Do not assume unempty derived types](https://github.com/flang-compiler/flang/pull/932)
+- [PR#957 Support Prefetch Directive](https://github.com/flang-compiler/flang/pull/957)
+- [PR#947 Fix gcc-10 compilaton issues](https://github.com/flang-compiler/flang/pull/947)
+- [PR#948 Expand CI to run with GCC-9/10 and LLVM-9/10/11](https://github.com/flang-compiler/flang/pull/948)
+- [PR#949 USE rename should check if renamed sptr is available in the scope](https://github.com/flang-compiler/flang/pull/949)
+- [PR#971 Remove dwarfdump_prolog.f90 test since it is dependent on codegen](https://github.com/flang-compiler/flang/pull/971)
+- [PR#940 Flang should generate debug location for limited instructions in prolog](https://github.com/flang-compiler/flang/pull/940)
+- [PR#977 Update apt data before installing sphinx](https://github.com/flang-compiler/flang/pull/977)
+- [PR#751 Fix for len intrinsic returning int\*8 in some cases](https://github.com/flang-compiler/flang/pull/751)
+- [PR#956 Minor FileCheck pattern fixes](https://github.com/flang-compiler/flang/pull/956)
+- [PR#978 Fix the readme to point to the correct flang-dev list](https://github.com/flang-compiler/flang/pull/978)
+- [PR#979 Rename direct header to avoid windows conflict](https://github.com/flang-compiler/flang/pull/979)
+
+### LLVM Flang
+
+Recent development updates:
+
+- OpenMP semantic checks: private, firstprivate, lastprivate, Workshare Construct, `DO` loop restrictions
+- Detect call to abstract interface
+- OpenMP - add task_reduction clause, make reduction clause part of OmpClause
+- New Driver - adding support for various options, testing improvements, standard macro pre-definitions, fixed-form detection, CMake improvements
+- OpenACC - semantic checks to enforce declare directive restrictions
+- Internal subprogram improvements
+- OpenMP/OpenACC - Extend CheckNoBranching to handle branching provided by LabelEnforce
+- Disallow `INTENT` attribute on procedure dummy arguments
+- Module file improvements and bug fixes
+- Add tests for procedure arguments with implicit interfaces
+
+Call notes will be sent to the _flang-dev_ email list and also recorded [here](https://docs.google.com/document/d/10T-S2J3GrahpG4Ooif93NSTz2zBW0MQc_RlwHi0-afY).
+
+## Events
+
+- We had our 8th Fortran Monthly call on January 19.
+ You can watch the recording below:
+
+
+
+- This year fortran-lang will be applying as a mentor organisation for [Google Summer of Code](https://summerofcode.withgoogle.com/).
+ We have started working on the application and the project ideas; you can join the ongoing discussion [here](https://fortran-lang.discourse.group/t/google-summer-of-code-2021/658).
+ If you'd like to help us flesh out the ideas, or have a project idea of your own, please join our upcoming video calls on February 9 and 16 (call info will be posted in the Discourse thread), or write directly in the Discourse thread.
+ If you're a student, or know students who are [eligible to participate](https://developers.google.com/open-source/gsoc/faq#what_are_the_eligibility_requirements_for_participation), and you'd like to help build the Fortran ecosystem please reach out and let us know.
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/03-01-Fortran-Newsletter-March-2021.md.txt b/_sources/news/2021/03-01-Fortran-Newsletter-March-2021.md.txt
new file mode 100644
index 000000000000..49b2ab2fe338
--- /dev/null
+++ b/_sources/news/2021/03-01-Fortran-Newsletter-March-2021.md.txt
@@ -0,0 +1,198 @@
+---
+category: newsletter
+date: 2021-03-01
+author: Milan Curcic, Laurence Kedward, Ondřej Čertík
+...
+
+# Fortran newsletter: March 2021
+
+Welcome to the March 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#191](https://github.com/fortran-lang/fortran-lang.org/pull/191):
+ Fix author/maintainer output in fpm registry
+- [#193](https://github.com/fortran-lang/fortran-lang.org/pull/193):
+ Rename all instances of fortran-lang.github.io to fortran-lang.org
+- [#196](https://github.com/fortran-lang/fortran-lang.org/pull/196):
+ Update package index
+- [#199](https://github.com/fortran-lang/fortran-lang.org/pull/199):
+ Fix broken link for LLVM flang
+- [#205](https://github.com/fortran-lang/fortran-lang.org/pull/205):
+ Add more electronic structure and atomistic simulation packages
+- [#206](https://github.com/fortran-lang/fortran-lang.org/pull/206):
+ Add books to learning section
+- [#208](https://github.com/fortran-lang/fortran-lang.org/pull/208):
+ Fix package information
+
+Ongoing work:
+
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Internationalization for fortran-lang
+- [#207](https://github.com/fortran-lang/fortran-lang.org/issues/207) (WIP):
+ Correct subtitle of setting up your os
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in `stdlib`:
+
+- [#271](https://github.com/fortran-lang/stdlib/pull/271):
+ Probability Distribution and Statistical Functions--PRNG Module
+- [#304](https://github.com/fortran-lang/stdlib/pull/304):
+ Add supported compilers MinGW 8, 9, 10
+- [#310](https://github.com/fortran-lang/stdlib/pull/310):
+ Extend `stdlib_ascii` module for handling character variables
+- [#324](https://github.com/fortran-lang/stdlib/pull/324):
+ Install setuptools for MinGW builds
+
+Work in progress:
+
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of sparse matrices.
+- [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP),
+ [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP),
+ [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP),
+ [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Implementation of the `stdlib_stats_distribution` modules.
+ It provides probability distribution and statistical functions.
+- [#311](https://github.com/fortran-lang/stdlib/pull/311) (WIP):
+ Implementation of a module for handling lists of strings
+- [#320](https://github.com/fortran-lang/stdlib/pull/320) (WIP):
+ Implement non-fancy functional string type
+- [#313](https://github.com/fortran-lang/stdlib/pull/313) (WIP):
+ Legendre polynomials and Gaussian quadrature
+
+Please help improve stdlib by testing and reviewing these pull requests!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in `fpm`:
+
+- [#316](https://github.com/fortran-lang/fpm/pull/316):
+ Update subcommand "new" to reflect the addition of support for the example/ directory
+- [#345](https://github.com/fortran-lang/fpm/pull/345):
+ Fpm backend with dynamic openmp scheduling
+- [#346](https://github.com/fortran-lang/fpm/pull/346):
+ Include root dir in path to default example setup
+- [#349](https://github.com/fortran-lang/fpm/pull/349):
+ Suggest to move the fpm version in the boostrapping process
+- [#372](https://github.com/fortran-lang/fpm/pull/372):
+ Unify release mode calling convention
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP):
+ First feature-complete release of the Fortran implementation.
+- [#230](https://github.com/fortran-lang/fpm/pull/230),
+ [#261](https://github.com/fortran-lang/fpm/pull/261) (WIP):
+ Document the specification of the fpm CLI.
+- [#352](https://github.com/fortran-lang/fpm/pull/352) (WIP):
+ Hacky fix for the help test
+- [#357](https://github.com/fortran-lang/fpm/pull/357) (WIP):
+ Install script for Fortran fpm
+- [#364](https://github.com/fortran-lang/fpm/pull/364) (WIP):
+ Plugin alpha version
+- [#369](https://github.com/fortran-lang/fpm/pull/369) (WIP):
+ Separate build targets from model structure
+- [#370](https://github.com/fortran-lang/fpm/pull/370) (WIP):
+ Update run subcommand
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### LFortran
+
+- The LFortran team is excited to announce that LFortran is now a [NumFOCUS sponsored project](https://numfocus.org/project/lfortran).
+ Please consider donating to LFortran to accelerate its development.
+- 4 people contributed code in the last month:
+ [Gagandeep Singh](https://github.com/czgdp1807),
+ [Dominic Poerio](https://dompoer.io/),
+ [Rohit Goswami](https://rgoswami.me/),
+ [Ondřej Čertík](https://ondrejcertik.com/).
+- Recent Merge Requests highlights:
+ - Complex type support (thanks to [Gagandeep Singh](https://github.com/czgdp1807)):
+ [!654](https://gitlab.com/lfortran/lfortran/-/merge_requests/654),
+ [!657](https://gitlab.com/lfortran/lfortran/-/merge_requests/657),
+ [!658](https://gitlab.com/lfortran/lfortran/-/merge_requests/658),
+ [!660](https://gitlab.com/lfortran/lfortran/-/merge_requests/660),
+ [!663](https://gitlab.com/lfortran/lfortran/-/merge_requests/663),
+ [!664](https://gitlab.com/lfortran/lfortran/-/merge_requests/664).
+ [!672](https://gitlab.com/lfortran/lfortran/-/merge_requests/672).
+ - Multiline REPL (thanks to [Dominic Poerio](https://dompoer.io/)):
+ [!655](https://gitlab.com/lfortran/lfortran/-/merge_requests/655),
+ [!662](https://gitlab.com/lfortran/lfortran/-/merge_requests/662),
+ [!670](https://gitlab.com/lfortran/lfortran/-/merge_requests/670),
+ [!674](https://gitlab.com/lfortran/lfortran/-/merge_requests/674).
+ - Initial support for runtime math functions:
+ [!667](https://gitlab.com/lfortran/lfortran/-/merge_requests/667),
+ [!673](https://gitlab.com/lfortran/lfortran/-/merge_requests/673),
+ - [!648](https://gitlab.com/lfortran/lfortran/-/merge_requests/648): Implement --show-stacktrace
+ - [!666](https://gitlab.com/lfortran/lfortran/-/merge_requests/666): Refactor
+ ImplicitCast nodes handling
+ - [!665](https://gitlab.com/lfortran/lfortran/-/merge_requests/665): Fixed
+ floating point printing
+
+## Events
+
+- We had our 9th Fortran Monthly call on February 25.
+ You can watch the recording below:
+
+
+
+- This year Fortran-lang applied as a mentor organization for [Google Summer of Code](https://summerofcode.withgoogle.com/).
+ Accepted mentor organizations will be announced on March 9.
+ If you're a student, or know students who are [eligible to participate](https://developers.google.com/open-source/gsoc/faq#what_are_the_eligibility_requirements_for_participation), and you'd like to help build the Fortran ecosystem please reach out and let us know.
+
+- The 223rd meeting of the US Fortran Standards Committee is held virtually from
+ February 22 to March 2 (Monday and Tuesday only).
+ Main topics of dicussion are the planned changes for the Fortran 202X revision
+ of the Standard:
+
+ - [List](https://j3-fortran.org/doc/meeting/223) of all submitted papers
+ - [Summary](https://github.com/j3-fortran/fortran_proposals/issues/199) of which papers were discussed each day and voting results
+
+ If you have ideas for new improvements to the language, please propose them
+ [here](https://github.com/j3-fortran/fortran_proposals).
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/03-09-fortran-lang-accepted-for-google-summer-of-code-2021.md.txt b/_sources/news/2021/03-09-fortran-lang-accepted-for-google-summer-of-code-2021.md.txt
new file mode 100644
index 000000000000..21bcc8fca1d8
--- /dev/null
+++ b/_sources/news/2021/03-09-fortran-lang-accepted-for-google-summer-of-code-2021.md.txt
@@ -0,0 +1,23 @@
+---
+category: newsletter
+date: 2021-03-09
+author: Ondřej Čertík, Milan Curcic, Sebastian Ehlert, Laurence Kedward, Arjen Markus, Brad Richardson, Damian Rouson, Marshall Ward
+...
+
+# Fortran-lang accepted to Google Summer of Code 2021
+
+We are excited to announce that Fortran-lang has been accepted as a [Google Summer of Code (GSoC) 2021 mentoring organization](https://summerofcode.withgoogle.com/organizations/6633903353233408)! 🎉
+
+You can review our project ideas
+[here](https://github.com/fortran-lang/fortran-lang.org/wiki/GSoC-2021-Project-ideas),
+and if you have any ideas that are not mentioned, please let us know.
+
+We are looking for students to get in touch with us and to apply.
+Click [here](https://github.com/fortran-lang/fortran-lang.org/wiki/GSoC-2021-Student-instructions)
+for instructions on how to do so.
+
+Our main communication channel will be the [Fortran Discourse](https://fortran-lang.discourse.group/).
+There, we will announce a date for GSoC video calls where all prospective
+students are welcome to join to ask questions, discuss, and brainstorm ideas.
+
+We look forward to a productive and fun Google Summer of Code!
diff --git a/_sources/news/2021/04-01-Fortran-Newsletter-April-2021.md.txt b/_sources/news/2021/04-01-Fortran-Newsletter-April-2021.md.txt
new file mode 100644
index 000000000000..a75b6375b6b4
--- /dev/null
+++ b/_sources/news/2021/04-01-Fortran-Newsletter-April-2021.md.txt
@@ -0,0 +1,303 @@
+---
+category: newsletter
+date: 2021-04-01
+author: Sebastian Ehlert, Alexis Perry-Holby, Laurence Kedward, Milan Curcic, Ondřej Čertík
+...
+
+# Fortran newsletter: April 2021
+
+Welcome to the April 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#229](https://github.com/fortran-lang/fortran-lang.org/pull/229):
+ Correct value of pi in quickstart mini-book
+- [#226](https://github.com/fortran-lang/fortran-lang.org/pull/226):
+ Added DelaunaySparse to package list
+- [#223](https://github.com/fortran-lang/fortran-lang.org/pull/223)
+ [#225](https://github.com/fortran-lang/fortran-lang.org/pull/225):
+ GSoC announcement
+- [#222](https://github.com/fortran-lang/fortran-lang.org/pull/222):
+ Avoid unclear formulation in contributing guide
+- [#221](https://github.com/fortran-lang/fortran-lang.org/pull/221):
+ Add information about free compiler versions
+- [#216](https://github.com/fortran-lang/fortran-lang.org/pull/216):
+ Improve tags
+- [#207](https://github.com/fortran-lang/fortran-lang.org/issues/207):
+ Correct subtitle of setting up your os
+
+Ongoing work:
+
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Internationalization for fortran-lang
+- [#220](https://github.com/fortran-lang/fortran-lang.org/pull/220) (WIP):
+ Include learn resources to online courses
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in `stdlib`:
+
+- [#320](https://github.com/fortran-lang/stdlib/pull/320):
+ Implement non-fancy functional string type
+- [#362](https://github.com/fortran-lang/stdlib/pull/362):
+ Fix wording in style guide for dimension attribute
+- [#352](https://github.com/fortran-lang/stdlib/pull/352):
+ Added TOC to README
+- [#346](https://github.com/fortran-lang/stdlib/pull/346)
+ [#356](https://github.com/fortran-lang/stdlib/pull/356):
+ Added to_lower, to_upper, reverse and to_title function to stdlib_string_type module
+
+Work in progress:
+
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of sparse matrices.
+- [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP),
+ [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP),
+ [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP),
+ [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Implementation of the `stdlib_stats_distribution` modules.
+ It provides probability distribution and statistical functions.
+- [#311](https://github.com/fortran-lang/stdlib/pull/311) (WIP):
+ Implementation of a module for handling lists of strings
+- [#313](https://github.com/fortran-lang/stdlib/pull/313) (WIP):
+ Legendre polynomials and Gaussian quadrature
+- [#333](https://github.com/fortran-lang/stdlib/pull/333) (WIP):
+ Provide abstract base class for a string object
+- [#336](https://github.com/fortran-lang/stdlib/pull/336) (WIP):
+ Add functions to convert integer/logical values to character values
+- [#343](https://github.com/fortran-lang/stdlib/pull/343) (WIP):
+ Implement strip and chomp as supplement to trim
+- [#349](https://github.com/fortran-lang/stdlib/pull/349) (WIP):
+ Simplify test makefile
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#355](https://github.com/fortran-lang/stdlib/pull/355) (WIP):
+ Implement clip function
+- [#359](https://github.com/fortran-lang/stdlib/pull/359) (WIP):
+ Add general contributing guidelines to stdlib
+- [#360](https://github.com/fortran-lang/stdlib/pull/360) (WIP):
+ Summarize build toolchain workflow and implied rules
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Add sort to stdlib_string_type module
+- [#367](https://github.com/fortran-lang/stdlib/pull/367) (WIP):
+ Add Intel compiler workflow for OSX
+
+Please help improve stdlib by testing and reviewing these pull requests!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in `fpm`:
+
+- [Alpha release version 0.2.0](https://github.com/fortran-lang/fpm/releases/tag/v0.2.0)
+- [Fpm is now available on conda-forge](https://github.com/conda-forge/fpm-feedstock)
+- [#352](https://github.com/fortran-lang/fpm/pull/352):
+ Hacky fix for the help test
+- [#357](https://github.com/fortran-lang/fpm/pull/357):
+ Install script for Fortran fpm
+- [#369](https://github.com/fortran-lang/fpm/pull/369):
+ Separate build targets from model structure
+- [#370](https://github.com/fortran-lang/fpm/pull/370):
+ Update run subcommand
+- [#377](https://github.com/fortran-lang/fpm/pull/377):
+ Add explicit include-dir key to manifest
+- [#378](https://github.com/fortran-lang/fpm/pull/378):
+ Add ford-compatible documentation to fpm_strings.f90
+- [#386](https://github.com/fortran-lang/fpm/pull/386):
+ Replace deprecated flags in debug_fortran option
+- [#390](https://github.com/fortran-lang/fpm/pull/390)
+ [#407](https://github.com/fortran-lang/fpm/pull/407):
+ Implement --flag option for Fortran fpm
+- [#397](https://github.com/fortran-lang/fpm/pull/397):
+ Add Conda install instructions to the README
+- [#398](https://github.com/fortran-lang/fpm/pull/398):
+ Minor fix: for setting executable link libraries
+- [#402](https://github.com/fortran-lang/fpm/pull/402):
+ Add fpm description and reorganize the README intro
+- [#404](https://github.com/fortran-lang/fpm/pull/404):
+ Correct join for null input
+- [#409](https://github.com/fortran-lang/fpm/pull/409):
+ Give Programs Access to Code in Subdirectories
+- [#414](https://github.com/fortran-lang/fpm/pull/414):
+ Add few important links to README
+- [#412](https://github.com/fortran-lang/fpm/pull/412):
+ Duplicate module definitions
+- [#413](https://github.com/fortran-lang/fpm/pull/413):
+ Add: omp_lib to intrinsic modules list
+- [#419](https://github.com/fortran-lang/fpm/pull/419):
+ Split workflow for Haskell and Fortran fpm
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP):
+ First feature-complete release of the Fortran implementation.
+- [#364](https://github.com/fortran-lang/fpm/pull/364) (WIP):
+ Plugin alpha version
+- [#420](https://github.com/fortran-lang/fpm/pull/420) (WIP):
+ Phase out Haskell fpm
+- [fpm-haskell](https://github.com/fortran-lang/fpm-haskell) (WIP):
+ Separate repository for the Haskell fpm version
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Classic Flang
+
+A total of 10 pull requests were merged in February.
+
+- [PR#996 tests: one test case supporting PR #966](https://github.com/flang-compiler/flang/pull/996)
+- [PR#968 Fix a clash between CONTIGUOUS and SAVE attribute in flang (issue #673)](https://github.com/flang-compiler/flang/pull/968)
+- [PR#955 Do not issue an error when character kind 2 is used](https://github.com/flang-compiler/flang/pull/955)
+- [PR#975 Add the option to build release_11x branch of llvm with Github Actions](https://github.com/flang-compiler/flang/pull/975)
+- [PR#974 Fix hash collision handling routine that didn't work due to a fatal mistake (issue #960).](https://github.com/flang-compiler/flang/pull/974)
+- [PR#1000 Add ccache support to GitHub Actions](https://github.com/flang-compiler/flang/pull/1000)
+- [PR#952 Array debugging support with upgraded DISubrange](https://github.com/flang-compiler/flang/pull/952)
+- [PR#1002 Fix for regression introduced by PR #922 (issue #995)](https://github.com/flang-compiler/flang/pull/1002)
+- [PR#985 add asprintf](https://github.com/flang-compiler/flang/pull/985)
+- [PR#966 Fixes to address cp2k compilation and runtime issues](https://github.com/flang-compiler/flang/pull/966)
+
+A total of 8 pull requests were merged in March.
+
+- [PR#963 Fix errors on array initialisation with an implied do loop](https://github.com/flang-compiler/flang/pull/963)
+- [PR#1007 fix for issue #1006: stop passing unused uninitialized value](https://github.com/flang-compiler/flang/pull/1007)
+- [PR#1004 Nested implied do loop fix for real numbers](https://github.com/flang-compiler/flang/pull/1004)
+- [PR#710 Test case for capturing procedure pointers to OpenMP parallel regions](https://github.com/flang-compiler/flang/pull/710)
+- [PR#561 flang2: corrected fix for #424](https://github.com/flang-compiler/flang/pull/561)
+- [PR#778 Fixing NCAR test problems with error tolerance lower than E-12.](https://github.com/flang-compiler/flang/pull/778)
+- [PR#1010 LLVM 12 upgrade](https://github.com/flang-compiler/flang/pull/1010)
+- [PR#1012 Remove release_90 from Github Actions](https://github.com/flang-compiler/flang/pull/1012)
+
+### LLVM Flang
+
+Recent development updates:
+
+- New Driver:
+ - Add options for -fdefault\* and -flarge-sizes
+ - Refine tests for module search directories
+ - Add -fdebug-dump-parsing-log
+ - Add -fdebug-module-writer option
+ - Add debug dump, measure-parse-tree and pre-fir-tree options
+ - Add -Xflang and make -test-io a frontend-only flang
+ - Add -J and -module-dir to f18 driver
+ - Fix -fdefault\* family bug
+- FIR (Fortran IR - a dialect of MLIR):
+ - Add diagnostic tests for FIR ops verifier
+ - Add FIR Types parser diagnostic tests
+ - Upstream the pre-FIR tree changes (The PFT has been updated to support Fortran 77)
+ - Update flang test tool support classes
+ - Add zero_bits, array value, and other operations
+ - Upstream utility function valueHasFirAttribute() to be used in subsequent merges
+- OpenMP - add semantic checks for:
+ - OpenMP 4.5 - 2.7.1 Do Loop restrictions for Threadprivate
+ - Occurrence of multiple list items in aligned clause for simd directive
+ - Flang OpenMP 4.5 - 2.15.3.6 Reduction clause
+ - 2.15.4.2 - Copyprivate clause
+ - 2.15.3.4 - Firstprivate clause
+ - 2.15.3.5 - Lastprivate clause
+- Update character tests to use gtest
+- Adaptations to MLIR API changes
+- Fix call to CHECK() on overriding an erroneous type-bound procedure
+- Handle type-bound procedures with alternate returns
+- Runtime: implement INDEX intrinsic function
+- Fix compilation on MinGW-w64
+- Extension: forward refs to dummy args under IMPLICIT NONE
+- Detect circularly defined interfaces of procedures
+- Implement the related character intrinsic functions SCAN and VERIFY
+
+Call notes will be sent to the _flang-dev_ email list and also recorded [here](https://docs.google.com/document/d/10T-S2J3GrahpG4Ooif93NSTz2zBW0MQc_RlwHi0-afY).
+
+### LFortran
+
+- LFortran is participating in GSoC under the NumFOCUS and Fortran-lang umbrella, if you are interested, please apply: [https://gitlab.com/lfortran/lfortran/-/wikis/GSoC-2021-Ideas](https://gitlab.com/lfortran/lfortran/-/wikis/GSoC-2021-Ideas)
+- 7 people contributed code in the last month:
+ [Gagandeep Singh](https://github.com/czgdp1807),
+ [Dominic Poerio](https://dompoer.io/),
+ [Himanshu Pandey](https://github.com/hp77-creator),
+ [Thirumalai Shaktivel](https://github.com/Thirumalai-Shaktivel),
+ [Scot Halverson](https://github.com/scothalverson),
+ [Rohit Goswami](https://rgoswami.me/),
+ [Ondřej Čertík](https://ondrejcertik.com/).
+- 114 Merge Requests were [merged](https://gitlab.com/lfortran/lfortran/-/merge_requests?scope=all&utf8=%E2%9C%93&state=merged) in the past month, highlights
+ - macOS support (both Intel and ARM), compilation and development of
+ LFortran itself (stacktraces work also)
+ - Initial implentation of: modules (modfiles, dependencies, ...),
+ interfaces, integer/real kinds, public/private attribute, derived types,
+ strings, variable initializations, pointers, modules
+ - Many other fixes
+
+LFortran is still in pre-alpha stage, but we are making rapid progress towards
+getting it to compile more Fortran features. We are looking for contributors,
+if you are interested, please get in touch and we will help you get started.
+We can be contacted at Zulip Chat, mailinglist or GitLab issues (see
+https://lfortran.org for links to all three).
+
+## Events
+
+- We had our 10th Fortran Monthly call on March 24.
+ You can watch the recording below:
+
+
+
+- This year Fortran-lang is a mentor organization for [Google Summer of Code](https://summerofcode.withgoogle.com/organizations/6633903353233408/).
+ If you're a student, or know students who are [eligible to participate](https://developers.google.com/open-source/gsoc/faq#what_are_the_eligibility_requirements_for_participation), and you'd like to help build the Fortran ecosystem please reach out and let us know.
+ The student application window opened on March 29 and will close on April 13 at 14:00 Eastern Time.
+
+- The 223rd meeting of the US Fortran Standards Committee concluded on March 2.
+ Main topics of dicussion were the planned changes for the Fortran 202X revision of the Standard.
+ Here's the [list of all submitted papers](https://j3-fortran.org/doc/meeting/223),
+ and the [summary](https://github.com/j3-fortran/fortran_proposals/issues/199)
+ of the papers discussed and voting results.
+ The committee also welcomed a new member, Milan Curcic ([@milancurcic](https://github.com/milancurcic)),
+ who is the voting alternate to Gary Klimowicz ([@gklimowicz](https://github.com/gklimowicz)).
+
+ If you have ideas for new improvements to the language, please propose them
+ [here](https://github.com/j3-fortran/fortran_proposals).
+
+- Registration is open for the upcoming free webinar on
+ [Fortran for High Performance Computing](https://register.gotowebinar.com/register/7343048137688004108).
+ The webinar is organized by [Excellerat](https://www.excellerat.eu/)
+ and will be presented by Wadud Miah ([@wadudmiah](https://github.com/wadudmiah)) from the University of Southampton.
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/04-20-First-Year.md.txt b/_sources/news/2021/04-20-First-Year.md.txt
new file mode 100644
index 000000000000..c8d4a3883650
--- /dev/null
+++ b/_sources/news/2021/04-20-First-Year.md.txt
@@ -0,0 +1,34 @@
+---
+category: newsletter
+date: 2021-04-20
+author: Ondřej Čertík, Milan Curcic, Brad Richardson, Laurence Kedward
+...
+
+# First year of the Fortran website
+
+In April 2020 we created a website for the Fortran language at
+[fortran-lang.org](https://fortran-lang.org/). In exactly one year, it grew to
+be the first result when you search "Fortran" in Bing, Yahoo, DuckDuckGo,
+Ecosia, Qwant, SearchEncrypt and the second result in Google (after the
+Wikipedia page for Fortran).
+
+The goal of the website is to maintain a neutral place where any Fortran user
+(expert or novice), compiler vendor (open source or commercial), Fortran
+Standards Committee member, enthusiast, supporter or anybody else interested
+is welcome to participate. Fortran was invented in 1956, and we aim to be the
+stewards of the language and we welcome you to join us.
+
+Here are some of the ways that you can participate:
+
+- [Fortran Discourse](https://fortran-lang.discourse.group/) discussion forum
+- Contribute to [fpm](https://github.com/fortran-lang/fpm/),
+ [stdlib](https://github.com/fortran-lang/stdlib/),
+ the [Fortran website](https://github.com/fortran-lang/fortran-lang.org) or
+ any other project
+- Join our monthly Fortran call (see announcements at Discourse)
+- Contribute to the Fortran monthly newsletter
+- Follow our Fortran Twitter account
+ [@fortranlang](https://twitter.com/fortranlang)
+
+Thank you everybody for your support so far. We are looking forward for the
+second year!
diff --git a/_sources/news/2021/05-01-Fortran-Newsletter-May-2021.md.txt b/_sources/news/2021/05-01-Fortran-Newsletter-May-2021.md.txt
new file mode 100644
index 000000000000..e9f64b3da08c
--- /dev/null
+++ b/_sources/news/2021/05-01-Fortran-Newsletter-May-2021.md.txt
@@ -0,0 +1,239 @@
+---
+category: newsletter
+date: 2021-05-01
+author: Sebastian Ehlert, Alexis Perry-Holby, Milan Curcic, Ondřej Čertík, Laurence Kedward
+...
+
+# Fortran newsletter: May 2021
+
+Welcome to the May 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#244](https://github.com/fortran-lang/fortran-lang.org/pull/244):
+ Add a first year announcement
+- [#236](https://github.com/fortran-lang/fortran-lang.org/pull/236):
+ Add dl_poly_4 to package index
+- [#220](https://github.com/fortran-lang/fortran-lang.org/pull/220):
+ Include learn resources to online courses
+
+Ongoing work:
+
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Internationalization for fortran-lang
+- [#246](https://github.com/fortran-lang/fortran-lang.org/pull/246) (WIP):
+ Transferring fortran90.org “Fortran Best Practise” into a mini-book
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in `stdlib`:
+
+- [#391](https://github.com/fortran-lang/stdlib/pull/391):
+ Add issue templates
+- [#388](https://github.com/fortran-lang/stdlib/pull/388):
+ Changed filenames for bitset tests
+- [#384](https://github.com/fortran-lang/stdlib/pull/384):
+ Implement starts_with and ends_with functions
+- [#367](https://github.com/fortran-lang/stdlib/pull/367):
+ Add Intel compiler workflow for OSX
+- [#360](https://github.com/fortran-lang/stdlib/pull/360):
+ Summarize build toolchain workflow and implied rules
+- [#343](https://github.com/fortran-lang/stdlib/pull/343):
+ Implement strip and chomp as supplement to trim
+- [#336](https://github.com/fortran-lang/stdlib/pull/336):
+ Add functions to convert integer/logical values to character values
+
+Work in progress:
+
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of sparse matrices.
+- [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP),
+ [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP),
+ [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP),
+ [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Implementation of the `stdlib_stats_distribution` modules.
+ It provides probability distribution and statistical functions.
+- [#311](https://github.com/fortran-lang/stdlib/pull/311) (WIP):
+ Implementation of a module for handling lists of strings
+- [#313](https://github.com/fortran-lang/stdlib/pull/313) (WIP):
+ Legendre polynomials and Gaussian quadrature
+- [#333](https://github.com/fortran-lang/stdlib/pull/333) (WIP):
+ Provide abstract base class for a string object
+- [#349](https://github.com/fortran-lang/stdlib/pull/349) (WIP):
+ Simplify test makefile
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#355](https://github.com/fortran-lang/stdlib/pull/355) (WIP):
+ Implement clip function
+- [#359](https://github.com/fortran-lang/stdlib/pull/359) (WIP):
+ Add general contributing guidelines to stdlib
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Add sort to stdlib_string_type module
+- [#372](https://github.com/fortran-lang/stdlib/pull/372) (WIP):
+ Correct implementation of to_title
+- [#386](https://github.com/fortran-lang/stdlib/pull/386) (WIP):
+ Start the addition of the module stdlib_sorting
+
+Please help improve stdlib by testing and [reviewing pull requests](https://github.com/fortran-lang/stdlib/issues?q=is%3Apr+is%3Aopen+label%3A%22reviewers+needed%22)!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in `fpm`:
+
+- [#420](https://github.com/fortran-lang/fpm/pull/420):
+ Phase out Haskell fpm
+- [#468](https://github.com/fortran-lang/fpm/pull/468):
+ Identify OpenBSD
+- [#465](https://github.com/fortran-lang/fpm/pull/465):
+ Fix typo in README
+- [#442](https://github.com/fortran-lang/fpm/pull/442):
+ Use lib instead of ar on Windows
+- [#440](https://github.com/fortran-lang/fpm/pull/440):
+ Minor edits to README
+- [#438](https://github.com/fortran-lang/fpm/pull/438):
+ Add external-modules key to build table for non-fpm modules
+- [#437](https://github.com/fortran-lang/fpm/pull/437):
+ Remove coarray single from default Intel flags
+- [#433](https://github.com/fortran-lang/fpm/pull/433):
+ Fix to allow compiling C with Intel CC
+- [#431](https://github.com/fortran-lang/fpm/pull/431):
+ Use different compiler flags on differnt platforms for Intel
+- [#429](https://github.com/fortran-lang/fpm/pull/429):
+ Use wget if curl is missing in install.sh
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP):
+ First feature-complete release of the Fortran implementation.
+- [#364](https://github.com/fortran-lang/fpm/pull/364) (WIP):
+ Plugin alpha version
+- [#423](https://github.com/fortran-lang/fpm/pull/423) (WIP):
+ Use default instead of master to reference the repository HEAD
+- [#444](https://github.com/fortran-lang/fpm/pull/444) (WIP):
+ Allow to find include files / modules in CPATH environment variable
+- [#449](https://github.com/fortran-lang/fpm/pull/449) (WIP):
+ Response files with ar on Windows
+- [#450](https://github.com/fortran-lang/fpm/pull/450) (WIP):
+ Remove coarray flag from intel debug settings
+- [#451](https://github.com/fortran-lang/fpm/pull/451) (WIP):
+ Refactor: use objects to represent compilers and archiver
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Classic Flang
+
+A total of 5 pull requests were merged in April.
+
+- [PR#1021 Switch to new LLVM License](https://github.com/flang-compiler/flang/pull/1021)
+- [PR#1025 runtime: register atfork handler to re-initialize internal flangrti locks at fork](https://github.com/flang-compiler/flang/pull/1025)
+- [PR#1026 Test case update for #895](https://github.com/flang-compiler/flang/pull/1026)
+- [PR#1030 Update README.md](https://github.com/flang-compiler/flang/pull/1030)
+- [PR#1034 Github Action use the prebuilt clang to build flang](https://github.com/flang-compiler/flang/pull/1034)
+
+### LLVM Flang
+
+Recent development updates:
+
+- OpenMP
+ - [OPENMP5.1]Initial support for novariants clause.
+ - [OPENMP5.1]Initial support for nocontext clause.
+ - Add functionality to check "close nesting" of regions, which can be used for Semantic checks
+ - [OpenMP5.1] Initial support for masked directive and filter clause
+ - Modify semantic check for nesting of `ordered` regions to include `close` nesting check.
+ - Remove `OmpEndLoopDirective` handles from code.
+ - Add General Semantic Checks for Allocate Directive
+- New Driver
+ - Add options for -Werror
+ - Modify the existing test cases that use -Mstandard in f18, to use -pedantic and %flang_fc1 to share with the new driver
+ - Add support for `-cpp/-nocpp`
+ - Fix `-fdebug-dump-provenance`
+ - Add debug options not requiring semantic checks
+ - Remove `%flang-new` from the LIT configuration
+ - Update the regression tests to use the new driver when enabled
+ - Add support for `-fget-definition`
+- Move .f77 to the list of fixed-form file extensions
+- Runtime
+ - Implement reductions
+ - Implement numeric intrinsic functions
+ - TRANSFER() intrinsic function
+ - RANDOM_NUMBER, RANDOM_SEED, RANDOM_INIT
+ - Implement IPARITY, PARITY, and FINDLOC reductions
+- Fix unit test failure on POWER
+- Improve constant folding for type parameter inquiries
+- Check for conflicting BIND(C) names
+- Enforce a limit on recursive PDT instantiations
+- Accept & fold IEEE_SELECTED_REAL_KIND
+- Define missing & needed IEEE_ARITHMETIC symbols
+- Handle instantiation of procedure pointer components
+- Fix checking of argument passing for parameterized derived types
+- Fix spurious errors from runtime derived type table construction
+- Check for attributes specific to dummy arguments
+- Handle structure constructors with forward references to PDTs
+
+Call notes will be sent to the _flang-dev_ email list and also recorded [here](https://docs.google.com/document/d/10T-S2J3GrahpG4Ooif93NSTz2zBW0MQc_RlwHi0-afY).
+
+### LFortran
+
+- 98 Merge Requests merged in April
+- Working towards compiling the [SNAP](https://github.com/lanl/SNAP) proxy app ([#313](https://gitlab.com/lfortran/lfortran/-/issues/313)):
+ - Code can be parsed to AST and transformed back to source code which compiles with other compilers and works
+ - About 3rd of the files can be transformed from AST to ASR and the modules saved
+- Other improvements:
+ - Runtime library (more functions work)
+ - Nested functions
+ - Derived types
+
+## Events
+
+- We had our 11th Fortran Monthly call on April 22.
+ You can watch the recording below:
+
+
+
+- Wadud Miah ([@wadudmiah](https://github.com/wadudmiah)) from the University of Southampton presented a webinar on Fortran for High Performance Computing, organized by [Excellerat](https://www.excellerat.eu/). You can find the slides and the recording [here](https://services.excellerat.eu/viewevent/39).
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/05-18-Welcome-GSoC-students.md.txt b/_sources/news/2021/05-18-Welcome-GSoC-students.md.txt
new file mode 100644
index 000000000000..a9e49cd9b4a7
--- /dev/null
+++ b/_sources/news/2021/05-18-Welcome-GSoC-students.md.txt
@@ -0,0 +1,43 @@
+---
+category: newsletter
+date: 2021-05-18
+author: Milan Curcic, Ondřej Čertík, Sebastian Ehlert, Laurence Kedward, Arjen Markus, Brad Richardson
+...
+
+# Fortran-lang welcomes new students to Google Summer of Code 2021
+
+We're happy to announce six students that will work on Fortran projects under
+the Google Summer of Code 2021 program:
+
+- [Aman Godara](https://github.com/aman-godara) will work on strings in the
+ [Fortran Standard Library](https://github.com/fortran-lang/stdlib). Aman's
+ mentors will be [Sebastian Ehlert](https://github.com/awvwgk) and
+ [Milan Curcic](https://github.com/milancurcic).
+- [Rohit Goswami](https://github.com/haozeke) will work on the
+ [LFortran](https://lfortran.org) compiler, specifically toward the capability
+ to compile a complex physics package. Rohit's mentor will be
+ [Ondřej Čertík](https://github.com/certik).
+- [Jakub Jelínek](https://github.com/kubajj) will work on handling compiler
+ arguments in the
+ [Fortran Package Manager](https://github.com/fortran-lang/fpm). Jakub's
+ mentors will be [Laurence Kedward](https://github.com/lkedward) and
+ [Brad Richardson](https://github.com/everythingfunctional).
+- [Chetan Karwa](https://github.com/chetankarwa) will work on the linked list
+ support in the
+ [Fortran Standard Library](https://github.com/fortran-lang/stdlib). Chetan's
+ mentors will be [Arjen Markus](https://github.com/arjenmarkus) and
+ [Milan Curcic](https://github.com/milancurcic).
+- [Thirumalai Shaktivel](https://gitlab.com/Thirumalai-Shaktivel) will work
+ on the Abstract Syntax Tree generation in the [LFortran](https://lfortran.org)
+ compiler. Thirumalai's mentor will be
+ [Ondřej Čertík](https://github.com/certik).
+- [Gagandeep Singh](https://github.com/czgdp1807) will work on the support
+ of arrays and allocatables in the [LFortran](https://lfortran.org) compiler.
+ Gagandeep's mentor will be [Ondřej Čertík](https://github.com/certik).
+ Gagandeep was accepted under the NumFOCUS application to GSoC.
+
+This is the first year that Fortran-lang applied for Google Summer of Code, and
+we're beyond excited that our project was allocated this many student slots.
+You can follow students' progress in their weekly reports in the [Fortran Discourse](https://fortran-lang.discourse.group/) forum.
+
+Thank you, Google, for your support of Fortran and open source software!
diff --git a/_sources/news/2021/06-01-Fortran-Newsletter-June-2021.md.txt b/_sources/news/2021/06-01-Fortran-Newsletter-June-2021.md.txt
new file mode 100644
index 000000000000..692143a2f58e
--- /dev/null
+++ b/_sources/news/2021/06-01-Fortran-Newsletter-June-2021.md.txt
@@ -0,0 +1,197 @@
+---
+category: newsletter
+date: 2021-06-01
+author: Sebastian Ehlert, Milan Curcic, Laurence Kedward, Ondřej Čertík
+...
+
+# Fortran newsletter: June 2021
+
+Welcome to the June 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#269](https://github.com/fortran-lang/fortran-lang.org/pull/269):
+ Grammar and typo fixes in main page and quickstart minibook
+- [#261](https://github.com/fortran-lang/fortran-lang.org/pull/261):
+ Script for summarizing PRs
+- [#259](https://github.com/fortran-lang/fortran-lang.org/pull/259):
+ MapTran3D, RPNcalc, Gemini3D and Blocktran were added to the package index
+- [#253](https://github.com/fortran-lang/fortran-lang.org/pull/253):
+ Fixed grammar in Easy to learn section
+
+Ongoing work:
+
+- [#255](https://github.com/fortran-lang/fortran-lang.org/pull/255) (WIP):
+ Quickstart edits
+- [#246](https://github.com/fortran-lang/fortran-lang.org/pull/246) (WIP):
+ Transferring fortran90.org “Fortran Best Practise” into a mini-book
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Internationalization for fortran-lang
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in `stdlib`:
+
+- [#417](https://github.com/fortran-lang/stdlib/pull/417):
+ Add GCC-11 to workflow
+- [#415](https://github.com/fortran-lang/stdlib/pull/415):
+ Corrected Ubuntu version
+- [#407](https://github.com/fortran-lang/stdlib/pull/407):
+ Changed to_title to to_sentence and implemented correct to_title
+- [#359](https://github.com/fortran-lang/stdlib/pull/359):
+ Add general contributing guidelines to stdlib
+- [#355](https://github.com/fortran-lang/stdlib/pull/355):
+ Implement clip function
+
+Work in progress:
+
+- [#420](https://github.com/fortran-lang/stdlib/pull/420) (WIP):
+ First implementation of real-valued linspace.
+- [#419](https://github.com/fortran-lang/stdlib/pull/419) (WIP):
+ Allow modification of install directory for module files
+- [#418](https://github.com/fortran-lang/stdlib/pull/418) (WIP):
+ Improved support for NAG
+- [#414](https://github.com/fortran-lang/stdlib/pull/414) (WIP):
+ Implemented intelligent slice functionality
+- [#408](https://github.com/fortran-lang/stdlib/pull/408) (WIP):
+ Addition of the stdlib_sorting module
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Add sort to stdlib_string_type module
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#333](https://github.com/fortran-lang/stdlib/pull/333) (WIP):
+ Provide abstract base class for a string object
+- [#313](https://github.com/fortran-lang/stdlib/pull/313) (WIP):
+ Legendre polynomials and Gaussian quadrature
+- [#311](https://github.com/fortran-lang/stdlib/pull/311) (WIP):
+ Implementation of a module for handling lists of strings
+- [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP),
+ [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP),
+ [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP),
+ [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Implementation of the `stdlib_stats_distribution` modules.
+ It provides probability distribution and statistical functions.
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of sparse matrices.
+
+Please help improve stdlib by testing and [reviewing pull requests](https://github.com/fortran-lang/stdlib/issues?q=is%3Apr+is%3Aopen+label%3A%22reviewers+needed%22)!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here is what is new in _fpm_:
+
+- [#450](https://github.com/fortran-lang/fpm/pull/450):
+ Remove coarray flag from intel debug settings
+- [#423](https://github.com/fortran-lang/fpm/pull/423):
+ Use default instead of master to reference the repository HEAD
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP):
+ First feature-complete release of the Fortran implementation.
+- [#483](https://github.com/fortran-lang/fpm/pull/483) (WIP):
+ Allow fpm to change the working directory
+- [#451](https://github.com/fortran-lang/fpm/pull/451) (WIP):
+ Refactor: use objects to represent compilers and archiver
+- [#449](https://github.com/fortran-lang/fpm/pull/449) (WIP):
+ Response files with ar on Windows
+- [#444](https://github.com/fortran-lang/fpm/pull/444) (WIP):
+ Allow to find include files / modules in CPATH environment variable
+- [#364](https://github.com/fortran-lang/fpm/pull/364) (WIP):
+ Plugin alpha version
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### LFortran
+
+- 39 Merge Requests [merged](https://gitlab.com/lfortran/lfortran/-/merge_requests?scope=all&state=merged)
+- Features that can now be compiled (in the LLVM backend):
+ - More nested functions and callbacks (the context is properly propagated)
+ - Runtime: size, lbound, ubound
+ - Return statement
+ - More array operations and declarations
+ - Array initializer expressions
+- Features in ASR only (semantics):
+ - Runtime intrinsics: min, max, allocated
+- Features in AST only (syntax):
+ - Co-arrays
+ - Methods
+ - Enumerations
+ - Attributes in `use`
+ - BOZ constants
+ - Forall
+ - More interfaces
+ - Import
+ - Implicit statements
+ - Select type
+
+The following people contributed code in May 2021:
+
+- Gagandeep Singh ([@czgdp1807](https://github.com/czgdp1807))
+- Thirumalai Shaktivel ([@Thirumalai-Shaktivel](https://github.com/Thirumalai-Shaktivel))
+- Ondřej Čertík ([@certik](https://github.com/certik))
+- Dominic Poerio ([@dpoe](https://gitlab.com/dpoe))
+
+## Events
+
+- We had our 12th Fortran Monthly call on May 20.
+ You can watch the recording below:
+
+
+
+- Google Summer of Code program has announced the allocation of students to each project.
+ Fortran-lang received six studens (one through [NumFOCUS](https://numfocus.org/)) who will work across three subprojects: stdlib, fpm, and LFortran.
+ Congratulations and welcome to students
+ [Aman Godara](https://github.com/aman-godara),
+ [Rohit Goswami](https://github.com/haozeke),
+ [Jakub Jelínek](https://github.com/kubajj),
+ [Chetan Karwa](https://github.com/chetankarwa),
+ [Thirumalai Shaktivel](https://gitlab.com/Thirumalai-Shaktivel), and
+ [Gagandeep Singh](https://github.com/czgdp1807).
+ Read the full post [here](https://fortran-lang.org/newsletter/2021/05/18/Welcome-GSoC-students/).
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/07-01-Fortran-Newsletter-July-2021.md.txt b/_sources/news/2021/07-01-Fortran-Newsletter-July-2021.md.txt
new file mode 100644
index 000000000000..1d8839652396
--- /dev/null
+++ b/_sources/news/2021/07-01-Fortran-Newsletter-July-2021.md.txt
@@ -0,0 +1,214 @@
+---
+category: newsletter
+date: 2021-07-01
+author: Laurence Kedward, Sebastian Ehlert, Ondřej Čertík, Zachary Moon, Milan Curcic
+...
+
+## Fortran newsletter: July 2021
+
+Welcome to the July 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#276](https://github.com/fortran-lang/fortran-lang.org/pull/276):
+ Add LATTE tight-binding molecular dynamics code to package index
+- [#275](https://github.com/fortran-lang/fortran-lang.org/pull/275):
+ Add crest program to package index
+- [#255](https://github.com/fortran-lang/fortran-lang.org/pull/255):
+ Quickstart edits
+- [#273](https://github.com/fortran-lang/fortran-lang.org/pull/273):
+ Add the SNaC package to package index
+- [#272](https://github.com/fortran-lang/fortran-lang.org/pull/272):
+ Add QUICK to package index
+
+Ongoing work:
+
+- [#277](https://github.com/fortran-lang/fortran-lang.org/pull/277) (WIP):
+ Add projects for Fortran-lua interfacing to package index
+- [#274](https://github.com/fortran-lang/fortran-lang.org/pull/274) (WIP):
+ Add convert_FORTRAN_case formatter to package index
+- [#246](https://github.com/fortran-lang/fortran-lang.org/pull/246) (WIP):
+ Transferring fortran90.org "Fortran Best Practices" into a mini-book
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Draft: Internationalization for fortran-lang
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in `stdlib`:
+
+- [#313](https://github.com/fortran-lang/stdlib/pull/313):
+ Legendre polynomials and gaussian quadrature
+- [#432](https://github.com/fortran-lang/stdlib/pull/432):
+ Outer product
+- [#439](https://github.com/fortran-lang/stdlib/pull/439):
+ Reduce time spent on sorting tests
+- [#440](https://github.com/fortran-lang/stdlib/pull/440):
+ Make maximum rank an option
+- [#433](https://github.com/fortran-lang/stdlib/pull/433):
+ Implemented low level find function for string matching
+- [#414](https://github.com/fortran-lang/stdlib/pull/414):
+ Implemented intelligent slice functionality
+- [#428](https://github.com/fortran-lang/stdlib/pull/428):
+ Fix issue with stdlib_sorting
+- [#419](https://github.com/fortran-lang/stdlib/pull/419):
+ Allow modification of install directory for module files
+- [#430](https://github.com/fortran-lang/stdlib/pull/430):
+ Remove support for GCC 7 and 8
+- [#424](https://github.com/fortran-lang/stdlib/pull/424):
+ Add separate logical kind parameters
+
+Work in progress:
+
+- [#445](https://github.com/fortran-lang/stdlib/pull/445) (WIP):
+ Add `disp` function to display your data
+- [#444](https://github.com/fortran-lang/stdlib/pull/444) (WIP):
+ Add `format_string` to format other type to string
+- [#441](https://github.com/fortran-lang/stdlib/pull/441) (WIP):
+ Implement pad function
+- [#437](https://github.com/fortran-lang/stdlib/pull/437) (WIP):
+ [FPM] add fpm support
+- [#436](https://github.com/fortran-lang/stdlib/pull/436) (WIP):
+ Implement low-level replace_all function
+- [#426](https://github.com/fortran-lang/stdlib/pull/426) (WIP):
+ Addition of a subroutine to compute the median of array elements
+- [#420](https://github.com/fortran-lang/stdlib/pull/420) (WIP):
+ First implementation of real-valued linspace.
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Sorting string's characters according to their ASCII values
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#333](https://github.com/fortran-lang/stdlib/pull/333) (WIP):
+ Provide abstract base class for a string object
+- [#311](https://github.com/fortran-lang/stdlib/pull/311) (WIP):
+ String list new
+- [#286](https://github.com/fortran-lang/stdlib/pull/286) (WIP):
+ Probability Distribution and Statistical Functions -- Beta Distribution Module
+- [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Probability Distribution and Statistical Functions -- Gamma Distribution Module
+- [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP):
+ Probability Distribution and Statistical Functions -- Exponential Distribution Module
+- [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP):
+ Probability Distribution and Statistical Functions -- Normal Distribution Module
+- [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP):
+ Probability Distribution and Statistical Functions -- Uniform Distribution Module
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of COO / CSR sparse format
+- [#157](https://github.com/fortran-lang/stdlib/pull/157) (WIP):
+ Update CMAKE files
+
+Please help improve stdlib by testing and [reviewing pull requests](https://github.com/fortran-lang/stdlib/issues?q=is%3Apr+is%3Aopen+label%3A%22reviewers+needed%22)!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+**Alpha release update:** Last month saw the release of **v0.3.0** for _fpm_ which includes a number of [new features and bug fixes](https://github.com/fortran-lang/fpm/releases/tag/v0.3.0).
+
+Here is what is new in _fpm_:
+
+- [#504](https://github.com/fortran-lang/fpm/pull/504):
+ install.sh, README.md: Update version number, single source file extension
+- [#501](https://github.com/fortran-lang/fpm/pull/501):
+ Bump version for new release
+- [#491](https://github.com/fortran-lang/fpm/pull/491):
+ Catch execute_command_line errors and print useful messages
+- [#500](https://github.com/fortran-lang/fpm/pull/500):
+ Allow reading version number from file
+- [#497](https://github.com/fortran-lang/fpm/pull/497):
+ correct for equal sign in flag options to fix #495
+- [#449](https://github.com/fortran-lang/fpm/pull/449):
+ Response files with ar on Windows
+- [#490](https://github.com/fortran-lang/fpm/pull/490):
+ Minor fix to module parsing
+- [#489](https://github.com/fortran-lang/fpm/pull/489):
+ Redirect output when searching for archiver
+- [#484](https://github.com/fortran-lang/fpm/pull/484):
+ Add support for invoking simple plugins
+- [#483](https://github.com/fortran-lang/fpm/pull/483):
+ Allow fpm to change the working directory
+
+Work in progress:
+
+- [First beta release](https://github.com/fortran-lang/fpm/milestone/1) (WIP):
+ First feature-complete release of the Fortran implementation.
+- [#505](https://github.com/fortran-lang/fpm/pull/505) (WIP):
+ quiet mode for #502
+- [#498](https://github.com/fortran-lang/fpm/pull/498) (WIP):
+ Draft - Compiler flags profiles
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### LFortran
+
+- 49 Merge Requests [merged](https://gitlab.com/lfortran/lfortran/-/merge_requests?scope=all&state=merged)
+- Highlights
+ - Improvements to array support in the LLVM backend and at the ASR level:
+ array sections, allocatable arrays, and other improvements
+ - Many parser fixes (`lfortran fmt` works on more projects): block data,
+ common block, equivalence, custom operator declaration, flush, critical and
+ event statements
+ - More runtime functions: minval, maxval, real, sum, abs
+ - Optional human readable mod files
+
+## Events
+
+- We had our 13th Fortran Monthly call on June 15.
+ You can watch the recording below:
+
+
+
+- Joint J3/WG5 (Fortran Standards Committees) meeting was held virtually from June 21-30 (Mondays and Wednesdays only). You can find all the papers that were discussed [here](https://j3-fortran.org/doc/meeting/224). Highlights from the meeting:
+
+ - Conditional expressions syntax for Fortran 202X ([paper](https://j3-fortran.org/doc/year/21/21-157r2.txt)).
+ - Protected components specifications and syntax for Fortran 202X ([paper](https://j3-fortran.org/doc/year/21/21-168.txt)).
+ - The generics feature planned for Fortran 202Y was discussed at depth ([paper](https://j3-fortran.org/doc/year/21/21-144r4.txt)).
+ - Jeff Hammond (NVidia Corporation) is the new J3 member as a voting alternate to Bryce Adelstein-Lelbach.
+ - Target year for Fortran 202X is 2023, subject to change.
+
+- FortranCon 2021 will be held virtually from September 23-24, 2021. For more information, visit the [FortranCon website](https://tcevents.chem.uzh.ch/event/14/).
+
+- Work has started for our Google Summer of Code program. You read about our students and their progress so far on Discourse:
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/08-01-Fortran-Newsletter-August-2021.md.txt b/_sources/news/2021/08-01-Fortran-Newsletter-August-2021.md.txt
new file mode 100644
index 000000000000..24e88bfd5cc3
--- /dev/null
+++ b/_sources/news/2021/08-01-Fortran-Newsletter-August-2021.md.txt
@@ -0,0 +1,237 @@
+---
+category: newsletter
+date: 2021-08-01
+author: Milan Curcic, Ondřej Čertík, Laurence Kedward
+...
+
+# Fortran newsletter: August 2021
+
+Welcome to the August 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#281](https://github.com/fortran-lang/fortran-lang.org/pull/281):
+ July newsletter
+- [#274](https://github.com/fortran-lang/fortran-lang.org/pull/274):
+ Add `convert_FORTRAN_case` formatter to package index
+- [#277](https://github.com/fortran-lang/fortran-lang.org/pull/277):
+ Add projects for Fortran-lua interfacing to package index
+- [#284](https://github.com/fortran-lang/fortran-lang.org/pull/284):
+ PRs script updates
+- [#286](https://github.com/fortran-lang/fortran-lang.org/pull/286):
+ Installation process for GFortran on OpenBSD
+- [#288](https://github.com/fortran-lang/fortran-lang.org/pull/288):
+ Add Flatiron institute multipole libraries to the package index
+- [#289](https://github.com/fortran-lang/fortran-lang.org/pull/289):
+ Small fix in packages index
+- [#291](https://github.com/fortran-lang/fortran-lang.org/pull/291):
+ Bump addressable from 2.7.0 to 2.8.0
+- [#293](https://github.com/fortran-lang/fortran-lang.org/pull/293):
+ add Apogee and Edinburgh compilers
+- [#290](https://github.com/fortran-lang/fortran-lang.org/pull/290):
+ Add arrayfire-fortran to package index
+- [#294](https://github.com/fortran-lang/fortran-lang.org/pull/294):
+ compilers: use more objective tone
+- [#296](https://github.com/fortran-lang/fortran-lang.org/pull/296):
+ my software with at least 5 stars
+- [#297](https://github.com/fortran-lang/fortran-lang.org/pull/297):
+ Fix insecure workflow.
+
+Ongoing work:
+
+- [#246](https://github.com/fortran-lang/fortran-lang.org/pull/246) (WIP):
+ Transferring fortran90.org "Fortran Best Practices" into a mini-book
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Draft: Internationalization for fortran-lang
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in stdlib:
+
+- [#436](https://github.com/fortran-lang/stdlib/pull/436):
+ implemented low-level `replace_all` function
+- [#454](https://github.com/fortran-lang/stdlib/pull/454):
+ added `stdlib_math` to specs/index.md
+- [#453](https://github.com/fortran-lang/stdlib/pull/453):
+ implemented count function
+- [#441](https://github.com/fortran-lang/stdlib/pull/441):
+ implemented pad function
+- [#456](https://github.com/fortran-lang/stdlib/pull/456):
+ slice function's documentation made user friendly
+- [#459](https://github.com/fortran-lang/stdlib/pull/459):
+ Fix CMake variable usage
+- [#420](https://github.com/fortran-lang/stdlib/pull/420):
+ First implementation of real-valued linspace.
+- [#468](https://github.com/fortran-lang/stdlib/pull/468):
+ Update CI
+- [#469](https://github.com/fortran-lang/stdlib/pull/469):
+ CMake: corrections and updates
+- [#426](https://github.com/fortran-lang/stdlib/pull/426):
+ Addition of a subroutine to compute the median of array elements
+- [#474](https://github.com/fortran-lang/stdlib/pull/474):
+ Bug fix: Allocatable argument 'x' is not allocated #472
+
+Work in progress:
+
+- [#481](https://github.com/fortran-lang/stdlib/pull/481) (WIP):
+ [`stdlib_linalg`] Update eye function.
+- [#480](https://github.com/fortran-lang/stdlib/pull/480) (WIP):
+ [`stdlib_math`] Add seq function.
+- [#478](https://github.com/fortran-lang/stdlib/pull/478) (WIP):
+ [`stdlib_linalg`] Add zeros, ones, ex function.
+- [#477](https://github.com/fortran-lang/stdlib/pull/477) (WIP):
+ [`stdlib_linalg`] Add empty function.
+- [#475](https://github.com/fortran-lang/stdlib/pull/475) (WIP):
+ Generating sorting subroutines specific to character type with fypp
+- [#473](https://github.com/fortran-lang/stdlib/pull/473) (WIP):
+ Error stop improvements
+- [#470](https://github.com/fortran-lang/stdlib/pull/470) (WIP):
+ Revival string list
+- [#467](https://github.com/fortran-lang/stdlib/pull/467) (WIP):
+ implemented `move_alloc` for `string_type`
+- [#455](https://github.com/fortran-lang/stdlib/pull/455) (WIP):
+ `stdlib_hash`: waterhash algorithm
+- [#452](https://github.com/fortran-lang/stdlib/pull/452) (WIP):
+ Implementation of a map data type
+- [#445](https://github.com/fortran-lang/stdlib/pull/445) (WIP):
+ [feature] `disp`(display your data) & `format_string`(format other type to string, see #444)
+- [#444](https://github.com/fortran-lang/stdlib/pull/444) (WIP):
+ Add `format_string` routine to format other types to strings
+- [#437](https://github.com/fortran-lang/stdlib/pull/437) (WIP):
+ [FPM] add fpm support
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Sorting string's characters according to their ASCII values
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#286](https://github.com/fortran-lang/stdlib/pull/286) (WIP):
+ Probability Distribution and Statistical Functions -- Beta Distribution Module
+- [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Probability Distribution and Statistical Functions -- Gamma Distribution Module
+- [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP):
+ Probability Distribution and Statistical Functions -- Exponential Distribution Module
+- [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP):
+ Probability Distribution and Statistical Functions -- Normal Distribution Module
+- [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP):
+ Probability Distribution and Statistical Functions -- Uniform Distribution Module
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of COO / CSR sparse format
+- [#157](https://github.com/fortran-lang/stdlib/pull/157) (WIP):
+ Update CMAKE files
+
+Please help improve stdlib by testing and [reviewing pull requests](https://github.com/fortran-lang/stdlib/issues?q=is%3Apr+is%3Aopen+label%3A%22reviewers+needed%22)!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in fpm:
+
+- [#507](https://github.com/fortran-lang/fpm/pull/507):
+ optimize file listing
+- [#511](https://github.com/fortran-lang/fpm/pull/511):
+ check name used for package, executable, test, or example
+- [#516](https://github.com/fortran-lang/fpm/pull/516):
+ initialize allocatable strings before using in a comparison
+- [#517](https://github.com/fortran-lang/fpm/pull/517):
+ Fix run
+- [#522](https://github.com/fortran-lang/fpm/pull/522):
+ remove warnings and fix truncated help text
+- [#523](https://github.com/fortran-lang/fpm/pull/523):
+ Fix compilation error in ifort
+
+Work in progress:
+
+- [#525](https://github.com/fortran-lang/fpm/pull/525) (WIP):
+ proposal to close #525 by generating build/.gitignore
+- [#527](https://github.com/fortran-lang/fpm/pull/527) (WIP):
+ Add objects for handling compiler and archiver
+- [#521](https://github.com/fortran-lang/fpm/pull/521) (WIP):
+ expand tabs
+- [#506](https://github.com/fortran-lang/fpm/pull/506) (WIP):
+ Draft: initial implementation of `implicit_none`
+- [#498](https://github.com/fortran-lang/fpm/pull/498) (WIP):
+ Draft - Compiler flags profiles
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### LFortran
+
+Updates for July 2021:
+
+- 90 [merged](https://gitlab.com/lfortran/lfortran/-/merge_requests?scope=all&state=merged) MRs, this month we have crossed 1000 total merged MRs, 12 total contributors
+- Parser: we asked the community to test it, several people have reported about
+ 15 bugs, we have fixed all of them (AST)
+- Initial fixed form parser (AST)
+- Classes and class procedures (ASR, LLVM)
+- Many common array usage now works, including allocatable (ASR, LLVM)
+- Associate construct (ASR, LLVM)
+- Compile time evaluation of constant expressions (ASR)
+- 7 people contributed code:
+ - Ondřej Čertík
+ - Thirumalai Shaktivel
+ - Gagandeep Singh
+ - Rohit Goswami
+ - Dominic Poerio
+ - Andrew Best
+ - Sebastian Ehlert
+
+We are looking for new contributors, so if you are interested, please [get in
+touch with us](https://lfortran.org/)!
+
+## Events
+
+- We had our 14th Fortran Monthly call on July 20.
+ You can watch the recording below:
+
+
+
+- FortranCon 2021 will be held virtually from September 23-24, 2021.
+ Registration is free of charge and is due by September 15.
+ The first call for abstracts is due August 1, and the second is due September 1.
+ For more information, visit the [FortranCon website](https://tcevents.chem.uzh.ch/event/14/).
+
+- Work is well under way started for our Google Summer of Code program. Read about our students and their progress so far on Discourse:
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/09-01-Fortran-Newsletter-September-2021.md.txt b/_sources/news/2021/09-01-Fortran-Newsletter-September-2021.md.txt
new file mode 100644
index 000000000000..f3f2acc986bd
--- /dev/null
+++ b/_sources/news/2021/09-01-Fortran-Newsletter-September-2021.md.txt
@@ -0,0 +1,308 @@
+---
+category: newsletter
+date: 2021-09-01
+author: Milan Curcic, Alexis Perry-Holby, Sebastian Ehlert, Ondřej Čertík
+...
+
+# Fortran newsletter: September 2021
+
+Welcome to the September 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#303](https://github.com/fortran-lang/fortran-lang.org/pull/303):
+ Add NJOY to package index
+
+### Work in progress
+
+- [#302](https://github.com/fortran-lang/fortran-lang.org/pull/302) (WIP):
+ Update Silverfrost compiler description.
+- [#300](https://github.com/fortran-lang/fortran-lang.org/pull/300) (WIP):
+ Add QCxMS to package index
+- [#246](https://github.com/fortran-lang/fortran-lang.org/pull/246) (WIP):
+ Transferring fortran90.org "Fortran Best Practices" into a mini-book
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Internationalization for fortran-lang
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues) if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the [contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md) for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in stdlib:
+
+- [#467](https://github.com/fortran-lang/stdlib/pull/467):
+ Implemented move_alloc for string_type
+- [#470](https://github.com/fortran-lang/stdlib/pull/470):
+ Revival string list
+- [#481](https://github.com/fortran-lang/stdlib/pull/481):
+ [stdlib_linalg] Update eye function.
+- [#493](https://github.com/fortran-lang/stdlib/pull/493):
+ Update copyright and remove old artifact
+- [#444](https://github.com/fortran-lang/stdlib/pull/444):
+ Add format_string routine to format other types to strings
+- [#483](https://github.com/fortran-lang/stdlib/pull/483):
+ Remove GCC Fortran MinGW 8.4.0 from known to work list
+
+### Work in progress
+
+- [#501](https://github.com/fortran-lang/stdlib/pull/501) (WIP):
+ Minor updates to README.md
+- [#500](https://github.com/fortran-lang/stdlib/pull/500) (WIP):
+ Selection algorithms
+- [#499](https://github.com/fortran-lang/stdlib/pull/499) (WIP):
+ [stdlib_linalg] matrix property checks
+- [#498](https://github.com/fortran-lang/stdlib/pull/498) (WIP):
+ [stdlib_math] add `arg/argd/argpi`
+- [#494](https://github.com/fortran-lang/stdlib/pull/494) (WIP):
+ Add testing module to allow better structuring of test suites
+- [#491](https://github.com/fortran-lang/stdlib/pull/491) (WIP):
+ Stdlib linked list
+- [#488](https://github.com/fortran-lang/stdlib/pull/488) (WIP):
+ [stdlib_math] add `is_close` routines.
+- [#478](https://github.com/fortran-lang/stdlib/pull/478) (WIP):
+ [stdlib_linalg] Add zeros, ones function.
+- [#475](https://github.com/fortran-lang/stdlib/pull/475) (WIP):
+ Generating sorting subroutines specific to `character` type with fypp
+- [#473](https://github.com/fortran-lang/stdlib/pull/473) (WIP):
+ Error stop improvements
+- [#455](https://github.com/fortran-lang/stdlib/pull/455) (WIP):
+ stdlib_hash: waterhash algorithm
+- [#452](https://github.com/fortran-lang/stdlib/pull/452) (WIP):
+ Implementation of a map data type
+- [#445](https://github.com/fortran-lang/stdlib/pull/445) (WIP):
+ [stdlib_io] `disp`(display your data)
+- [#437](https://github.com/fortran-lang/stdlib/pull/437) (WIP):
+ [FPM] add fpm support
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Sorting string's characters according to their ASCII values
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#286](https://github.com/fortran-lang/stdlib/pull/286) (WIP):
+ Probability Distribution and Statistical Functions -- Beta Distribution Module
+- [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Probability Distribution and Statistical Functions -- Gamma Distribution Module
+- [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP):
+ Probability Distribution and Statistical Functions -- Exponential Distribution Module
+- [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP):
+ Probability Distribution and Statistical Functions -- Normal Distribution Module
+- [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP):
+ Probability Distribution and Statistical Functions -- Uniform Distribution Module
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of COO / CSR sparse format
+
+Please help improve stdlib by testing and [reviewing pull requests](https://github.com/fortran-lang/stdlib/issues?q=is%3Apr+is%3Aopen+label%3A%22reviewers+needed%22)!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in fpm:
+
+- [Version 0.4.0](https://github.com/fortran-lang/fpm/releases/tag/v0.4.0):
+ Alpha release update
+- [#546](https://github.com/fortran-lang/fpm/pull/546):
+ Update version for release 0.4.0
+- [#548](https://github.com/fortran-lang/fpm/pull/548):
+ Fix build on MacOS/ARM64
+- [#527](https://github.com/fortran-lang/fpm/pull/527):
+ Add objects for handling compiler and archiver
+- [#536](https://github.com/fortran-lang/fpm/pull/536):
+ Always call `git init` in fpm new when backfilling
+- [#533](https://github.com/fortran-lang/fpm/pull/533):
+ Allow extra section in package manifest
+- [#528](https://github.com/fortran-lang/fpm/pull/528):
+ Generate `build/.gitignore`
+
+### Work in progress
+
+- [#539](https://github.com/fortran-lang/fpm/pull/539) (WIP):
+ Add parent packages into dependency tree
+- [#521](https://github.com/fortran-lang/fpm/pull/521) (WIP):
+ Expand tabs in source parsing
+- [#506](https://github.com/fortran-lang/fpm/pull/506) (WIP):
+ Initial implementation of implicit_none
+- [#498](https://github.com/fortran-lang/fpm/pull/498) (WIP):
+ Compiler flags profiles
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md) to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md) to learn what are all the things that you can specify in the fpm.toml file.
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## FFTPACK
+
+Zuo Zhihua ([@zoziha](https://github.com/zoziha)) and Ondřej Čertík ([@certik](https://github.com/certik)) started maintaining the public domain project FFTPACK under the Fortran-lang namespace.
+The project is readily available for usage in with fpm.
+
+Here is what is new in FFTPACK:
+
+- [#10](https://github.com/fortran-lang/fftpack/pull/10):
+ Add `(i)qct/dcosqi/dcosqf/dcosqb` interfaces for quarter wave data.
+- [#7](https://github.com/fortran-lang/fftpack/pull/7):
+ Add `dzffti/dzfftf/dzfftb` interfaces
+- [#4](https://github.com/fortran-lang/fftpack/pull/4):
+ Improve fft interface for `complex` sequences: `(i)fft/zffti/zfftf/zfftb`
+- [#6](https://github.com/fortran-lang/fftpack/pull/6):
+ Add `(i)rfft/dffti/dfftf/dfftb` interface and ready to move to `fortran-lang`
+- [#5](https://github.com/fortran-lang/fftpack/pull/5):
+ Add `fftshift/ifftshift`
+- [#3](https://github.com/fortran-lang/fftpack/pull/3):
+ Add CI: fpm.yml
+
+### Work in progress
+
+- [#11](https://github.com/fortran-lang/fftpack/pull/11) (WIP):
+ Add `(i)dct/dcosti/dcost` interfaces.
+
+Feedback and ideas for this project are welcome.
+
+## Compilers
+
+### Flang
+
+Recent development updates:
+
+- New Driver and CMake integration:
+ - The new driver has replaced the old, hence f18 has been deleted.
+ - flang-new (aka. the new driver) now drives the flang bash script before an external compiler is called.
+ - Code-generation work is ongoing.
+ - Work is now proceeding to enable CMake to recognize the compiler and set the appropriate options for build configurations.
+- FIR (Fortran IR - a dialect of MLIR):
+ - Fortran 95 lowering and runtime support is nearing completion, particularly of intrinsics
+ - Code upstreaming will begin again in earnest once F95 is deemed complete
+- OpenMP
+ - Nesting of region semantic checks
+ - enter_data MLIR to LLVM IR lowering
+ - Semantic checks for allocate directive
+ - Lowering for various modifiers for the schedule clause
+ - Pretty printer and parser for omp.target operation
+ - Semantic checks for linear, nested barrier, allocate directive
+ - Progress with firstprivate, critical, collapse, ordered, reduction
+- Lift -Werror checks into local functions
+- Document the flang wrapper script
+- Fix the extent calculation when upper bounds are less than lower bounds
+- Fix list-directed plural repeated null values at end of record
+- Fix build failure on MacOS involving std::clock_t
+- Fix error messages on Windows.
+- Disable Plugins in out-of-tree builds
+- Correct off-by-one error in SET_EXPONENT
+
+Call notes are recorded and available upon request [here](https://docs.google.com/document/d/10T-S2J3GrahpG4Ooif93NSTz2zBW0MQc_RlwHi0-afY). Please contact Alexis Perry-Holby at aperry@lanl.gov for document access.
+
+### LFortran
+
+- 168
+ [merged](https://gitlab.com/lfortran/lfortran/-/merge_requests?scope=all&state=merged)
+ Merge Requests in August 2021
+- The following people have contributed code to LFortran in August:
+ - Ondřej Čertík
+ - Thirumalai Shaktivel
+ - Rohit Goswami
+ - Gagandeep Singh
+ - Andrew Best
+ - Carlos Une
+- Sebastian Ehlert got LFortran working with fpm
+- Many people have reported bugs (thank you all!)
+- Our 3 Google Summer of Code (GSoC) students have successfully finished their
+ projects. Here are their final reports:
+ - Gagandeep Singh: [https://czgdp1807.github.io/2021/08/16/z_final_report.html](https://czgdp1807.github.io/2021/08/16/z_final_report.html)
+ - Thirumalai Shaktivel: [https://gist.github.com/Thirumalai-Shaktivel/c2a1aaa5239e792e499eaa8942987519](https://gist.github.com/Thirumalai-Shaktivel/c2a1aaa5239e792e499eaa8942987519)
+ - Rohit Goswami: [https://rgoswami.me/posts/gsoc21-fin-reprot/](https://rgoswami.me/posts/gsoc21-fin-reprot/)
+
+#### LFortran 0.12.0 was released on August 15
+
+Changes since the last release.
+
+- Fixed all issues in the parser that were reported (AST)
+ - multiple loop single end do
+ - arithmetic if
+- Comments and empty lines are now represented in AST and formatted correctly (AST)
+- The formatter (`lfortran fmt`) now uses the minimal amount of parentheses in expressions
+- Initial fixed-form parser (AST)
+- Initial class support (ASR, LLVM)
+- Allocate / deallocate, allocatable arrays (ASR, LLVM)
+- Associate block (ASR, LLVM)
+- Runtime library refactoring (ASR, LLVM)
+ - Split into builtin, pure and impure
+ - `iso_fortran_env`, `iso_c_binding` intrinsic modules added
+- Compile time evaluation (ASR, LLVM)
+
+Commits (`git shortlog -ns v0.11.0..v0.12.0`):
+
+```
+ 369 Ondřej Čertík
+ 85 Thirumalai Shaktivel
+ 79 Gagandeep Singh
+ 75 Rohit Goswami
+ 20 Andrew Best
+ 4 Dominic Poerio
+```
+
+#### Updates in master since the last release:
+
+- LFortran can now compile binaries on Windows
+- C interoperation works on all platforms (including Windows and MSVC)
+- Runtime library improvements
+ - Complex intrinsics fixed on all platforms
+ - All trigonometric functions now use the Fortran `impure` interface in the runtime library
+ - More intrinsics implemented
+- Initial implementation of classes and methods
+- LFortran now works with `fpm` and compiles the hello world project and a few other example projects
+- Parser improvements: team and sync statements
+- Improved handling of character types as function arguments and return values
+
+We are looking for new contributors, so if you are interested, please [get in
+touch with us](https://lfortran.org/)! We would be happy to do a video call
+with you to get you started.
+
+## Events
+
+- We had our 15th Fortran Monthly call on August 17.
+ You can watch the recording below:
+
+
+- FortranCon 2021 will be held virtually from September 23-24, 2021.
+ Registration is free of charge and is due by September 15.
+ The second call for abstracts is due September 1.
+ For more information, visit the [FortranCon website](https://tcevents.chem.uzh.ch/event/14/).
+
+- Our Google Summer of Code program for 2021 is coming to a close.
+ Read about our students and their progress so far on Discourse:
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [fortran-lang/fftpack](https://github.com/fortran-lang/fftpack)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/10-01-Fortran-Newsletter-October-2021.md.txt b/_sources/news/2021/10-01-Fortran-Newsletter-October-2021.md.txt
new file mode 100644
index 000000000000..6d9affcbfc44
--- /dev/null
+++ b/_sources/news/2021/10-01-Fortran-Newsletter-October-2021.md.txt
@@ -0,0 +1,315 @@
+---
+category: newsletter
+date: 2021-10-01
+author: Laurence Kedward, Alexis Perry-Holby, Ondřej Čertík
+...
+
+# Fortran newsletter: October 2021
+
+Welcome to the October 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#305](https://github.com/fortran-lang/fortran-lang.org/pull/305):
+ September newsletter draft
+- [#300](https://github.com/fortran-lang/fortran-lang.org/pull/300):
+ Add QCxMS to package index
+- [#302](https://github.com/fortran-lang/fortran-lang.org/pull/302):
+ Update Silverfrost compiler description.
+- [#307](https://github.com/fortran-lang/fortran-lang.org/pull/307):
+ Fixed typo
+- [#308](https://github.com/fortran-lang/fortran-lang.org/pull/308):
+ remove excess 'mpi' tag from fortran2018-examples
+- [#246](https://github.com/fortran-lang/fortran-lang.org/pull/246):
+ Transferring fortran90.org "Fortran Best Practices" into a mini-book
+- [#314](https://github.com/fortran-lang/fortran-lang.org/pull/314):
+ grammar and spelling from issue #313
+- [#317](https://github.com/fortran-lang/fortran-lang.org/pull/317):
+ more grammar, spelling, and rewording for Fortran Best Practices
+- [#324](https://github.com/fortran-lang/fortran-lang.org/pull/324):
+ replaced "be found be found" with "be found"
+- [#320](https://github.com/fortran-lang/fortran-lang.org/pull/320):
+ Alternative approach to avoiding integer division
+- [#328](https://github.com/fortran-lang/fortran-lang.org/pull/328):
+ Add incompact3d to package index
+- [#333](https://github.com/fortran-lang/fortran-lang.org/pull/333):
+ Add fparser to package index
+- [#335](https://github.com/fortran-lang/fortran-lang.org/pull/335):
+ Adding two more packages to the index
+- [#334](https://github.com/fortran-lang/fortran-lang.org/pull/334):
+ Add pFlogger to package index
+- [#336](https://github.com/fortran-lang/fortran-lang.org/pull/336):
+ One more package
+
+### Work in progress
+
+- [#329](https://github.com/fortran-lang/fortran-lang.org/pull/329) (WIP):
+ Quantum Information book, WSL GUI, and typos
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Draft: Internationalization for fortran-lang
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues)
+if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the
+[contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md)
+for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in stdlib:
+
+- [#509](https://github.com/fortran-lang/stdlib/pull/509):
+ fixed typo
+- [#503](https://github.com/fortran-lang/stdlib/pull/503):
+ refactor documentation regarding consistency
+- [#511](https://github.com/fortran-lang/stdlib/pull/511):
+ Correctly set CMAKE_INSTALL_MODULEDIR cache variable
+- [#513](https://github.com/fortran-lang/stdlib/pull/513):
+ Update issue templates
+- [#523](https://github.com/fortran-lang/stdlib/pull/523):
+ Rename config.yaml -> config.yml
+- [#508](https://github.com/fortran-lang/stdlib/pull/508):
+ github-ci: add fpm support
+- [#475](https://github.com/fortran-lang/stdlib/pull/475):
+ Generating sorting subroutines specific to `character` type with fypp
+- [#525](https://github.com/fortran-lang/stdlib/pull/525):
+ Add files generated by tests to gitignore
+- [#529](https://github.com/fortran-lang/stdlib/pull/529):
+ Add maintainer entry to fpm manifest
+- [#530](https://github.com/fortran-lang/stdlib/pull/530):
+ Make it clearer how the user can control compiler optimization
+- [#528](https://github.com/fortran-lang/stdlib/pull/528):
+ Reduce redundancy caused by optional arguments
+- [#3](https://github.com/fortran-lang/stdlib-cmake-example/pull/3) (`stdlib-cmake-example`):
+ Add example integration with test-drive
+
+### Work in progress
+
+- [#543](https://github.com/fortran-lang/stdlib/pull/543) (WIP):
+ Fix string concat
+- [#539](https://github.com/fortran-lang/stdlib/pull/539) (WIP):
+ Add function gcd
+- [#538](https://github.com/fortran-lang/stdlib/pull/538) (WIP):
+ Bump stdlib version to 0.1.0
+- [#537](https://github.com/fortran-lang/stdlib/pull/537) (WIP):
+ Add a changelog for the current features of stdlib
+- [#536](https://github.com/fortran-lang/stdlib/pull/536) (WIP):
+ Fix conversion warnings
+- [#521](https://github.com/fortran-lang/stdlib/pull/521) (WIP):
+ Ensure module output directory is generated in configure stage
+- [#520](https://github.com/fortran-lang/stdlib/pull/520) (WIP):
+ [stdlib_io] add `disp`(display your data).
+- [#517](https://github.com/fortran-lang/stdlib/pull/517) (WIP):
+ adding SPEC_TEMPLATE.md #504
+- [#514](https://github.com/fortran-lang/stdlib/pull/514) (WIP):
+ pop, drop & get with basic range feature for stringlist
+- [#500](https://github.com/fortran-lang/stdlib/pull/500) (WIP):
+ Selection algorithms
+- [#499](https://github.com/fortran-lang/stdlib/pull/499) (WIP):
+ [stdlib_linalg] matrix property checks
+- [#498](https://github.com/fortran-lang/stdlib/pull/498) (WIP):
+ [stdlib_math] add `arg/argd/argpi`
+- [#494](https://github.com/fortran-lang/stdlib/pull/494) (WIP):
+ Add testing module to allow better structuring of test suites
+- [#491](https://github.com/fortran-lang/stdlib/pull/491) (WIP):
+ Stdlib linked list
+- [#488](https://github.com/fortran-lang/stdlib/pull/488) (WIP):
+ [stdlib_math] add `is_close` routines.
+- [#473](https://github.com/fortran-lang/stdlib/pull/473) (WIP):
+ Error stop improvements
+- [#455](https://github.com/fortran-lang/stdlib/pull/455) (WIP):
+ stdlib_hash: waterhash algorithm
+- [#452](https://github.com/fortran-lang/stdlib/pull/452) (WIP):
+ Implementation of a map data type
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Sorting string's characters according to their ASCII values
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#286](https://github.com/fortran-lang/stdlib/pull/286) (WIP):
+ Probability Distribution and Statistical Functions -- Beta Distribution Module
+- [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Probability Distribution and Statistical Functions -- Gamma Distribution Module
+- [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP):
+ Probability Distribution and Statistical Functions -- Exponential Distribution Module
+- [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP):
+ Probability Distribution and Statistical Functions -- Normal Distribution Module
+- [#272](https://github.com/fortran-lang/stdlib/pull/272) (WIP):
+ Probability Distribution and Statistical Functions -- Uniform Distribution Module
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of COO / CSR sparse format
+
+Please help improve stdlib by testing and [reviewing pull requests](https://github.com/fortran-lang/stdlib/issues?q=is%3Apr+is%3Aopen+label%3A%22reviewers+needed%22)!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in fpm:
+
+- [#521](https://github.com/fortran-lang/fpm/pull/521):
+ expand tabs
+- [#557](https://github.com/fortran-lang/fpm/pull/557):
+ Update installer script to update subprojects first
+- [#558](https://github.com/fortran-lang/fpm/pull/558):
+ Add issue templates
+- [#565](https://github.com/fortran-lang/fpm/pull/565):
+ Default branch renaming aftermath
+- [#562](https://github.com/fortran-lang/fpm/pull/562):
+ Add new distributions where fpm is available to README
+- [#563](https://github.com/fortran-lang/fpm/pull/563):
+ Add workflow to create single source fpm version
+- [#564](https://github.com/fortran-lang/fpm/pull/564):
+ Separate upload stage in CI testing
+- [#572](https://github.com/fortran-lang/fpm/pull/572):
+ Build no tests by default
+- [#549](https://github.com/fortran-lang/fpm/pull/549):
+ Allow setting, archiver, C compiler flags and linker flags from commandline
+- [#578](https://github.com/fortran-lang/fpm/pull/578):
+ help text was truncated
+- [#579](https://github.com/fortran-lang/fpm/pull/579):
+ Fix dir not getting removed after testing fpm
+- [#584](https://github.com/fortran-lang/fpm/pull/584):
+ Actually read environment variables
+
+### Work in progress
+
+- [#575](https://github.com/fortran-lang/fpm/pull/575) (WIP):
+ Enable multiple build output directories
+- [#569](https://github.com/fortran-lang/fpm/pull/569) (WIP):
+ Add workflow for continuous delivery
+- [#539](https://github.com/fortran-lang/fpm/pull/539) (WIP):
+ Add parent packages into dependency tree
+- [#498](https://github.com/fortran-lang/fpm/pull/498) (WIP):
+ Compiler flags profiles
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/HEAD/PACKAGING.md)
+ to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/HEAD/manifest-reference.md)
+ to learn what are all the things that you can specify in the fpm.toml file.
+
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Flang
+
+Recent development updates:
+
+- New Driver and CMake integration:
+ - flang-omp-report plugin - first full fledged frontend plugin has been contributed
+ - CMake integration - waiting on a new PR
+ - Code-generation work is ongoing - task list has been presented to the community for discussion and approval
+- FIR (Fortran IR - a dialect of MLIR):
+ - Fortran 95 lowering and runtime support is nearing completion
+ - Code upstreaming has begun again
+- OpenMP
+ - Merged: Critical, collapse clause, Fixes for SNAP.
+ - In review: Firstprivate, Ordered, MLIR definitions for a few target side constructs, semantic checks for atomic, critical, sections, simd
+ - OpenMP 5.0 metadirective
+- Runtime
+ - Change complex type define in runtime for clang-cl
+ - Implement READ(SIZE=) and INQUIRE(IOLENGTH=) in runtime
+ - GET_COMMAND_ARGUMENT runtime implementation, handling the LENGTH, VALUE, STATUS and ERRMSG parameters.
+ - COMMAND_ARGUMENT_COUNT runtime implementation
+ - Add POSIX implementation for SYSTEM_CLOCK
+ - Fix WRITE after BACKSPACE on variable-length file
+ - Implement Posix version of DATE_AND_TIME runtime
+- Ported test scripts to Python, enables testing on Windows
+- More precise checks for NULL() operands
+- Enforce array conformance in actual arguments to ELEMENTALs
+- Constant folding for COUNT, SQRT, HYPOT, CABS, CSHIFT, EOSHIFT, PACK, UNPACK, and TRANSPOSE
+- Make this_image() an intrinsic function
+- Revamp C1502 checking of END INTERFACE [generic-spec]
+- Accept SIZE(assumed-rank, DIM=n)
+- Validate SIZE(x,DIM=n) dimension for assumed-size array x
+- Catch errors with intrinsic array inquiry functions
+- Correct overflow detection in folding of real->integer conversions
+- Upgrade warning to error in case of PURE procedure
+- Enforce fixed form rules about END continuation
+- Enforce specification function rules on callee, not call
+- Catch error: base of DATA statement object can't be a pointer
+- Represent parentheses around derived types
+- Enforce constraint: defined ass't in WHERE must be elemental
+- Catch branching into FORALL/WHERE constructs
+- Implement semantic checks for ELEMENTAL subprograms
+- Signal EOR in non advancing IO and move to next record
+- Extension: reduced scope for some implied DO loop indices
+- Take result length into account in ApplyElementwise folding
+- Apply double precision KindCode in specific proc interface
+
+Call notes are recorded and available upon request [here](https://docs.google.com/document/d/10T-S2J3GrahpG4Ooif93NSTz2zBW0MQc_RlwHi0-afY). Please contact Alexis Perry-Holby at aperry@lanl.gov for document access.
+
+### LFortran
+
+- 81
+ [merged](https://gitlab.com/lfortran/lfortran/-/merge_requests?scope=all&state=merged)
+ Merge Requests in September 2021
+- LFortran Minimum Viable Product (MVP) [released](https://lfortran.org/blog/2021/09/lfortran-minimum-viable-product-mvp/)
+- LFortran 0.13.0, 0.13.1 and 0.14.0 released in September
+- The following people have contributed code to LFortran in September:
+ - Ondřej Čertík
+ - Gagandeep Singh
+ - Carlos Une
+ - Thirumalai Shaktivel
+ - Harris M. Snyder
+ - Sebastian Ehlert
+ - Mengjia Lyu
+- Many people have reported bugs (thank you all!)
+- Main features implemented in September:
+ - Operator overloading (ASR, LLVM)
+ - Goto (ASR, LLVM)
+ - Runtime library improvements: `iand`, `len`, `trim`, `len_trim`
+ - Interactive mode: get complex numbers, intrinsic functions working
+ (Windows, macOS, Linux)
+ - New driver options: --fast, --symtab-only, --target
+
+We are looking for new contributors. Please do not hesitate to contact us if
+you are interested. We will help you get up to speed.
+
+## Events
+
+- We had our 16th Fortran Monthly call on September 22.
+ You can watch the recording below:
+
+
+- The second international Fortran Conference (FortranCon) 2021 was held virtually on September 23-24
+ Video recordings of the talks will be made available soon.
+ For more information, visit the [FortranCon website](https://tcevents.chem.uzh.ch/event/14/).
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [fortran-lang/fftpack](https://github.com/fortran-lang/fftpack)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/11-01-Fortran-Newsletter-November-2021.md.txt b/_sources/news/2021/11-01-Fortran-Newsletter-November-2021.md.txt
new file mode 100644
index 000000000000..232f70d75d4a
--- /dev/null
+++ b/_sources/news/2021/11-01-Fortran-Newsletter-November-2021.md.txt
@@ -0,0 +1,260 @@
+---
+category: newsletter
+date: 2021-11-01
+author: Sebastian Ehlert, Alexis Perry-Holby, Milan Curcic, Ondřej Čertík
+...
+
+# Fortran newsletter: November 2021
+
+Welcome to the November 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+This month we've had several updates to the website:
+
+- [#345](https://github.com/fortran-lang/fortran-lang.org/pull/345):
+ Fix title in learning resources
+- [#341](https://github.com/fortran-lang/fortran-lang.org/pull/341):
+ Add Cantera to package index
+- [#329](https://github.com/fortran-lang/fortran-lang.org/pull/329):
+ Quantum Information book, WSL GUI, and typos
+- [#340](https://github.com/fortran-lang/fortran-lang.org/pull/340):
+ Minor fixes in Best Practices
+
+### Work in progress
+
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Internationalization for fortran-lang
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues)
+if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the
+[contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md)
+for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in stdlib:
+
+- [0.1.0](https://github.com/fortran-lang/stdlib/releases/tag/v0.1.0):
+ Initial version of the Fortran standard library
+- [#543](https://github.com/fortran-lang/stdlib/pull/543):
+ Fix string concat
+
+### Work in progress
+
+- [#554](https://github.com/fortran-lang/stdlib/pull/554) (WIP):
+ Hash functions
+- [#552](https://github.com/fortran-lang/stdlib/pull/552) (WIP):
+ Fix bug in stringlist
+- [#536](https://github.com/fortran-lang/stdlib/pull/536) (WIP):
+ Fix conversion warnings
+- [#520](https://github.com/fortran-lang/stdlib/pull/520) (WIP):
+ [stdlib\_io] add `disp` (display your data).
+- [#517](https://github.com/fortran-lang/stdlib/pull/517) (WIP):
+ adding SPEC_TEMPLATE.md
+- [#514](https://github.com/fortran-lang/stdlib/pull/514) (WIP):
+ pop, drop & get with basic range feature for stringlist
+- [#500](https://github.com/fortran-lang/stdlib/pull/500) (WIP):
+ Selection algorithms
+- [#499](https://github.com/fortran-lang/stdlib/pull/499) (WIP):
+ [stdlib\_linalg] matrix property checks
+- [#498](https://github.com/fortran-lang/stdlib/pull/498) (WIP):
+ [stdlib\_math] add `arg/argd/argpi`
+- [#494](https://github.com/fortran-lang/stdlib/pull/494) (WIP):
+ Add testing module to allow better structuring of test suites
+- [#491](https://github.com/fortran-lang/stdlib/pull/491) (WIP):
+ Stdlib linked list
+- [#488](https://github.com/fortran-lang/stdlib/pull/488) (WIP):
+ [stdlib\_math] add `is_close` routines.
+- [#473](https://github.com/fortran-lang/stdlib/pull/473) (WIP):
+ Error stop improvements
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Sorting string's characters according to their ASCII values
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#286](https://github.com/fortran-lang/stdlib/pull/286) (WIP):
+ Probability Distribution and Statistical Functions -- Beta Distribution Module
+- [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Probability Distribution and Statistical Functions -- Gamma Distribution Module
+- [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP):
+ Probability Distribution and Statistical Functions -- Exponential Distribution Module
+- [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP):
+ Probability Distribution and Statistical Functions -- Normal Distribution Module
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of COO / CSR sparse format
+
+Please help improve stdlib by testing and [reviewing pull requests](https://github.com/fortran-lang/stdlib/issues?q=is%3Apr+is%3Aopen+label%3A%22reviewers+needed%22)!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in fpm:
+
+- [#597](https://github.com/fortran-lang/fpm/pull/597):
+ Add LFortran optimization flag to release profile
+- [#595](https://github.com/fortran-lang/fpm/pull/595):
+ List names without suffix (mainly for Windows)
+- [#590](https://github.com/fortran-lang/fpm/pull/590):
+ Change link command on Windows with `ifort` or `ifx`
+- [#575](https://github.com/fortran-lang/fpm/pull/575):
+ Enable multiple build output directories
+- [#587](https://github.com/fortran-lang/fpm/pull/587):
+ Bootstrapping instructions version update
+
+### Work in progress
+
+- [#598](https://github.com/fortran-lang/fpm/pull/598) (WIP):
+ Update README.md compiler, archiver, & link flags
+- [#569](https://github.com/fortran-lang/fpm/pull/569) (WIP):
+ Add workflow for continuous delivery
+- [#539](https://github.com/fortran-lang/fpm/pull/539) (WIP):
+ Add parent packages into dependency tree
+- [#498](https://github.com/fortran-lang/fpm/pull/498) (WIP):
+ Compiler flags profiles
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/main/PACKAGING.md)
+ to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/main/manifest-reference.md)
+ to learn what are all the things that you can specify in the fpm.toml file.
+
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Flang
+
+Recent development updates:
+
+- Runtime
+ - Front-end and runtime support for CALL EXIT and ABORT
+ - Fix formatted real input regression w/ spaces
+ - Add runtime interface for GET_ENVIRONMENT_VARIABLE
+ - More work on SYSTEM_CLOCK runtime API and implementation
+ - Implement GET_ENVIRONMENT_VARIABLE(LENGTH)
+- OpenMP
+ - Added OpenMP 5.0 specification based semantic checks for sections construct and test case for simd construct
+ - Added test case for OpenMP 5.0 specification based semantic checks for parallel sections construct
+ - Added OpenMP 5.0 specification based semantic checks for CRITICAL construct name resolution
+ - Checks for THREADPRIVATE and DECLARE TARGET Directives
+ - Initial parsing/sema for append_args clause for 'declare variant'
+- FIR
+ - Add typeparams to fir.array_update, fir.array_fetch and fir.array_merge_store operations. Add optional slice operands to fir.array_merge_store op.
+ - Updated various ops - fir.extract_value, fir.insert_value, fir.allocmem, fir.alloca, fir.field_index, fir.freemem, fir.store
+ - Move the parsers, printers and builders from the TableGen file to the .cpp file
+ - Update fir.alloca op - Add pinned attributes and specific builders
+ - Add ops: fir.char_convert and fir.array_modify
+ - Add passes: external name interop, affine promotion, affine demotion, character conversion, abstract result conversion, cfg conversion
+ - Add fir.convert canonicalization patterns
+ - Add the DoLoopHelper
+ - Add IfBuilder and utility functions
+ - Add FIRBuilder utility functions
+ - Add character utility functions in FIRBuilder
+ - Add Character helper
+ - Add utility function to FIRBuilder and MutableBox
+ - Add substring to fir.slice operation
+ - Avoid slice with substr in fir.array_load, fir.array_coor and fir.array_merge_store
+- Driver
+ - Error if uuidgen is not installed
+ - Fix erroneous `&`
+ - Add actions that execute despite semantic errors
+- flang-omp-report
+ - replace std::vector's with llvm::SmallVector
+ - Switch from std::string to StringRef (where possible)
+ - replace std::map with llvm::DenseMap
+- Make builtin types more easily accessible; use them
+- Fix test regression from SQRT folding
+- Fold FINDLOC, MAXLOC, MINLOC, LGE/LGT/LLE/LLT, BTEST intrinsic functions
+- Take into account SubprogramDetails in GetInterfaceSymbol
+- Add debug dump method to evaluate::Expr and semantics::Symbol
+- Add a wrapper for Fortran main program
+- Improve runtime interface with C99 complex
+- Better error recovery for missing THEN in ELSE IF
+- Define IEEE_SCALB, IEEE_NEXT_AFTER, IEEE_NEXT_DOWN, IEEE_NEXT_UP
+- Catch mismatched parentheses in prescanner
+- Error checking for IBCLR/IBSET and ISHFT/SHIFT[ALR]
+- Document behavior for nonspecified/ambiguous cases
+- Add two negative tests for needExternalNameMangling
+- Expunge bogus semantic check for ELEMENTAL without dummies
+- Admit NULL() in generic procedure resolution cases
+- Fix bogus folding error for ISHFT(x, negative)
+- Emit unformatted headers & footers even with RECL=
+- Enforce rest of semantic constraint C919
+- Extension to distinguish specific procedures
+- Support NAMELIST input of short arrays
+- Fix generic resolution case
+- Speed common runtime cases of DOT_PRODUCT & MATMUL
+- Fix crash on empty formatted external READs
+- Extension: allow tabs in output format strings
+- Fix DOT_PRODUCT for logical
+- Fix NAMELIST input bug with multiple subscript triplets
+- Support legacy usage of 'A' edit descriptors for integer & real
+
+Call notes are recorded and available upon request [here](https://docs.google.com/document/d/10T-S2J3GrahpG4Ooif93NSTz2zBW0MQc_RlwHi0-afY). Please contact Alexis Perry-Holby at aperry@lanl.gov for document access.
+
+### LFortran
+
+- 155 Merge Requests merged in October 2021
+- AST to ASR transformation simplified and unified
+- Many new intrinsics added
+- Rust style error messages, add first warnings and style suggestions
+- Fixed bugs in location information
+- C preprocessor added
+
+We are looking for new contributors. Please do not hesitate to contact us if
+you are interested. We will help you get up to speed.
+
+## Events
+
+- We have adopted two new Fortran-lang guidelines:
+ - [Governance document](https://github.com/fortran-lang/.github/blob/main/GOVERNANCE.md) that describes how Fortran-lang projects are managed
+ - [Administration, moderation, and editing guide](https://fortran-lang.discourse.group/t/welcome-to-discourse/7#administration-moderation-and-editing-3) for Fortran Discourse
+ Both documents are part of an effort to increase transparency between Fortran-lang administrators and the rest of the community.
+- The US Fortran Standards Committee (J3) held the meeting 225 October 18-27, 2021.
+ The meeting was virtual and on Mondays and Wednesdays only.
+ Discussions focused on resolving any outstanding issues to the Fortran 202X features.
+ Here are the links to the meeting [agenda](https://j3-fortran.org/doc/year/21/agenda225.txt),
+ [minutes](https://j3-fortran.org/doc/year/21/minutes225.txt),
+ and [papers](https://j3-fortran.org/doc/meeting/225).
+ See also the [Fortran-lang and LFortran liaison report to J3](https://j3-fortran.org/doc/year/21/21-206.txt)
+ submitted by Ondřej Čertík and Milan Curcic.
+- We had our 19th Fortran Monthly call on October 19.
+ You can watch the recording below:
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [fortran-lang/fftpack](https://github.com/fortran-lang/fftpack)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/12-01-Fortran-Newsletter-December-2021.md.txt b/_sources/news/2021/12-01-Fortran-Newsletter-December-2021.md.txt
new file mode 100644
index 000000000000..357c170e6383
--- /dev/null
+++ b/_sources/news/2021/12-01-Fortran-Newsletter-December-2021.md.txt
@@ -0,0 +1,260 @@
+---
+category: newsletter
+date: 2021-12-01
+author: Milan Curcic, Sebastian Ehlert, Alexis Perry-Holby
+...
+
+# Fortran newsletter: December 2021
+
+Welcome to the December 2021 edition of the monthly Fortran newsletter.
+The newsletter comes out at the beginning of every month and details
+Fortran news from the previous month.
+
+## fortran-lang.org
+
+Here's what's new and ongoing in the fortran-lang.org repo:
+
+- [#348](https://github.com/fortran-lang/fortran-lang.org/pull/348):
+ Fix typo in author field
+
+### Work in progress
+
+- [#347](https://github.com/fortran-lang/fortran-lang.org/pull/347) (WIP):
+ Fortran Intrinsics
+- [#201](https://github.com/fortran-lang/fortran-lang.org/pull/201) (WIP):
+ Internationalization for fortran-lang
+
+[Let us know](https://github.com/fortran-lang/fortran-lang.org/issues)
+if you have any suggestions for the website and its content.
+We welcome any new contributors to the website and the tutorials page in particular - see the
+[contributor guide](https://github.com/fortran-lang/fortran-lang.org/blob/HEAD/CONTRIBUTING.md)
+for how to get started.
+
+## Fortran Standard Library
+
+Here's what's new in stdlib:
+
+- [#558](https://github.com/fortran-lang/stdlib/pull/558):
+ Pin specific fpm version
+- [#556](https://github.com/fortran-lang/stdlib/pull/556):
+ fix some FORD links
+- [#494](https://github.com/fortran-lang/stdlib/pull/494):
+ Add testing module to allow better structuring of test suites
+- [#562](https://github.com/fortran-lang/stdlib/pull/562):
+ Minor update `pure/elemental` in `string_type` module
+- [#565](https://github.com/fortran-lang/stdlib/pull/565):
+ Make support for quadruple precision optional
+- [#566](https://github.com/fortran-lang/stdlib/pull/566):
+ Create a call for reviewers pull request template
+- [#578](https://github.com/fortran-lang/stdlib/pull/578):
+ Update error in case fypp preprocessor is not found
+- [#579](https://github.com/fortran-lang/stdlib/pull/579):
+ Add module for handling version information of stdlib
+
+### Work in progress
+
+- [#581](https://github.com/fortran-lang/stdlib/pull/581) (WIP):
+ Add routines for saving/loading arrays in npy format
+- [#580](https://github.com/fortran-lang/stdlib/pull/580) (WIP):
+ Add terminal and color escape sequences
+- [#573](https://github.com/fortran-lang/stdlib/pull/573) (WIP):
+ Revised Hash functions incorporating changes in the main Stdlib repository.
+- [#552](https://github.com/fortran-lang/stdlib/pull/552) (WIP):
+ fixed bug in stringlist
+- [#536](https://github.com/fortran-lang/stdlib/pull/536) (WIP):
+ Fix conversion warnings
+- [#520](https://github.com/fortran-lang/stdlib/pull/520) (WIP):
+ [stdlib_io] add `disp`(display variable values formatted).
+- [#517](https://github.com/fortran-lang/stdlib/pull/517) (WIP):
+ adding SPEC_TEMPLATE.md #504
+- [#514](https://github.com/fortran-lang/stdlib/pull/514) (WIP):
+ pop, drop & get with basic range feature for stringlist
+- [#500](https://github.com/fortran-lang/stdlib/pull/500) (WIP):
+ Selection algorithms
+- [#499](https://github.com/fortran-lang/stdlib/pull/499) (WIP):
+ [stdlib_linalg] matrix property checks
+- [#498](https://github.com/fortran-lang/stdlib/pull/498) (WIP):
+ [stdlib_math] add `arg/argd/argpi`
+- [#491](https://github.com/fortran-lang/stdlib/pull/491) (WIP):
+ Stdlib linked list
+- [#488](https://github.com/fortran-lang/stdlib/pull/488) (WIP):
+ [stdlib_math] add `is_close` routines.
+- [#473](https://github.com/fortran-lang/stdlib/pull/473) (WIP):
+ Error stop improvements
+- [#363](https://github.com/fortran-lang/stdlib/pull/363) (WIP):
+ Sorting string's characters according to their ASCII values
+- [#353](https://github.com/fortran-lang/stdlib/pull/353) (WIP):
+ Initial checkin for a module for tolerant comparison of reals
+- [#286](https://github.com/fortran-lang/stdlib/pull/286) (WIP):
+ Probability Distribution and Statistical Functions -- Beta Distribution Module
+- [#278](https://github.com/fortran-lang/stdlib/pull/278) (WIP):
+ Probability Distribution and Statistical Functions -- Gamma Distribution Module
+- [#276](https://github.com/fortran-lang/stdlib/pull/276) (WIP):
+ Probability Distribution and Statistical Functions -- Exponential Distribution Module
+- [#273](https://github.com/fortran-lang/stdlib/pull/273) (WIP):
+ Probability Distribution and Statistical Functions -- Normal Distribution Module
+- [#189](https://github.com/fortran-lang/stdlib/pull/189) (WIP):
+ Initial implementation of COO / CSR sparse format
+
+Please help improve stdlib by testing and [reviewing pull requests](https://github.com/fortran-lang/stdlib/issues?q=is%3Apr+is%3Aopen+label%3A%22reviewers+needed%22)!
+
+The candidate for file system operations to be included in stdlib is being developed by
+[@MarDiehl](https://github.com/MarDiehl) and [@arjenmarkus](https://github.com/arjenmarkus)
+in [this repository](https://github.com/MarDiehl/stdlib_os).
+Please try it out and let us know how it works, if there are any issues, or if the API can be improved.
+
+## Fortran Package Manager
+
+Here's what's new in fpm:
+
+- [v0.5.0](https://github.com/fortran-lang/fpm/releases/tag/v0.5.0):
+ Alpha release update
+- [#598](https://github.com/fortran-lang/fpm/pull/598):
+ Update README.md compiler, archiver, & link flags
+- [#569](https://github.com/fortran-lang/fpm/pull/569):
+ Add workflow for continuous delivery
+- [#602](https://github.com/fortran-lang/fpm/pull/602):
+ fix(fpm_compiler): intel windows release flag was incorrect
+- [#607](https://github.com/fortran-lang/fpm/pull/607):
+ Repair --list option and correct obsolete descriptions of the --list option
+- [#612](https://github.com/fortran-lang/fpm/pull/612):
+ Fix modules listing (for install)
+- [#613](https://github.com/fortran-lang/fpm/pull/613):
+ Add: critical section to mkdir in backend
+- [#616](https://github.com/fortran-lang/fpm/pull/616):
+ Add: workflow to make installer on push and release
+- [#614](https://github.com/fortran-lang/fpm/pull/614):
+ Bump version to 0.5.0
+- [setup-fpm#7](https://github.com/fortran-lang/setup-fpm/pull/7):
+ Fix Latest Option
+
+### Work in progress
+
+- [#622](https://github.com/fortran-lang/fpm/pull/622) (WIP):
+ Cleanup the backend output
+- [#608](https://github.com/fortran-lang/fpm/pull/608) (WIP):
+ --env switch lets you specify the prefix of the compiler-related environment variables
+- [#539](https://github.com/fortran-lang/fpm/pull/539) (WIP):
+ Add parent packages into dependency tree
+- [#498](https://github.com/fortran-lang/fpm/pull/498) (WIP):
+ Compiler flags profiles
+
+`fpm` is still in early development and we need as much help as we can get.
+Here's how you can help today:
+
+- Use it and let us know what you think! Read the [fpm packaging guide](https://github.com/fortran-lang/fpm/blob/main/PACKAGING.md)
+ to learn how to build your package with fpm, and the [manifest reference](https://github.com/fortran-lang/fpm/blob/main/manifest-reference.md)
+ to learn what are all the things that you can specify in the fpm.toml file.
+
+- Browse existing _fpm_ packages on the [fortran-lang website](https://fortran-lang.org/packages/fpm)
+- Browse the [open issues](https://github.com/fortran-lang/fpm/issues) and see if you can help implement any fixes or features.
+- Adapt your Fortran package for fpm and submit it to the [Registry](https://github.com/fortran-lang/fpm-registry).
+- Improve the documentation.
+
+The short-term goal of fpm is to make development and installation of Fortran packages with dependencies easier.
+Its long term goal is to build a rich and decentralized ecosystem of Fortran packages and create a healthy
+environment in which new open source Fortran projects are created and published with ease.
+
+## Compilers
+
+### Flang
+
+Recent development updates:
+
+- OpenMP
+ - Use the ultimate symbol in a call to the IsPointer function
+ - Add parsing/sema/serialization for 'bind' clause.
+- FIR
+ - Add base of the FIR to LLVM IR pass
+ - Add various FIR to LLVM IR conversion patterns:
+ - fir.unreachable
+ - fir.insert_on_range
+ - fir.zero_bits
+ - fir.select and fir.select_rank
+ - fir.extract_value and fir.insert_value
+ - types - fir.box, fir.logical, fir.char, fir.ptr
+ - fir.box_rank, fir.box_addr, fir.box_dims, fir.box_elesize
+ - fir.convert
+ - fir.call
+ - fir.store and fir.load
+ - Add substr information to fircg.ext_embox and fircg.ext_rebox operations
+ - Use notifyMatchFailure in fir.zero_bits conversion
+ - Restrict array type on fir.insert_on_range
+ - Add test for FIR types conversion
+ - Use contralized values for indexing box
+ - Add complex operations conversion from FIR LLVM IR
+ - Add TargetRewrite pass and TargetRewrite: Rewrite COMPLEX values
+- Runtime
+ - Read environment variables directly
+- flang-omp-report
+ - Removed unnecessary comments in flang-omp-report plugin tests
+ - Remove the loop workarounds for nowait clause
+ - Add flang-omp-report summarising script
+- Checks for pointers to intrinsic functions
+- Fold SPREAD
+- Improve error message for misuse of NULL(mold) as data statement constant
+- Fix crash on "call system_clock(count_max=j)"
+- Fix combined folding of FINDLOC/MAXLOC/MINLOC
+- Implement GET_ENVIRONMENT_VARIABLE(VALUE)
+- Remove builder that takes SSA value instead of Attribute on ExtractValueOp, InsetValueOp, and InsertOnRangeOp
+- Remove getModel in DescriptorModel.h
+- Set the addendum when establishing pointer section in descriptor
+- Fix error in characteristics check at procedure pointer assignment
+- Initial parsing/sema for 'align' clause
+- Don't reference non-invariant symbols in shape expressions
+- Make subscript list argument a nullable pointer
+- Distinguish error/warning cases for bad jumps into constructs
+- Fix folding of EPSILON()
+
+Call notes are recorded and available upon request [here](https://docs.google.com/document/d/10T-S2J3GrahpG4Ooif93NSTz2zBW0MQc_RlwHi0-afY). Please contact Alexis Perry-Holby at aperry@lanl.gov for document access.
+
+### LFortran
+
+- 32 Merge Requests merged in November 2021
+- Support for same name interface and subroutine/function
+- Compile-time evaluation for bit intrinsics
+- Implement the `repeat` and `shape` intrinsics
+- Variadic support for `min` and `max` intrinsics
+- Implement the scalar `random_number` function
+- Fixes and improved error message for `read` and `write` statements
+- Support the `final`, `intrinsic`, and `private` attributes
+- Implement the `ieee_arithmetic` intrinsic module
+- Support for the `abstract` class
+- Support for `assignment(=)` on `use` statement
+
+We are looking for new contributors. Please do not hesitate to contact us if
+you are interested. We will help you get up to speed.
+
+## Events
+
+- Sebastian Ehlert presented the Fortran Package Manager at the PackagingCon 2021 conference.
+ You can watch the recording below:
+
+- Recordings of all FortranCon 2021 presentations are now available to view in
+ the [FortranCon YouTube Channel](https://www.youtube.com/playlist?list=PLeKbr7eYHjt5UaV9zQtY24oEbne9_uFni).
+ Enjoy!
+- We had our 20th Fortran Monthly call on November 15.
+ You can watch the recording below:
+
+
+As usual, subscribe to the [mailing list](https://groups.io/g/fortran-lang) and/or
+join the [Discourse](https://fortran-lang.discourse.group) to stay tuned with the future meetings.
+
+## Contributors
+
+We thank everybody who contributed to fortran-lang in the past month by
+commenting in any of these repositories:
+
+- [fortran-lang/stdlib](https://github.com/fortran-lang/stdlib)
+- [fortran-lang/stdlib-cmake-example](https://github.com/fortran-lang/stdlib-cmake-example)
+- [fortran-lang/fpm](https://github.com/fortran-lang/fpm)
+- [fortran-lang/fpm-registry](https://github.com/fortran-lang/fpm-registry)
+- [fortran-lang/setup-fpm](https://github.com/fortran-lang/setup-fpm)
+- [fortran-lang/fpm-haskell](https://github.com/fortran-lang/fpm-haskell)
+- [fortran-lang/fortran-lang.org](https://github.com/fortran-lang/fortran-lang.org)
+- [fortran-lang/benchmarks](https://github.com/fortran-lang/benchmarks)
+- [fortran-lang/fortran-forum-article-template](https://github.com/fortran-lang/fortran-forum-article-template)
+- [fortran-lang/fftpack](https://github.com/fortran-lang/fftpack)
+- [j3-fortran/fortran_proposals](https://github.com/j3-fortran/fortran_proposals)
+
+
diff --git a/_sources/news/2021/12-29-Fortran-lang-2021-in-review.md.txt b/_sources/news/2021/12-29-Fortran-lang-2021-in-review.md.txt
new file mode 100644
index 000000000000..6ce82ed1dbe9
--- /dev/null
+++ b/_sources/news/2021/12-29-Fortran-lang-2021-in-review.md.txt
@@ -0,0 +1,375 @@
+---
+category: newsletter
+date: 2021-12-29
+author: Milan Curcic, Ondřej Čertík, Laurence Kedward, Sebastian Ehlert, Jérémie Vandenplas
+...
+
+=(Fortran-lang-2021-in-review)
+
+# Fortran-lang: 2021 in review
+
+With another year behind us, let's review the progress that the
+Fortran-lang community has made.
+If you're new to Fortran-lang, here's a quick intro:
+We're an open source community that aims to develop modern Fortran tooling and
+nurture a rich ecosystem of libraries, as well as to provide a friendly,
+helpful, and inclusive space for newcomers and experienced Fortran programmers
+to work together.
+We started in late 2019 and have been going ever since.
+If you're first discovering (or re-discovering) Fortran through this article,
+welcome, and we hope it inspires you to try Fortran for one of your projects.
+In this article we summarize new developments from 2021,
+from flagship and new projects to community development and outreach.
+
+## Standard Library (stdlib)
+
+To date, [33 people](https://github.com/fortran-lang/stdlib/graphs/contributors)
+have contributed code to stdlib, and more than 100 people have participated in
+discussions.
+More than a dozen new modules have been added in 2021:
+
+- `stdlib_array`: Provides `trueloc` and `falseloc` which allow you
+ to index an array based on a logical condition in a functional style
+- `stdlib_hash`: Provides many hash algorithms, 32- and 64-bit alike
+- `stdlib_math`: Provides a number of common mathematical functions
+- `stdlib_random`: Pseudo-random integer number generation
+- `stdlib_selection`: Selection procedures for selecting elements from an array
+ given a desired range
+- `stdlib_sorting`: Sorting procedures based on Rust's sorting algorithm and
+ introsort by David Musser
+- `stdlib_specialfunctions`: Provides the Legendre function and its derivative
+ in support of the Gaussian quadrature procedures
+- `stdlib_stats_distribution_normal`: Functions to sample values from a normal
+ distribution
+- `stdlib_stats_distribution_uniform`: Functions to sample values from a uniform
+ distribution
+- `stdlib_string_type`: Provides a `string_type` derived type that alleviates
+ some limitations of the variable-length `character` variables. `string_type`
+ is compatible with all intrinsic procedures that operate on `character`.
+- `stdlib_stringlist_type`: A derived type that is a 1-dimensional list of
+ strings
+- `stdlib_strings`: Provides a number of inquiry and manipulation procedures that
+ complement the intrinsic set
+- `stdlib_version`: Allows querying the version of the stdlib library build
+
+which brings us to a total of 23 modules in stdlib.
+You can read about these modules in more detail on the
+[stdlib API docs website](https://stdlib.fortran-lang.org).
+
+Besides the new modules, procedures, and derived types, there have been a few
+key improvements in terms of stdlib delivery:
+
+1. You can now use stdlib as a dependency in your fpm projects,
+ see [here](https://github.com/fortran-lang/stdlib#build-with-fortran-langfpm).
+ This significantly lowers the bar for getting started with stdlib.
+2. We had our first stdlib release (0.1.0) on October 4. As of now we don't have
+ a set release schedule, and plan to publish a new release when there is
+ significant new functionality.
+ As stdlib matures and becomes more widely used, we expect releases to become
+ more frequent.
+3. We now maintain a
+ [change log](https://github.com/fortran-lang/stdlib/blob/HEAD/CHANGELOG.md) where every change to the API is documented.
+ This is a useful document to reference when you want to know what's been
+ added to the stdlib since the latest release.
+
+If you haven't tried stdlib yet, please do and let us know what you think
+and how we can improve it.
+Our vision for stdlib is to provide basic utilities that most Fortran projects use,
+as well as wider numerical capabilities with the scope of NumPy and SciPy.
+
+## Fortran Package Manager (fpm)
+
+Fortran Package Manager (fpm) is the package manager and build system for
+Fortran.
+Its key goal is to make developing, distributing, and reusing Fortran
+libraries and applications as easy and as fun as possible.
+In 2020, the big change for fpm was the transition from the prototype
+implemented in Haskell to a pure Fortran implementation.
+Fpm has since been used in increasingly more and ever larger Fortran projects.
+
+To date, [22 people](https://github.com/fortran-lang/fpm/graphs/contributors)
+have contributed code to fpm.
+In 2021 fpm has advanced from v0.1.3 to v0.5.0.
+Key additions this year include (release version in parentheses):
+
+- CLI arguments for linker, archiver, and C compiler (0.5.0)
+- Support for MPI and LFortran (0.4.0)
+- Support for installed library modules via `external-modules` in the manifest
+ (0.3.0)
+- Automatic discovery of manifest files in parent directories (0.3.0)
+- Support for reading package version from file (0.3.0)
+- Support for include directories (0.2.0)
+- Support for `--flag` CLI option to specify compiler flags (0.2.0)
+- `fpm build --show-model` displays the internal representation of a package
+ (0.1.4)
+- Allow hyphen in new package names (0.1.4)
+- `fpm new` now supports `--full` and `--bare` to specify level of scaffolding
+ (0.1.4)
+
+Check out also these fpm plugins:
+
+- [fpm-search](https://github.com/brocolis/fpm-search):
+ Adds the `fpm search` command for searching for registered fpm packages from
+ the command line.
+- [fpm-man](https://github.com/urbanjost/fpm-man):
+ Adds the `fpm man` command for displaying man-style help pages about Fortran
+ intrinsics and other language features.
+
+At the time of writing, there are almost 200 projects now using fpm.
+If you haven't tried fpm yet, please do!
+It has truly been a game-changing tool for many of us.
+
+We have many ideas that we want to pursue, such as:
+
+- First-class integration with other package managers such as Spack and Conda
+- First-class integration with build systems like CMake and Meson
+- Improving [fpm's package registry](https://github.com/fortran-lang/fpm-registry), etc.
+
+We are always looking for new contributors.
+If any of these projects interest you, please join us.
+
+## LFortran
+
+
+
+Though not technically a Fortran-lang project,
+[LFortran](https://lfortran.org) has been growing close to the Fortran-lang
+community and projects largely thanks to its creator and lead developer
+[Ondřej Čertík](https://github.com/certik) also being one of the founding
+members of Fortran-lang.
+LFortran has been developing rapidly this year and was released as a
+[Minimum Viable Product (MVP)](https://lfortran.org/blog/2021/09/lfortran-minimum-viable-product-mvp/) in September.
+LFortran currently parses all of Fortran 2018 and compiles a significant
+subset of the language.
+16 people have contributed code so far, and many more have reported bugs or participated in discussions.
+If you haven't tried LFortran yet, please do and let us know how it can best
+improve for your use case.
+You can help speed up LFortran's development by contributing code and/or
+documentation directly, or by donating funds to the project via
+[NumFOCUS](https://numfocus.org/project/lfortran).
+
+Follow LFortran on Twitter at [@lfortranorg](https://twitter.com/lfortranorg).
+
+## fortran-lang.org, Discourse, and social media
+
+A major addition to the Fortran website this year is the
+[Fortran Best Practices mini-book](https://fortran-lang.org/learn/best_practices).
+This is a port and an update to the well-known
+[fortran90.org](https://www.fortran90.org) by
+[Ondřej Čertík](https://github.com/certik).
+It provides a plethora of tips on how to write simple and idiomatic Fortran
+for numerical tasks, and how to avoid some common gotchas.
+Give it a read and let us know how it can be improved.
+
+The [Fortran Discourse](https://fortran-lang.discourse.group) is as active
+as ever, with new users joining daily.
+There are currently 338 active users out of a total of 537 registered users.
+The Fortran Discourse is a great place to ask for help with Fortran code, post
+a Fortran job opening, and discuss anything Fortran-related.
+
+We also continue to release the monthly newsletter where we
+document the progress month-by-month, as well as post about any notable events
+in the Fortran world.
+This newsletter is a great way to stay up to date with Fortran-lang.
+If you're also on Twitter, follow our account
+[@fortranlang](https://twitter.com/fortranlang) for daily bite-size news and
+updates, as well as the new [@FortranTip](https://twitter.com/FortranTip)
+account, managed by [Beliavsky](https://github.com/beliavsky), which brings
+daily Fortran tips to your Twitter feed.
+
+Finally, we meet on monthly video calls to discuss issues and topics related to all
+Fortran-lang projects.
+The calls are advertised on Fortran Discourse and are open to everyone.
+Don't hesitate to join the call to meet other Fortran-lang participants and take part
+in different discussions.
+
+## New projects
+
+In addition to the flagship projects summarized above, a few new projects
+started or were adopted by Fortran-lang this year.
+
+### fftpack
+
+[fftpack](https://github.com/fortran-lang/fftpack) is a classic collection of
+subroutines to perform the Fast Fourier Transform on real and complex data.
+It is based on the classic
+[FFTPACK library from Netlib](http://www.netlib.org/fftpack/).
+fftpack was adopted by Fortran-lang in an effort to provide:
+
+- A community-maintained FFT library
+- Bug fixes to the existing codebase
+- Modern interfaces on top of the existing API
+- fpm package for easy use as a dependency.
+
+### test-drive
+
+[Test-drive](https://github.com/fortran-lang/test-drive) is a simple and
+easy-to-use testing framework developed by
+[Sebastian Ehlert](https://github.com/awvwgk).
+It follows a simple functional style to collect and run your tests in parallel
+and print a minimal and clean diagnostic printout to the standard output.
+Test-drive is currently used by both stdlib and fpm for their own test suites.
+Give test-drive a test drive for your next Fortran project!
+
+### fpm-docs
+
+[fpm-docs](https://github.com/fortran-lang/fpm-docs) is a brand new user
+documentation website for fpm, developed by
+[Sebastian Ehlert](https://github.com/awvwgk).
+Its key aim is to provide community-maintained documentation across four
+target audiences/use cases:
+
+- **Tutorials**: for learning how to use fpm for Fortran development
+- **How-to guides**: recipes for specific and concrete problems
+- **Design documents**: resources that document the design of various aspects of
+ fpm
+- **References**: specification documents of fpm components
+
+
+
+As the fpm user docs are now hosted at
+[fpm.fortran-lang.org](https://fpm.fortran-lang.org), the API docs are now
+located at [fortran-lang.github.io/fpm/](https://fortran-lang.github.io/fpm/).
+
+## Google Summer of Code 2021
+
+2021 has been the first year for Fortran-lang to participate in the
+[Google Summer of Code](https://summerofcode.withgoogle.com/) program.
+Together with NumFOCUS and LFortran, Fortran-lang had six students who worked on a
+variety of projects:
+
+- [Aman Godara](https://github.com/Aman-Godara) (Improving strings in stdlib)
+- [Chetan Karwa](https://github.com/chetankarwa) (Linked lists in stdlib)
+- [Gagandeep Singh](https://github.com/czgdp1807) (Arrays and allocatables in LFortran)
+- [Jakub Jelínek](https://github.com/kubajj) (Compiler arguments in fpm)
+- [Rohit Goswami](https://rgoswami.me/) (Compiling dftatom with LFortran)
+- [Thirumalai Shaktivel](https://github.com/Thirumalai-Shaktivel) (AST generation in LFortran)
+
+You can read in more detail about their projects
+[here](https://summerofcode.withgoogle.com/archive/2021/organizations/6542461173760000).
+
+A big thank you to all students, mentors, and administrators, for their great
+work, and of course, to the Google Summer of Code program for making
+possible for students to participate.
+
+We plan to apply for Google Summer of Code in 2022 as well.
+The program is no longer limited to students and anybody 18 or older can apply
+to work on an open source project and get paid for it.
+If you're interested participating in the program in 2022 with Fortran-lang,
+don't hesitate to contact us and we'll guide you toward applying.
+
+## Conferences and papers
+
+### FortranCon 2021
+
+Like in 2020, the Fortran event of this year was
+[FortranCon 2021](https://tcevents.chem.uzh.ch/event/14/), the international
+Fortran conference, held on September 23-24.
+The keynote speaker this year was [Damian Rouson](https://github.com/rouson),
+the head of the
+[Computer Languages and Systems Software (CLaSS)](https://crd.lbl.gov/divisions/amcr/computer-science-amcr/class/)
+group at the Lawrence Berkeley National Lab.
+Fortran-lang had a dedicated session (a Fortran-lang minisymposium) on the
+second day of the conference, with the talks about specific Fortran-lang
+projects as well as the Google Summer of Code student presentations.
+FortranCon was hosted at the University of Zurich (UZH), and organized by
+[Tiziano Müller](https://github.com/dev-zero) from UZH and
+[Alfio Lazzaro](https://github.com/alazzaro) from Hewlett-Packard Enterprise.
+You can watch all FortranCon 2021 talks [here](https://www.youtube.com/playlist?list=PLeKbr7eYHjt5UaV9zQtY24oEbne9_uFni).
+
+### PackagingCon 2021
+
+Another big event for Fortran-lang was
+[PackagingCon 2021](https://packaging-con.org/), a conference dedicated to
+package management software and its community of developers.
+[Sebastian Ehlert](https://github.com/awvwgk) presented fpm--you can watch the
+recording below:
+
+
+
+
+
+### Papers
+
+This year two papers have been written about Fortran-lang projects.
+The first paper documents the motivation and goals of
+Fortran-lang: "Toward Modern Fortran Tooling and a Thriving Developer
+Community" by Milan Curcic, Ondřej Čertík, Brad Richardson, Sebastian Ehlert,
+Laurence Kedward, Arjen Markus, Ivan Pribec, and Jérémie Vandenplas
+([https://arxiv.org/abs/2109.07382](https://arxiv.org/abs/2109.07382)).
+
+