diff --git a/ChangeLog b/ChangeLog
index c9629a8..8d8aacf 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -582,7 +582,7 @@
 
 	Reported as
 
-	  http://lists.nongnu.org/archive/html/freetype-devel/2018-08/msg00124.html
+	  https://lists.nongnu.org/archive/html/freetype-devel/2018-08/msg00124.html
 
 	* docs/reference/markdown/stylesheets/extra.css (.md-typeset code):
 	Add rule `white-space'.
@@ -735,7 +735,7 @@
 
 	Reported as
 
-	  http://lists.nongnu.org/archive/html/freetype-devel/2018-08/msg00083.html
+	  https://lists.nongnu.org/archive/html/freetype-devel/2018-08/msg00083.html
 
 2018-08-26  Werner Lemberg  <wl@gnu.org>
 
diff --git a/ChangeLog.24 b/ChangeLog.24
index e28702b..c1f5f8b 100644
--- a/ChangeLog.24
+++ b/ChangeLog.24
@@ -231,7 +231,7 @@
 
 	* src/base/md5.c, src/base/md5.h: New files, taken from
 
-	  http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
+	  https://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
 
 	* include/freetype/internal/fttrace.h: Add `bitmap'.
 
diff --git a/ChangeLog.25 b/ChangeLog.25
index 59cf2bf..4782114 100644
--- a/ChangeLog.25
+++ b/ChangeLog.25
@@ -3405,7 +3405,7 @@
 
 	The canonical URL to get updates for this file is
 
-	  http://cvsweb.openwall.com/cgi/cvsweb.cgi/Owl/packages/popa3d/popa3d/md5/
+	  https://cvsweb.openwall.com/cgi/cvsweb.cgi/Owl/packages/popa3d/popa3d/md5/
 
 	as the author told me in private communication.
 
@@ -4837,7 +4837,7 @@
 
 	Apply fixes for cppcheck nitpicks.
 
-	  http://cppcheck.sourceforge.net/
+	  https://cppcheck.sourceforge.net/
 
 	The call was (from the top-level of the FreeType tree):
 
diff --git a/ChangeLog.28 b/ChangeLog.28
index ca1ff38..12879c6 100644
--- a/ChangeLog.28
+++ b/ChangeLog.28
@@ -2489,8 +2489,8 @@
 
 	Based on ideas taken from
 
-	  http://pkgs.fedoraproject.org/cgit/rpms/freetype.git/tree/freetype-multilib.patch
-	  http://pkgs.fedoraproject.org/cgit/rpms/freetype.git/tree/freetype-2.5.3-freetype-config-prefix.patch
+	  https://pkgs.fedoraproject.org/cgit/rpms/freetype.git/tree/freetype-multilib.patch
+	  https://pkgs.fedoraproject.org/cgit/rpms/freetype.git/tree/freetype-2.5.3-freetype-config-prefix.patch
 
 	* builds/unix/freetype-config.in: Rewritten.  Use `pkg-config' to
 	set output variables if program is available.
diff --git a/README b/README
index c23b99e..30a15f7 100644
--- a/README
+++ b/README
@@ -30,7 +30,7 @@
 
   To view the documentation online, go to
 
-    https://www.freetype.org/freetype2/documentation.html
+    https://www.freetype.org/freetype2/docs/
 
 
   Mailing Lists
diff --git a/builds/amiga/README b/builds/amiga/README
index 29e97d6..1075ee3 100644
--- a/builds/amiga/README
+++ b/builds/amiga/README
@@ -26,7 +26,7 @@
 http://ragriffi.home.sprynet.com).
 
 You will also need the latest include files and amiga.lib from the
-Amiga web site (http://www.amiga.com/3.9/download/NDK3.9.lha) for
+Amiga web site (https://os.amigaworld.de/download.php?id=3) for
 AmigaOS 3.9; the generated code should work under AmigaOS 2.04 and up.
 
 To use it, call "smake assign" and then "smake" from the builds/amiga
diff --git a/builds/mac/README b/builds/mac/README
index f58e47d..c5b0e75 100644
--- a/builds/mac/README
+++ b/builds/mac/README
@@ -46,7 +46,7 @@
 
   Required files are downloadable from:
 
-      http://developer.apple.com/tools/mpw-tools/index.html
+      http://macintoshgarden.org/apps/macintosh-programmers-workshop
 
   Also you can find documents how to update by MPW-PR.
 
@@ -54,7 +54,7 @@
   skeletons. Python bundled to Mac OS X is enough. For
   classic MacOS, MacPython is available:
 
-      http://homepages.cwi.nl/~jack/macpython/
+      https://homepages.cwi.nl/~jack/macpython/
 
   MPW requires all files are typed by resource fork.
   ResEdit bundled to MPW is enough. In Mac OS X,
@@ -280,7 +280,7 @@
     migrate to FSRef datatype. The big differences of FSRef
     against FSSpec are explained in Apple TechNotes 2078.
 
-    http://developer.apple.com/technotes/tn2002/tn2078.html
+    https://developer.apple.com/library/archive/technotes/tn2078/
 
     - filename length: the max length of file
     name of FSRef is 255 chars (it is limit of HFS+),
diff --git a/builds/mac/freetype-Info.plist b/builds/mac/freetype-Info.plist
index b3d114d..4b5d79b 100644
--- a/builds/mac/freetype-Info.plist
+++ b/builds/mac/freetype-Info.plist
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
-          "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
 
 <plist version="1.0">
 
diff --git a/builds/wince/vc2005-ce/index.html b/builds/wince/vc2005-ce/index.html
index 02a1caf..65e094f 100644
--- a/builds/wince/vc2005-ce/index.html
+++ b/builds/wince/vc2005-ce/index.html
@@ -35,7 +35,7 @@
 archives are already stored this way, so no further action is required.  If
 you use some <tt>.tar.*z</tt> archives, be sure to configure your extracting
 tool to convert the line endings.  For example, with <a
-href="http://www.winzip.com">WinZip</a>, you should activate the <em>TAR
+href="https://www.winzip.com">WinZip</a>, you should activate the <em>TAR
 file smart CR/LF Conversion</em> option.  Alternatively, you may consider
 using the <tt>unix2dos</tt> or <tt>u2d</tt> utilities that are floating
 around, which specifically deal with this particular problem.
diff --git a/builds/wince/vc2008-ce/index.html b/builds/wince/vc2008-ce/index.html
index f7a3583..87776b6 100644
--- a/builds/wince/vc2008-ce/index.html
+++ b/builds/wince/vc2008-ce/index.html
@@ -35,7 +35,7 @@
 archives are already stored this way, so no further action is required.  If
 you use some <tt>.tar.*z</tt> archives, be sure to configure your extracting
 tool to convert the line endings.  For example, with <a
-href="http://www.winzip.com">WinZip</a>, you should activate the <em>TAR
+href="https://www.winzip.com">WinZip</a>, you should activate the <em>TAR
 file smart CR/LF Conversion</em> option.  Alternatively, you may consider
 using the <tt>unix2dos</tt> or <tt>u2d</tt> utilities that are floating
 around, which specifically deal with this particular problem.
diff --git a/builds/windows/vc2010/index.html b/builds/windows/vc2010/index.html
index 634ea93..bb6d9b6 100644
--- a/builds/windows/vc2010/index.html
+++ b/builds/windows/vc2010/index.html
@@ -30,7 +30,7 @@
 <p>To configure library dependencies like <em>zlib</em> and <em>libpng</em>,
 edit the <tt>freetype.users.props</tt> file in this directory.  It also
 simplifies automated (command-line) builds using <a
-href="http://msdn.microsoft.com/library/dd393574%28v=vs.100%29.aspx">msbuild</a>.</p>
+href="https://msdn.microsoft.com/library/dd393574%28v=vs.100%29.aspx">msbuild</a>.</p>
 
 <p>To link your executable with FreeType DLL, you may want to define
 DLL_IMPORT so that the imported functions are appropriately
diff --git a/builds/windows/visualc/index.html b/builds/windows/visualc/index.html
index 3a77f36..2eefbdc 100644
--- a/builds/windows/visualc/index.html
+++ b/builds/windows/visualc/index.html
@@ -26,7 +26,7 @@
 archives are already stored this way, so no further action is required.  If
 you use some <tt>.tar.*z</tt> archives, be sure to configure your extracting
 tool to convert the line endings.  For example, with <a
-href="http://www.winzip.com">WinZip</a>, you should activate the <em>TAR
+href="https://www.winzip.com">WinZip</a>, you should activate the <em>TAR
 file smart CR/LF Conversion</em> option.  Alternatively, you may consider
 using the <tt>unix2dos</tt> or <tt>u2d</tt> utilities that are floating
 around, which specifically deal with this particular problem.
diff --git a/builds/windows/visualce/index.html b/builds/windows/visualce/index.html
index d5a3ca3..4be4bc8 100644
--- a/builds/windows/visualce/index.html
+++ b/builds/windows/visualce/index.html
@@ -35,7 +35,7 @@
 archives are already stored this way, so no further action is required.  If
 you use some <tt>.tar.*z</tt> archives, be sure to configure your extracting
 tool to convert the line endings.  For example, with <a
-href="http://www.winzip.com">WinZip</a>, you should activate the <em>TAR
+href="https://www.winzip.com">WinZip</a>, you should activate the <em>TAR
 file smart CR/LF Conversion</em> option.  Alternatively, you may consider
 using the <tt>unix2dos</tt> or <tt>u2d</tt> utilities that are floating
 around, which specifically deal with this particular problem.
diff --git a/docs/CHANGES b/docs/CHANGES
index c90cf54..3015600 100644
--- a/docs/CHANGES
+++ b/docs/CHANGES
@@ -76,7 +76,7 @@
     - CVE-2018-6942: Older  FreeType versions  can crash  with certain
       malformed variation fonts.
 
-        http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-6942
+        https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-6942
 
 
   II. MISCELLANEOUS
@@ -1393,7 +1393,7 @@
 
       Originally, it was a separate patch available from
 
-        http://www.infinality.net/blog/
+        https://web.archive.org/web/20150710073951/http://www.infinality.net:80/blog/
 
       and which has been integrated.
 
@@ -4115,7 +4115,7 @@
     untested for now.
 
   - Updated `docs/docmaker.py', a draft  API reference is available at
-    http://www.freetype.org/ft2api.html.
+    https://web.archive.org/web/20001215173400/http://www.freetype.org:80/ft2api.html.
 
   - Changed `type1' to use `psaux'.
 
diff --git a/docs/INSTALL b/docs/INSTALL
index 71d4a05..73d1d6a 100644
--- a/docs/INSTALL
+++ b/docs/INSTALL
@@ -70,7 +70,7 @@
 [1] make++, a make tool written in Perl, has sufficient support of GNU
     make extensions to build FreeType.  See
 
-      http://makepp.sourceforge.net
+      https://makepp.sourceforge.net
 
     for more information;  you need version 2.0 or newer, and you must
     pass option `--norc-substitution'.
diff --git a/docs/INSTALL.GNU b/docs/INSTALL.GNU
index e314ecf..b15e0b5 100644
--- a/docs/INSTALL.GNU
+++ b/docs/INSTALL.GNU
@@ -23,7 +23,7 @@
     Note that  make++, a  make tool written  in Perl,  supports enough
     features of GNU make to compile FreeType.  See
 
-      http://makepp.sourceforge.net
+      https://makepp.sourceforge.net
 
     for more information;  you need version 2.0 or newer, and you must
     pass option `--norc-substitution'.
diff --git a/docs/MAKEPP b/docs/MAKEPP
index a4d44b7..4450e47 100644
--- a/docs/MAKEPP
+++ b/docs/MAKEPP
@@ -1,5 +1,5 @@
 As a special  exception, FreeType can also be  built with the 'makepp'
-build tool, available from http://makepp.sourceforge.net.
+build tool, available from https://makepp.sourceforge.net.
 
 Note, however,  that  you will need at least version 2.0  and pass the
 option --norc-substitution to have it work correctly.
diff --git a/docs/formats.txt b/docs/formats.txt
index 75aba92..e4acf97 100644
--- a/docs/formats.txt
+++ b/docs/formats.txt
@@ -165,8 +165,8 @@
     partially defined in MHP 1.0.3 (also called ETSI TS 101812 V1.3.1)
     section 7.4.
 
-      http://www.etsi.org/
-      http://webapp.etsi.org/workprogram/Report_WorkItem.asp?WKI_ID=18799
+      https://www.etsi.org/
+      https://webapp.etsi.org/workprogram/Report_WorkItem.asp?WKI_ID=18799
 
 [3] Support  is rudimentary  currently; some  tables or  data are  not
     loaded yet.
diff --git a/include/freetype/ftdriver.h b/include/freetype/ftdriver.h
index 1e6835d..779ee45 100644
--- a/include/freetype/ftdriver.h
+++ b/include/freetype/ftdriver.h
@@ -249,7 +249,7 @@
    *   of improving symmetry in glyphs through hinting the right-side bearing
    *   were no longer necessary.  This lead to what GDI calls 'natural
    *   widths' ClearType, see
-   *   http://www.beatstamm.com/typography/RTRCh4.htm#Sec21.  Since hinting
+   *   http://rastertragedy.com/RTRCh4.htm#Sec21.  Since hinting
    *   has extra resolution, most non-linearity went away, but it is still
    *   possible for hints to change the advance widths in this mode.
    *
@@ -262,7 +262,7 @@
    *   to determine the width in bi-level rendering, and then re-run in
    *   ClearType, with the difference in widths being absorbed in the font
    *   hints for ClearType (mostly in the white space of hints); see
-   *   http://www.beatstamm.com/typography/RTRCh4.htm#Sec20.  Somewhat by
+   *   http://rastertragedy.com/RTRCh4.htm#Sec20.  Somewhat by
    *   definition, compatible width ClearType allows for non-linear widths,
    *   but only when the bi-level version has non-linear widths.
    *
@@ -275,7 +275,7 @@
    *   mode', not to be confused with GDI's 'natural widths'.  Subpixel
    *   positioning, in the current implementation of Direct Write,
    *   unfortunately does not support hinted advance widths, see
-   *   http://www.beatstamm.com/typography/RTRCh4.htm#Sec22.  Note that the
+   *   http://rastertragedy.com/RTRCh4.htm#Sec22.  Note that the
    *   TrueType interpreter fully allows the advance width to be adjusted in
    *   this mode, just the DWrite client will ignore those changes.
    *
@@ -284,7 +284,7 @@
    *   This is a set of exceptions made in the TrueType interpreter to
    *   minimize hinting techniques that were problematic with the extra
    *   resolution of ClearType; see
-   *   http://www.beatstamm.com/typography/RTRCh4.htm#Sec1 and
+   *   http://rastertragedy.com/RTRCh4.htm#Sec1 and
    *   https://www.microsoft.com/typography/cleartype/truetypecleartype.aspx.
    *   This technique is not to be confused with ClearType compatible widths.
    *   ClearType backward compatibility has no direct impact on changing
diff --git a/src/psaux/pshints.c b/src/psaux/pshints.c
index 6b2bd7e..1cbecd2 100644
--- a/src/psaux/pshints.c
+++ b/src/psaux/pshints.c
@@ -1212,7 +1212,7 @@
      * (`u').
      *
      * See notation in
-     * http://softsurfer.com/Archive/algorithm_0104/algorithm_0104B.htm.
+     * http://geomalgorithms.com/a05-_intersect-1.html.
      * Calculations are done in 16.16, but must handle the squaring of
      * line lengths in character space.  We scale all vectors by 1/32 to
      * avoid overflow.  This allows values up to 4095 to be squared.  The
diff --git a/src/smooth/ftgrays.c b/src/smooth/ftgrays.c
index 871e981..7029e59 100644
--- a/src/smooth/ftgrays.c
+++ b/src/smooth/ftgrays.c
@@ -48,7 +48,7 @@
    * coverage of the outline on each pixel cell.
    *
    * It is based on ideas that I initially found in Raph Levien's
-   * excellent LibArt graphics library (see http://www.levien.com/libart
+   * excellent LibArt graphics library (see https://www.levien.com/libart
    * for more information, though the web pages do not tell anything
    * about the renderer; you'll have to dive into the source code to
    * understand how it works).
diff --git a/src/truetype/ttinterp.h b/src/truetype/ttinterp.h
index 172cdd0..eb2db75 100644
--- a/src/truetype/ttinterp.h
+++ b/src/truetype/ttinterp.h
@@ -352,7 +352,7 @@
      *     https://www.microsoft.com/typography/cleartype/truetypecleartype.aspx
      *
      * [3] Beat Stamm describes it in more detail:
-     *     http://www.beatstamm.com/typography/RTRCh4.htm#Sec12
+     *     http://rastertragedy.com/RTRCh4.htm#Sec12.
      *
      * [4] The list of `native ClearType' fonts is small at the time of this
      *     writing; I found the following on a Windows 10 Update 1511
