This is an automated email from the ASF dual-hosted git repository.

joshtynjala pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/royale-docs.git

commit 79703521e7c56d49d8a5825de90ac03627527332
Author: Josh Tynjala <[email protected]>
AuthorDate: Tue Apr 9 13:19:54 2024 -0700

    intro paragraphs should generally link to Apache Royale homepage, for those 
who might not be familiar with the project
---
 compiler.md                                                           | 2 +-
 compiler/compiler-options.md                                          | 2 +-
 compiler/release-build-file-size-optimization.md                      | 2 +-
 component-sets.md                                                     | 4 ++--
 component-sets/basic.md                                               | 2 +-
 component-sets/jewel.md                                               | 2 +-
 component-sets/jewel/jewel-themes.md                                  | 2 +-
 component-sets/mxroyale.md                                            | 2 +-
 component-sets/sparkroyale.md                                         | 2 +-
 create-an-application.md                                              | 2 +-
 create-an-application/application-structure.md                        | 2 +-
 create-an-application/application-tutorial.md                         | 2 +-
 create-an-application/application-tutorial/build.md                   | 2 +-
 create-an-application/application-tutorial/data-model.md              | 2 +-
 create-an-application/application-tutorial/view.md                    | 2 +-
 create-an-application/optimizations.md                                | 2 +-
 .../optimizations/compiler-configuration-settings.md                  | 2 +-
 create-an-application/optimizations/minification.md                   | 4 ++--
 create-an-application/security.md                                     | 2 +-
 features-and-concepts.md                                              | 2 +-
 features/as3/metadata.md                                              | 2 +-
 features/as3/reflection-introspection.md                              | 2 +-
 features/data-binding.md                                              | 2 +-
 features/external-interface.md                                        | 2 +-
 features/externs.md                                                   | 2 +-
 features/modules.md                                                   | 2 +-
 features/mxml.md                                                      | 2 +-
 features/nodejs.md                                                    | 2 +-
 features/nodejs/external-modules.md                                   | 2 +-
 features/nodejs/modules.md                                            | 2 +-
 features/nodejs/scripting.md                                          | 2 +-
 features/payg.md                                                      | 2 +-
 features/strands-and-beads.md                                         | 2 +-
 features/styles-skins-themes.md                                       | 2 +-
 formatter.md                                                          | 2 +-
 formatter/asformat-config-file.md                                     | 2 +-
 frameworks-and-libraries.md                                           | 3 ++-
 get-started.md                                                        | 2 +-
 get-started/development-tools.md                                      | 4 ++--
 get-started/download-royale.md                                        | 2 +-
 get-started/frameworks.md                                             | 2 +-
 get-started/hello-world.md                                            | 2 +-
 get-started/royale-cli.md                                             | 2 +-
 get-started/system-requirements.md                                    | 2 +-
 index.md                                                              | 2 +-
 libraries/crux.md                                                     | 2 +-
 libraries/library-basics.md                                           | 2 +-
 libraries/spectrum-royale.md                                          | 4 ++--
 linter.md                                                             | 2 +-
 linter/aslint-config-file.md                                          | 2 +-
 migrate-an-existing-app.md                                            | 2 +-
 migrate-an-existing-app/emulation.md                                  | 2 +-
 migrate-an-existing-app/flex-equivalents.md                           | 2 +-
 migrate-an-existing-app/migrate-from-flex.md                          | 2 +-
 presentations/presentations.md                                        | 2 +-
 testing.md                                                            | 2 +-
 testing/royaleunit.md                                                 | 2 +-
 testing/royaleunit/create-a-unit-test.md                              | 2 +-
 tutorials.md                                                          | 2 +-
 tutorials/royale-in-a-week.md                                         | 2 +-
 user-interface.md                                                     | 2 +-
 user-interface/alerts.md                                              | 2 +-
 user-interface/components.md                                          | 2 +-
 user-interface/layouts.md                                             | 2 +-
 welcome/get-involved.md                                               | 2 +-
 welcome/high-level-view.md                                            | 2 +-
 welcome/history.md                                                    | 2 +-
 welcome/licenses.md                                                   | 2 +-
 welcome/what-is-royale.md                                             | 2 +-
 welcome/why-royale.md                                                 | 2 +-
 working-with-data.md                                                  | 2 +-
 working-with-data/item-renderers.md                                   | 2 +-
 working-with-data/loading-external-data.md                            | 2 +-
 working-with-data/loading-external-data/amf.md                        | 2 +-
 working-with-data/loading-external-data/httpservice.md                | 2 +-
 working-with-data/loading-external-data/remoteobject.md               | 2 +-
 76 files changed, 81 insertions(+), 80 deletions(-)

diff --git a/compiler.md b/compiler.md
index ff9ea80..395d7fe 100644
--- a/compiler.md
+++ b/compiler.md
@@ -24,7 +24,7 @@ permalink: /compiler
 
 Turn your source code into compiled output
 
-Royale provides a compiler (some call it a transpiler or cross-compiler) and a 
command-line debugger to turn your source code into compiled output you can 
share with users. The compiler takes [AS3](features/as3), 
[MXML](features/mxml), and CSS as inputs. 
+[Apache Royale](https://royale.apache.org/) provides a compiler (some call it 
a transpiler or cross-compiler) and a command-line debugger to turn your source 
code into compiled output you can share with users. The compiler takes 
[AS3](features/as3), [MXML](features/mxml), and CSS as inputs. 
 
 The main output of the compiler is **JavaScript**. The compiler can also 
output **SWF**s for the **Adobe Flash** and **AIR** runtimes. There is some 
initial work on **Web Assembly** output.
 
diff --git a/compiler/compiler-options.md b/compiler/compiler-options.md
index b80cf6b..160be97 100644
--- a/compiler/compiler-options.md
+++ b/compiler/compiler-options.md
@@ -24,7 +24,7 @@ permalink: /compiler/compiler-options
 
 List of all available compiler options
 
-The [**mxmlc** and **compc** compilers](compiler) have a number of useful 
configuration options. The list below is also available by running `mxmlc -help 
advanced` in a terminal.
+The [**mxmlc** and **compc** compilers](compiler) bundled with [Apache 
Royale](https://royale.apache.org/) have a number of useful configuration 
options. The list below is also available by running `mxmlc -help advanced` in 
a terminal.
 
 - `-allow-dynamic-bindings` -- Controls whether data binding may use 
reflection for dynamic access.
 - `-api-report` `<filename>` -- Used to generate a report of APIs used in a 
project.  
diff --git a/compiler/release-build-file-size-optimization.md 
b/compiler/release-build-file-size-optimization.md
index 5937065..f49f071 100644
--- a/compiler/release-build-file-size-optimization.md
+++ b/compiler/release-build-file-size-optimization.md
@@ -23,7 +23,7 @@ permalink: /compiler/release-build-file-size-optimization
 
 Reduce the size of release builds
 
-A number of [compiler options](compiler/compiler-options) are available for 
Royale that allow you to reduce the output size of JavaScript release builds. 
However, using these options may also prevent certain coding patterns in 
ActionScript and JavaScript (such as reflection capabilities) from working 
correctly, so read carefully to understand what the tradeoffs are for enabling 
these options and whether it will affect how you must write your code.
+A number of [compiler options](compiler/compiler-options) are available for 
[Apache Royale](https://royale.apache.org/) that allow you to reduce the output 
size of JavaScript release builds. However, using these options may also 
prevent certain coding patterns in ActionScript and JavaScript (such as 
reflection capabilities) from working correctly, so read carefully to 
understand what the tradeoffs are for enabling these options and whether it 
will affect how you must write your code.
 
 There are two main ways to reduce the size of a release build:
 
diff --git a/component-sets.md b/component-sets.md
index efe5b1d..9de5224 100644
--- a/component-sets.md
+++ b/component-sets.md
@@ -22,9 +22,9 @@ permalink: /component-sets
 
 # Component Sets
 
-Sets of components and containers designed in Apache Royale.
+Sets of components and containers designed in [Apache 
Royale](https://royale.apache.org/).
 
-Royale provides its own component sets that support developing simple, small 
and fast applications for prototyping and as the basis of complete application 
user interfaces:
+[Apache Royale](https://royale.apache.org/) provides its own component sets 
that support developing simple, small and fast applications for prototyping and 
as the basis of complete application user interfaces:
 
 - [Basic](component-sets/basic) is the smallest, fastest and most 
[PAYG](features/payg) set of components possible in Royale, and is used by 
other sets like Jewel as its base.
 
diff --git a/component-sets/basic.md b/component-sets/basic.md
index 879533b..c03d3c6 100644
--- a/component-sets/basic.md
+++ b/component-sets/basic.md
@@ -24,7 +24,7 @@ permalink: /component-sets/basic
 
 The most smallest, fastest and PAYG set
 
-is the most smallest, fastest and PAYG set of components possible in Royale, 
and is used by other sets like Jewel as its base.
+is the most smallest, fastest and PAYG set of components possible in [Apache 
Royale](https://royale.apache.org/), and is used by other sets like Jewel as 
its base.
 
 *information coming soon.*
 
diff --git a/component-sets/jewel.md b/component-sets/jewel.md
index ca81bb0..c777e53 100644
--- a/component-sets/jewel.md
+++ b/component-sets/jewel.md
@@ -24,7 +24,7 @@ permalink: /component-sets/jewel
 
 A set of modern UI components
 
-Jewel is a themeable and responsive set of user interface components for 
Apache Royale to help you quickly build the front end of your applications with 
[ActionScript](features/as3) & [MXML](features/mxml).
+Jewel is a themeable and responsive set of user interface components for 
[Apache Royale](https://royale.apache.org/) to help you quickly build the front 
end of your applications with [ActionScript](features/as3) & 
[MXML](features/mxml).
 
 It's based by design on [Basic](component-sets/basic) components. But while 
Basic is very strict with concepts like [PAYG](features/payg), in Jewel, while 
PAYG is important, when necessary we prioritize other things like 
responsiveness, themes and look and feel.
 
diff --git a/component-sets/jewel/jewel-themes.md 
b/component-sets/jewel/jewel-themes.md
index ba22671..8305428 100644
--- a/component-sets/jewel/jewel-themes.md
+++ b/component-sets/jewel/jewel-themes.md
@@ -29,7 +29,7 @@ The Jewel component set focuses on themes. When you set the 
theme of an applicat
 
 A theme is a predefined CSS file (and optionally other assets like images) 
that holds the definitions of each Jewel component, its subcomponents and the 
default [beads](features/strands-and-beads) used to configure the components. 
 
-Royale uses a theme to add the right css selectors to the final compilation so 
when the user loads the application the required css and other files are loaded 
and the application shows a concrete look and feel.
+[Apache Royale](https://royale.apache.org/) uses a theme to add the right css 
selectors to the final compilation so when the user loads the application the 
required css and other files are loaded and the application shows a concrete 
look and feel.
 
 ## Colors
 
diff --git a/component-sets/mxroyale.md b/component-sets/mxroyale.md
index 7fcd205..5bbdc3f 100644
--- a/component-sets/mxroyale.md
+++ b/component-sets/mxroyale.md
@@ -24,7 +24,7 @@ permalink: /component-sets/mxroyale
 
 Emulations of Flex UIComponent
 
-This component set includes Royale components that reproduce the functions of 
some UI components many applications used in Flex. These components do not 
promise 100% backward compatibility and may not use the same class hierarchy as 
Flex.
+This component set includes [Apache Royale](https://royale.apache.org/) 
components that reproduce the functions of some UI components many applications 
used in Flex. These components do not promise 100% backward compatibility and 
may not use the same class hierarchy as Flex.
 
 The source code for these emulations is in the SDK at 
frameworks/projects/MXRoyale/src/main/royale.
 
diff --git a/component-sets/sparkroyale.md b/component-sets/sparkroyale.md
index a9efa66..ab20e03 100644
--- a/component-sets/sparkroyale.md
+++ b/component-sets/sparkroyale.md
@@ -24,7 +24,7 @@ permalink: /component-sets/sparkroyale
 
 Emulations of Flex Spark components
 
-This component set includes Royale components that reproduce the functions of 
some UI components many applications used in Flex. These components do not 
promise 100% backward compatibility and may not use the same class hierarchy as 
Flex.
+This component set includes [Apache Royale](https://royale.apache.org/) 
components that reproduce the functions of some UI components many applications 
used in Flex. These components do not promise 100% backward compatibility and 
may not use the same class hierarchy as Flex.
 
 The source code for these emulations is in the SDK at 
frameworks/projects/SparkRoyale/src/main/royale.
 
diff --git a/create-an-application.md b/create-an-application.md
index 5850998..e8de64a 100644
--- a/create-an-application.md
+++ b/create-an-application.md
@@ -24,7 +24,7 @@ permalink: /create-an-application
 
 Building your first Apache Royale application
 
-The easiest way to create a Royale application is to start with an existing 
one and modify it.  In the examples folder are several examples you can use as 
a starting point.  But if you want to know more about the underlying 
principles, read on.
+The easiest way to create an [Apache Royale](https://royale.apache.org/) 
application is to start with an existing one and modify it.  In the examples 
folder are several examples you can use as a starting point.  But if you want 
to know more about the underlying principles, read on.
 
 This document is divided into several sections:
 
diff --git a/create-an-application/application-structure.md 
b/create-an-application/application-structure.md
index 5ef2b8d..86c45fe 100644
--- a/create-an-application/application-structure.md
+++ b/create-an-application/application-structure.md
@@ -24,7 +24,7 @@ permalink: /create-an-application/application-structure
 
 All about the organization of your project files and folders
 
-Royale applications usually include many files. If you are in 
rapid-prototyping or proof-of-concept "get something small running quickly" 
mode, you can cram everything into one file. But breaking things into multiple 
pieces often helps you organize your code and create "separation of concerns"; 
and as your project and team grows, you and your teammates can work on 
individual pieces independently without stepping on each other's work. Finally, 
you can more easily re-use coherent pieces th [...]
+[Apache Royale](https://royale.apache.org/) applications usually include many 
files. If you are in rapid-prototyping or proof-of-concept "get something small 
running quickly" mode, you can cram everything into one file. But breaking 
things into multiple pieces often helps you organize your code and create 
"separation of concerns"; and as your project and team grows, you and your 
teammates can work on individual pieces independently without stepping on each 
other's work. Finally, you can  [...]
 
 There are multiple popular ways of dividing an application into coherent and 
reusable pieces: Model-View (MV), Model-View-Controller (MVC), and other 
alphabet soup like MVP, MVVM, HMVC and more. This documentation will not 
address these patterns in detail. You can read more about them on the internet.
 
diff --git a/create-an-application/application-tutorial.md 
b/create-an-application/application-tutorial.md
index f68bf5e..148ab5b 100644
--- a/create-an-application/application-tutorial.md
+++ b/create-an-application/application-tutorial.md
@@ -24,7 +24,7 @@ permalink: /create-an-application/application-tutorial
 
 A complete tutorial on how to build a simple Royale application
 
-This tutorial will take you through building an app that displays the commit 
logs for the Apache Royale project by connecting to its 
[GitHub](https://github.com){:target='_blank'} repository on the Apache servers.
+This tutorial will take you through building an app that displays the commit 
logs for the [Apache Royale](https://royale.apache.org/) project by connecting 
to its [GitHub](https://github.com){:target='_blank'} repository on the Apache 
servers.
 
 At the end of this tutorial we'll get the following:
 
diff --git a/create-an-application/application-tutorial/build.md 
b/create-an-application/application-tutorial/build.md
index dc0b0b8..de90892 100644
--- a/create-an-application/application-tutorial/build.md
+++ b/create-an-application/application-tutorial/build.md
@@ -24,7 +24,7 @@ permalink: /create-an-application/application-tutorial/build
 
 Building the application
 
-In many other *HTML/JS/CSS* development models, you write the *JS* and then 
just view it in the browser. Royale uses a compiler to convert your *MXML* and 
*ActionScript* code into *HTML/JS/CSS*. Why? Because there is a philosophy that 
the sooner you catch a bug, the less expensive it is to fix it. The compiler 
scans your source code to make sure that it makes sense. The compiler checks 
that there aren't typos in property names, that if you are expecting a `String` 
you'll probably get one [...]
+In many other *HTML/JS/CSS* development models, you write the *JS* and then 
just view it in the browser. [Apache Royale](https://royale.apache.org/) uses a 
compiler to convert your *MXML* and *ActionScript* code into *HTML/JS/CSS*. 
Why? Because there is a philosophy that the sooner you catch a bug, the less 
expensive it is to fix it. The compiler scans your source code to make sure 
that it makes sense. The compiler checks that there aren't typos in property 
names, that if you are expecti [...]
 
 The main *MXML* file should now look like this:
 
diff --git a/create-an-application/application-tutorial/data-model.md 
b/create-an-application/application-tutorial/data-model.md
index 8ea0c56..256d470 100644
--- a/create-an-application/application-tutorial/data-model.md
+++ b/create-an-application/application-tutorial/data-model.md
@@ -24,7 +24,7 @@ permalink: 
/create-an-application/application-tutorial/data-model
 
 Abstract model that organizes elements of data for easy use in the application
 
-Since the goal of this application is to display a list of commits to the 
Royale GitHub repositories (repos), the data the application will work with 
must include that list of commits. The application will query GitHub for the 
information, place what GitHub provides in a data structure, and then connect 
that data structure to components in the user interface that can display it.
+Since the goal of this application is to display a list of commits to the 
[Apache Royale](https://royale.apache.org/) GitHub repositories (repos), the 
data the application will work with must include that list of commits. The 
application will query GitHub for the information, place what GitHub provides 
in a data structure, and then connect that data structure to components in the 
user interface that can display it.
 
 > For large projects, the model is often built in a separate class and source 
 > file so it can be separately developed, documented, and maintained (maybe by 
 > other team members). But to get something up quickly, we are going to just 
 > stick a few variables in the main application file in a script block.
 
diff --git a/create-an-application/application-tutorial/view.md 
b/create-an-application/application-tutorial/view.md
index c135a85..7b95545 100644
--- a/create-an-application/application-tutorial/view.md
+++ b/create-an-application/application-tutorial/view.md
@@ -24,7 +24,7 @@ permalink: /create-an-application/application-tutorial/view
 
 Contains the user interface elements that display data and accept user input
 
-In an 
[MVC](https://en.wikipedia.org/wiki/Model–view–controller){:target='_blank'} 
application the **View** contains the user interface elements that display data 
and accept user input. We want a way to display the list of commits and also 
some useful information about those commits. In Royale a popular way to do that 
is with a 
[DataGrid](https://royale.apache.org/asdoc/index.html#!org.apache.royale.html/DataGrid){:target='_blank'}.
+In an 
[MVC](https://en.wikipedia.org/wiki/Model–view–controller){:target='_blank'} 
application the **View** contains the user interface elements that display data 
and accept user input. We want a way to display the list of commits and also 
some useful information about those commits. In [Apache 
Royale](https://royale.apache.org/) a popular way to do that is with a 
[DataGrid](https://royale.apache.org/asdoc/index.html#!org.apache.royale.html/DataGrid){:target='_blank'}.
 
 The main or initial view of an application is identified as its `initialView` 
property. We want our user interface elements to appear vertically so we use 
[VView](https://royale.apache.org/asdoc/index.html#!org.apache.royale.express/VView){:target='_blank'}
 as the view:
 
diff --git a/create-an-application/optimizations.md 
b/create-an-application/optimizations.md
index 015b3be..515e9f4 100644
--- a/create-an-application/optimizations.md
+++ b/create-an-application/optimizations.md
@@ -25,7 +25,7 @@ Strategies to use when optimizing your document output
 
 ## Optimization options
 
-The following content explains optimizations for javascript output that you 
can use when configuring the Royale compiler directly or by using doc-comment 
directives in your ActionScript code.  
+The following content explains optimizations for javascript output that you 
can use when configuring the [Apache Royale](https://royale.apache.org/) 
compiler directly or by using doc-comment directives in your ActionScript code. 
 
 Many settings have corresponding approaches between the over-arching compiler 
level influence of compilation settings and those with more specificity at the 
code level, so to avoid repetition, it is recommended that you get familiar 
with the Compiler settings first.
 
 [Minification](create-an-application/optimizations/minification) What options 
you have for minifying your app for release and considerations when customizing 
the minified output.
diff --git 
a/create-an-application/optimizations/compiler-configuration-settings.md 
b/create-an-application/optimizations/compiler-configuration-settings.md
index 99a512c..430bea7 100644
--- a/create-an-application/optimizations/compiler-configuration-settings.md
+++ b/create-an-application/optimizations/compiler-configuration-settings.md
@@ -24,7 +24,7 @@ permalink: 
/create-an-application/optimizations/compiler-configuration-settings
 
 Optimization options
 
-This page explains optimizations for JavaScript output that you can use when 
configuring the Royale compiler directly. Often these settings involve removing 
some JavaScript emulations of runtime type-safety that are present in AVM. This 
can help to improve application performance and/or reduce the size of your 
final application build.
+This page explains optimizations for JavaScript output that you can use when 
configuring the [Apache Royale](https://royale.apache.org/) compiler directly. 
Often these settings involve removing some JavaScript emulations of runtime 
type-safety that are present in AVM. This can help to improve application 
performance and/or reduce the size of your final application build.
 
 It can be useful to develop your application with these settings 'on' and then 
consider switching them to 'off' for your release build, when you have assured 
yourself it is safe to do so.
 
diff --git a/create-an-application/optimizations/minification.md 
b/create-an-application/optimizations/minification.md
index b68ed68..01629d2 100644
--- a/create-an-application/optimizations/minification.md
+++ b/create-an-application/optimizations/minification.md
@@ -21,9 +21,9 @@ permalink: /create-an-application/optimizations/minification
 ---
 # Minification
 
-Minification is the process of minimizing code and markup in your application. 
It’s one of the main methods to reduce load times and improve application 
performance.
+Minification is the process of minimizing code and markup in your application. 
It's one of the main methods to reduce load times and improve application 
performance.
 
-Here are options and considerations for minimizing JavaScript output in your 
Royale application.
+Here are options and considerations for minimizing JavaScript output in your 
[Apache Royale](https://royale.apache.org/) application.
 
 ## Default behavior
 By default, Royale outputs a single minified JavaScript file for deployment of 
the application. The minified file contains all the code needed for running 
your application. The code contains the necessary pieces of framework code as 
well as your application code. The minification uses Google's Closure Compiler. 
The goal for the default release output is that it should always work without 
consideration for how the code was written.
diff --git a/create-an-application/security.md 
b/create-an-application/security.md
index e95d5f3..350ad68 100644
--- a/create-an-application/security.md
+++ b/create-an-application/security.md
@@ -24,7 +24,7 @@ permalink: /create-an-application/security
 
 Target environment security rules
 
-Royale can output a SWF that runs on the Adobe Flash/AIR runtimes or 
HTML/JS/CSS that run in browsers and other environments that support 
JavaScript, such as Node.
+[Apache Royale](https://royale.apache.org/) can output a SWF that runs on the 
Adobe Flash/AIR runtimes or HTML/JS/CSS that run in browsers and other 
environments that support JavaScript, such as Node.js.
 
 Each runtime environment has its own security rules. Here are links to 
security documentation for these runtimes:
 
diff --git a/features-and-concepts.md b/features-and-concepts.md
index 973efd7..497f2df 100644
--- a/features-and-concepts.md
+++ b/features-and-concepts.md
@@ -24,7 +24,7 @@ permalink: /features-and-concepts
 
 Key points about Apache Royale
 
-Here are some things that will help you be more productive with Royale, 
although some folks get pretty far by just following the tutorial in [Create an 
Application](create-an-application) and extending it.
+Here are some things that will help you be more productive with [Apache 
Royale](https://royale.apache.org/), although some folks get pretty far by just 
following the tutorial in [Create an Application](create-an-application) and 
extending it.
 
 ## AS3 and MXML Languages
 
diff --git a/features/as3/metadata.md b/features/as3/metadata.md
index 714adf7..68327fb 100644
--- a/features/as3/metadata.md
+++ b/features/as3/metadata.md
@@ -24,7 +24,7 @@ permalink: /features/as3/metadata
 
 Decorate classes, properties and methods with extra information that can be 
used at compile or run time
 
-Metadata decorate classes, properties and methods to give extra data to the 
compiler that can be used to generate code at compile time that depends on that 
metadata values, or can be used at runtime for code that can interpret that 
data to perform some specific functionality. You can use it in 
[AS3](features/as3) & [MXML](features/mxml).
+Metadata decorate classes, properties and methods to give extra data to the 
compiler that can be used to generate code at compile time that depends on that 
metadata values, or can be used at runtime for code that can interpret that 
data to perform some specific functionality. With [Apache 
Royale](https://royale.apache.org/), you can use meta in both 
[AS3](features/as3) and [MXML](features/mxml).
 
 An example in **AS3** of a `Bindable` Metadata declaration decorating a 
variable is the following:
 
diff --git a/features/as3/reflection-introspection.md 
b/features/as3/reflection-introspection.md
index 712aa47..7e4e514 100644
--- a/features/as3/reflection-introspection.md
+++ b/features/as3/reflection-introspection.md
@@ -23,7 +23,7 @@ permalink: /features/as3/reflection-introspection
 
 Finding the class and details of an object
 
-Reflection and introspection are in the Royale `Reflection` library.
+Reflection and introspection are in the [Apache 
Royale](https://royale.apache.org/) `Reflection` library.
 
 Royale supports class reflection and introspection using the following 
functions in the `org.apache.royale.reflection` package:
 
diff --git a/features/data-binding.md b/features/data-binding.md
index 88468ab..78a3f05 100644
--- a/features/data-binding.md
+++ b/features/data-binding.md
@@ -23,7 +23,7 @@ permalink: /features/data-binding
 
 Update the UI in real time as data changes
 
-Royale, like Flex before it, makes it easy to pass data around your 
application. A change to data can automatically update the display of that data 
in the user interface, and potentially in calculations or other functions that 
use that data. The feature that makes this possible without having to write 
lots of code is *data binding*.
+[Apache Royale](https://royale.apache.org/), like Flex before it, makes it 
easy to pass data around your application. A change to data can automatically 
update the display of that data in the user interface, and potentially in 
calculations or other functions that use that data. The feature that makes this 
possible without having to write lots of code is *data binding*.
 
 Data binding requires
  - a **data binding bead** that adds this functionality to the whole 
application, or to the container in which the data binding happens. If you 
enable data binding for a container, it only applies to the componenents within 
that container; if you enable it at the application level, all application 
components inherit the ability to use data binding.
diff --git a/features/external-interface.md b/features/external-interface.md
index 131d7d5..5557c99 100644
--- a/features/external-interface.md
+++ b/features/external-interface.md
@@ -26,7 +26,7 @@ Calling to/from External JavaScript
 
 In Flash, there is a class, 
[ExternalInterface](https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/loading-external-data/ExternalInterface.html){:target='_blank'},
 that lets your Flex (or Flash) application call other JavaScript code that has 
been embedded on the hosting web page,
-and lets external JavaScript code call a function within the Flex application. 
When you port a Flex application to Royale,
+and lets external JavaScript code call a function within the Flex application. 
When you port a Flex application to [Apache Royale](https://royale.apache.org/),
 you may need to replicate this functionality.
 
 > To make this easier, there is an implementation of the same API available as 
 > [mx.external.ExternalInterface](https://github.com/apache/royale-asjs/blob/develop/frameworks/projects/MXRoyale/src/main/royale/mx/loading-external-data/ExternalInterface.as){:target='_blank'}.
 >  You should be able to just rename your imports from 
 > `flash.external.ExternalInterface` to `mx.external.ExternalInterface`.
diff --git a/features/externs.md b/features/externs.md
index 56ec045..a9b18cb 100644
--- a/features/externs.md
+++ b/features/externs.md
@@ -24,7 +24,7 @@ permalink: /features/externs
 
 Use external JavaScript libraries in ActionScript
 
-Some Apache Royale elements have limited cross-browser support at the moment. 
To get reliable display and performance in those cases, Royale makes use of 
existing external JavaScript libraries. For example, [Jewel 
Alert](https://apache.github.io/royale-docs/component-sets/jewel/alert) uses 
the HTML dialog element, which is not reliable across all browsers. So Jewel 
Alert references the _dialogPolyfill_ external library to make sure the display 
is as intended in whichever browser the aler [...]
+Some [Apache Royale](https://royale.apache.org/) elements have limited 
cross-browser support at the moment. To get reliable display and performance in 
those cases, Royale makes use of existing external JavaScript libraries. For 
example, [Jewel 
Alert](https://apache.github.io/royale-docs/component-sets/jewel/alert) uses 
the HTML dialog element, which is not reliable across all browsers. So Jewel 
Alert references the _dialogPolyfill_ external library to make sure the display 
is as intended [...]
 
 [Google Closure Compiler 
(GCC)](https://developers.google.com/closure/compiler){:target='_blank'} 
provides a mechanism called _@externs_ that Apache Royale uses to declare that 
a name for a class, property or function is defined in external code and so 
should not be renamed when application code is compiled.
 
diff --git a/features/modules.md b/features/modules.md
index 7f6e94a..d9ea53e 100644
--- a/features/modules.md
+++ b/features/modules.md
@@ -24,7 +24,7 @@ permalink: /features/modules
 
 Break your application in parts
 
-Royale supports a distributed development model called **modules**. Those 
familiar with [Apache Flex](https://flex.apache.org/){:target='_blank'} SDK 
will recognize the term. Royale modules work almost identically to Flex modules 
with a few differences.
+[Apache Royale](https://royale.apache.org/) supports a distributed development 
model called **modules**. Those familiar with [Apache 
Flex](https://flex.apache.org/){:target='_blank'} SDK will recognize the term. 
Royale modules work almost identically to Flex modules with a few differences.
 
 An example of an Application loading a Module can be seen below:
 
diff --git a/features/mxml.md b/features/mxml.md
index e2173a5..414e89a 100644
--- a/features/mxml.md
+++ b/features/mxml.md
@@ -24,7 +24,7 @@ permalink: /features/mxml
 
 The declarative XML-based user interface markup language
 
-MXML is an XML-based language introduced in 2004 by Macromedia. In Royale you 
use it to lay out user-interface components. You can create an application in 
Royale using only [ActionScript](features/as3), but it takes a lot more work.
+MXML is an XML-based language introduced in 2004 by Macromedia. In [Apache 
Royale](https://royale.apache.org/) you use it to lay out user-interface 
components. You can create an application in Royale using only 
[ActionScript](features/as3), but it takes a lot more work.
 
 Most Royale applications have an MXML file as the main file. It provides the 
structure of the application. The main MXML file from our very simple <a 
href="https://apache.github.io/royale-docs/get-started/hello-world"; 
target="_blank">hello world example</a> looks a bit like this:
 
diff --git a/features/nodejs.md b/features/nodejs.md
index 9cd6b67..4c4be54 100644
--- a/features/nodejs.md
+++ b/features/nodejs.md
@@ -24,7 +24,7 @@ permalink: /features/nodejs
 
 Compile AS3 code to JS and run on Node.js
 
-Apache Royale can transpile [ActionScript](features/as3) to JavaScript and run 
on [Node.js](https://nodejs.org/). In this way you get all the benefits of AS3 
language in Node. Check the following topics to get started:
+[Apache Royale](https://royale.apache.org/) can transpile 
[ActionScript](features/as3) to JavaScript and run on 
[Node.js](https://nodejs.org/). In this way you get all the benefits of AS3 
language in Node. Check the following topics to get started:
 
  * [Command line scripting](features/nodejs/scripting) explains how to call 
Node.js APIs from ActionScript, compile to JavaScript, and run the generated 
script from the command line.
 
diff --git a/features/nodejs/external-modules.md 
b/features/nodejs/external-modules.md
index 2ab9ecb..ad25286 100644
--- a/features/nodejs/external-modules.md
+++ b/features/nodejs/external-modules.md
@@ -24,7 +24,7 @@ permalink: /features/nodejs/external-modules
 
 Expose Node.js modules installed from the npm registry to ActionScript
 
-By creating [type definitions](features/externs) with special metadata, 
developers can use [Node.js](features/nodejs) modules from 
[ActionScript](features/as3) code.
+By creating [type definitions](features/externs) with special metadata, 
developers can use [Node.js](features/nodejs) modules from 
[ActionScript](features/as3) code using [Apache 
Royale](https://royale.apache.org/).
 
 Let's try to use the [boxen](https://www.npmjs.com/package/boxen) module from 
[the npm registry](https://www.npmjs.com/) in ActionScript. This module draws a 
box around a string to display in the console, and it exposes many styling 
options like colors, borders, and alignment.
 
diff --git a/features/nodejs/modules.md b/features/nodejs/modules.md
index 470dc91..5440419 100644
--- a/features/nodejs/modules.md
+++ b/features/nodejs/modules.md
@@ -24,7 +24,7 @@ permalink: /features/nodejs/modules
 
 Write modules with ActionScript that can be loaded with `require()` in Node.js
 
-One of the reasons why the [Node.js](features/nodejs) ecosystem is so vibrant 
is the massive number of open source modules available to install from [the npm 
registry](https://www.npmjs.com/). Those modules are all deployed as 
JavaScript, but they can be written in a variety of languages that can compile 
to JavaScript, including [ActionScript](features/as3).
+One of the reasons why the [Node.js](features/nodejs) ecosystem is so vibrant 
is the massive number of open source modules available to install from [the npm 
registry](https://www.npmjs.com/). Those modules are all deployed as 
JavaScript, but they can be written in a variety of languages that can compile 
to JavaScript, including [ActionScript](features/as3) with [Apache 
Royale](https://royale.apache.org/).
 
 ## A simple module
 
diff --git a/features/nodejs/scripting.md b/features/nodejs/scripting.md
index 3d6e359..8b69069 100644
--- a/features/nodejs/scripting.md
+++ b/features/nodejs/scripting.md
@@ -24,7 +24,7 @@ permalink: /features/nodejs/scripting
 
 Write command line scripts for Node.js using ActionScript
 
-Much of the JavaScript development ecosystem is powered by 
[Node.js](https://nodejs.org/). This runtime is used for simple command line 
scripts, web servers, and more. With the help of Apache Royale, developers can 
use [ActionScript](features/as3) to create their own tools that run on Node.js.
+Much of the JavaScript development ecosystem is powered by 
[Node.js](https://nodejs.org/). This runtime is used for simple command line 
scripts, web servers, and more. With the help of [Apache 
Royale](https://royale.apache.org/), developers can use 
[ActionScript](features/as3) to create their own tools that run on Node.js.
 
 ## Hello, Node.js
 
diff --git a/features/payg.md b/features/payg.md
index d6ce3cb..20e1d06 100644
--- a/features/payg.md
+++ b/features/payg.md
@@ -24,7 +24,7 @@ permalink: /features/payg
 
 Pay as you go
 
-_Pay as you go (PAYG)_ is a general principle for Royale. The SDK framework 
code (the _ActionScript_ codebase used to create Royale SDK libraries) supports 
incremental functionality in components. The goal is to provide components 
that, used just as they are, require very little memory to provide the 
component's most basic functions; and that can be extended to support functions 
that are needed sometimes, but not always. 
+_Pay as you go (PAYG)_ is a general principle for [Apache 
Royale](https://royale.apache.org/). The SDK framework code (the _ActionScript_ 
codebase used to create Royale SDK libraries) supports incremental 
functionality in components. The goal is to provide components that, used just 
as they are, require very little memory to provide the component's most basic 
functions; and that can be extended to support functions that are needed 
sometimes, but not always. 
 
 For example, the most basic thing a text-input component needs to do is accept 
text the user provides. You might have lots and lots of instances of this 
component in your application, and only a handful of them have to be able to 
support entering _passwords_ by displaying as dots the characters the user 
enters. For those instances only, we PAYG by extending the base component's 
functionality and its "cost" in memory use and impact on the application's 
performance.
 
diff --git a/features/strands-and-beads.md b/features/strands-and-beads.md
index 07b9abc..ea0751b 100644
--- a/features/strands-and-beads.md
+++ b/features/strands-and-beads.md
@@ -24,7 +24,7 @@ permalink: /features/strands-and-beads
 
 Adding functionality to a component through composition
 
-Strands and beads are key concepts in Royale, related to the 
[PAYG](features/payg)  (pay as you go) concept. The idea is to keep component 
code as lightweight as possible, and to add functionality and complexity only 
to the components that need it.
+Strands and beads are key concepts in [Apache 
Royale](https://royale.apache.org/), related to the [PAYG](features/payg)  (pay 
as you go) concept. The idea is to keep component code as lightweight as 
possible, and to add functionality and complexity only to the components that 
need it.
 
 {:align="center"}
 ![Fig 1: MVC with Strands and 
Beads](assets/images/strand-beads/strand-bead-1.jpg){:height="70%" width="70%"}
diff --git a/features/styles-skins-themes.md b/features/styles-skins-themes.md
index 1606cc8..97e4847 100644
--- a/features/styles-skins-themes.md
+++ b/features/styles-skins-themes.md
@@ -24,7 +24,7 @@ permalink: /features/styles-skins-themes
 
 Customizing the look and feel of your application
 
-Royale provides three features for adjusting the look and feel of your 
application: styles, skins, and themes.
+[Apache Royale](https://royale.apache.org/) provides three features for 
adjusting the look and feel of your application: styles, skins, and themes.
 
 ## Styles
 
diff --git a/formatter.md b/formatter.md
index 305b1e4..4c77b84 100644
--- a/formatter.md
+++ b/formatter.md
@@ -26,7 +26,7 @@ Format your _.as_ and _.mxml_ source files
 
 ## User Guide
 
-Below are some pointers to help you get started with the Royale formatter in 
various environments.
+Below are some pointers to help you get started with the [Apache 
Royale](https://royale.apache.org/) formatter in various environments.
 
 ### Command line
 
diff --git a/formatter/asformat-config-file.md 
b/formatter/asformat-config-file.md
index eb6180c..153345b 100644
--- a/formatter/asformat-config-file.md
+++ b/formatter/asformat-config-file.md
@@ -24,7 +24,7 @@ permalink: /formatter/asformat-config-file
 
 Configure the Royale formatter for a specific project
 
-If the current working directory contains an _asformat-config.xml_ file, the 
[**asformat**](formatter/) tool will conveniently load this file automatically 
to configure its options.
+If the current working directory contains an _asformat-config.xml_ file, the 
[**asformat**](formatter/) tool included with [Apache 
Royale](https://royale.apache.org/) will conveniently load this file 
automatically to configure its options.
 
 The root of this file is an `<asformat-config>` element. To specify a 
[formatter option](formatter/formatter-options), add it as a child element.
 
diff --git a/frameworks-and-libraries.md b/frameworks-and-libraries.md
index 1abbf9c..56a238f 100644
--- a/frameworks-and-libraries.md
+++ b/frameworks-and-libraries.md
@@ -27,7 +27,8 @@ Pre-written sets of code which allows for easier development 
of Royale-based app
 Frameworks provide reliable templates to help you develop complex projects 
more easily and sustainably. Libraries are generally collections of modules and 
functions that focus on a particular task or theme--you might find a library to 
help you with scientific calculations, and another library for manipulating 
graphics.
 
 ## Frameworks
-Apache Royale itself is a framework. It can play well with other frameworks to 
help simplify development, especially when many people are working on the same 
project.
+
+[Apache Royale](https://royale.apache.org/) itself is a framework. It can play 
well with other frameworks to help simplify development, especially when many 
people are working on the same project.
 
 ### Designed for Apache Royale:
 
diff --git a/get-started.md b/get-started.md
index b1b3c8e..41522ee 100644
--- a/get-started.md
+++ b/get-started.md
@@ -26,7 +26,7 @@ All you need to know to start developing with Apache Royale
 
 ## Introduction
 
-Royale is an open source project. You can get the [source 
code](http://royale.apache.org/source-code){:target='_blank'} and build Royale, 
or, if you are in a hurry, you can [click 
here](https://royale.apache.org/download){:target='_blank'} to find out how to 
download pre-compiled code and get going quickly.
+[Apache Royale](https://royale.apache.org/) is an open source project. You can 
get the [source code](http://royale.apache.org/source-code){:target='_blank'} 
and build Royale, or, if you are in a hurry, you can [click 
here](https://royale.apache.org/download){:target='_blank'} to find out how to 
download pre-compiled code and get going quickly.
 
 In Apache Royale you develop your applications using ActionScript 3 (AS3) and 
MXML languages. Your source code is build with the Royale compiler to generate 
the final Application that will run on the chosen platform.
 
diff --git a/get-started/development-tools.md b/get-started/development-tools.md
index aea08db..5615ab5 100644
--- a/get-started/development-tools.md
+++ b/get-started/development-tools.md
@@ -24,11 +24,11 @@ permalink: /get-started/development-tools
 
 Software tools to help you while developing Royale code
 
-You can just use any standard text editor to write Royale applications and the 
command-line to compile them, but you may find that an Interactive Development 
Environment (IDE) can make you even more productive.
+You can just use any standard text editor to write [Apache 
Royale](https://royale.apache.org/) applications and the command-line to 
compile them, but you may find that an Interactive Development Environment 
(IDE) can make you even more productive.
 
 ## IDEs
 
-IDEs that support Apache Royale provide getting-started instructions to help 
you specify using Royale for a new project, or importing an existing Royale 
project.
+IDEs that support Royale provide getting-started instructions to help you 
specify using Royale for a new project, or importing an existing Royale project.
 
 ### IDEs with Royale support
 
diff --git a/get-started/download-royale.md b/get-started/download-royale.md
index d6ad99f..4c7a000 100644
--- a/get-started/download-royale.md
+++ b/get-started/download-royale.md
@@ -24,7 +24,7 @@ permalink: /get-started/download-royale
 
 know how you can grab your bits
 
-You can download Apache Royale via [Node Package Manager 
(npm)](https://www.npmjs.com/){:target='_blank'}, or from mirrors of Apache 
releases. NPM is typically simpler, especially if you have Node.js installed 
already.
+You can download [Apache Royale](https://royale.apache.org/) via [Node Package 
Manager (npm)](https://www.npmjs.com/){:target='_blank'}, or from mirrors of 
Apache releases. NPM is typically simpler, especially if you have Node.js 
installed already.
 
 ## NPM
 
diff --git a/get-started/frameworks.md b/get-started/frameworks.md
index 404f0cf..f1db85a 100644
--- a/get-started/frameworks.md
+++ b/get-started/frameworks.md
@@ -26,7 +26,7 @@ Sets of code libraries availables in Royale
 
 A framework is a set of code that provides support for application development 
by offering templates, components and examples. Developers using Adobe and 
Apache Flex benefitted from a number of frameworks, including: Tide, Swiz, 
Parsley, Cairngorm, PureMVC, DropAS3, Fabrication, Mate, and RobotLegs.
 
-Royale provides its own framework for making simple, small and fast 
applications, but also offers support for deploying additional Royale 
frameworks and using popular JavaScript frameworks.
+[Apache Royale](https://royale.apache.org/) provides its own framework for 
making simple, small and fast applications, but also offers support for 
deploying additional Royale frameworks and using popular JavaScript frameworks.
 
 ## Apache Royale frameworks
 
diff --git a/get-started/hello-world.md b/get-started/hello-world.md
index 7c09715..a8bff76 100644
--- a/get-started/hello-world.md
+++ b/get-started/hello-world.md
@@ -24,7 +24,7 @@ permalink: /get-started/hello-world
 
 Try the simplest piece of code possible
 
-To verify that the Royale SDK is set up correctly, we recommend you create and 
build a ["Hello 
World"](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program){:target='_blank'}
 example. If that works, you can move on to [Create an 
Application](create-an-application) and work through the tutorial on building a 
more substantial application.
+To verify that the [Apache Royale](https://royale.apache.org/) SDK is set up 
correctly, we recommend you create and build a ["Hello 
World"](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program){:target='_blank'}
 example. If that works, you can move on to [Create an 
Application](create-an-application) and work through the tutorial on building a 
more substantial application.
 
 These instructions presume you are not using an 
[IDE](https://en.wikipedia.org/wiki/Integrated_development_environment){:target='_blank'},
 but are creating files in a text editor and compiling using command-line 
scripts or similar controls. [Development tools](get-started/development-tools) 
that fully support Royale provide their own instructions for building your 
first Royale applications.
 
diff --git a/get-started/royale-cli.md b/get-started/royale-cli.md
index ff44276..03a94d9 100644
--- a/get-started/royale-cli.md
+++ b/get-started/royale-cli.md
@@ -28,7 +28,7 @@ Royale CLI is a command-line tool that makes creating and 
compiling applications
 
 ## Installing Royale CLI
 
-If you have not installed Royale already, use this command in the command 
window:
+If you have not installed [Apache Royale](https://royale.apache.org/) already, 
use this command in the command window:
 
 ```sh
 npm install @apache-royale/royale-js -g
diff --git a/get-started/system-requirements.md 
b/get-started/system-requirements.md
index ab32ab3..e212334 100644
--- a/get-started/system-requirements.md
+++ b/get-started/system-requirements.md
@@ -24,7 +24,7 @@ permalink: get-started/system-requirements
 
 The minimum hardware needed to work in Apache Royale
 
-Apache Royale is designed for use on Mac or PC computers. We would love to 
know your experience with it on a Linux machine!
+[Apache Royale](https://royale.apache.org/) is designed for use on macOS or 
Windows computers. We would love to know your experience with it on a Linux 
machine!
 
 Since developers often use Royale in the IDE of their choice, the system needs 
to satisfy the minimum requirements for that IDE. You do not need Internet 
access to work with Royale unless that is required by the IDE you are using. 
Royale provides scripts you can run if you want to compile your application 
using the command line, without an IDE.
 
diff --git a/index.md b/index.md
index e5793cb..d77b932 100644
--- a/index.md
+++ b/index.md
@@ -27,7 +27,7 @@ Designed for the future. Code Once. Run Everywhere.
 {:align="center"}
 ![Apache Royale 
Logo](assets/images/apache-royale-main-logo-1000x1000.png){:height="33%" 
width="33%"}
 
-Apache Royale is the new SDK, built on the solid foundation developed by the 
Flex universe, that lets you create applications in MXML and ActionScript that 
will run almost anywhere without heavy plugins like Flash or Adobe AIR.
+[Apache Royale](https://royale.apache.org/) is the new SDK, built on the solid 
foundation developed by the Flex universe, that lets you create applications in 
MXML and ActionScript that will run almost anywhere without heavy plugins like 
Flash or Adobe AIR.
 
 With Royale, you can create a single code base that can be compiled to work 
like a native app on Windows or Apple systems, on Android phones, on tablets of 
all systems and sizes, in browsers, or on embedded JavaScript environments like 
Chromium Embedded Framework. 
 
diff --git a/libraries/crux.md b/libraries/crux.md
index c0d70c1..d23f23f 100644
--- a/libraries/crux.md
+++ b/libraries/crux.md
@@ -24,7 +24,7 @@ permalink: /libraries/crux
 
 An Apache Royale library based on Swiz Framework
 
-Apache Royale Crux provides:
+The Crux framework for [Apache Royale](https://royale.apache.org/) provides:
 
 - [Inversion of Control (IoC) and Dependency Injection 
(DI)](https://www.codeproject.com/articles/592372/dependency-injection-di-vs-inversion-of-control-io){:target='_blank'}
 with **Metadata**
 - [Event 
handling](https://en.wikipedia.org/wiki/Event_(computing)){:target='_blank'} 
with **Metadata**
diff --git a/libraries/library-basics.md b/libraries/library-basics.md
index 7cfd7ba..ea1f364 100644
--- a/libraries/library-basics.md
+++ b/libraries/library-basics.md
@@ -22,7 +22,7 @@ permalink: /libraries/library-basics
 
 # Royale libraries
 
-A bit about Royale libraries. What they are, how to use them and how to create 
them.
+A bit about [Apache Royale](https://royale.apache.org/) libraries. What they 
are, how to use them and how to create them.
 
 Royale libraries are packaged in `swc` files. A `swc` file is a zipped archive 
which contains the following:
 1. A `catalog.xml` which describes what is in the archive.
diff --git a/libraries/spectrum-royale.md b/libraries/spectrum-royale.md
index 4bc903a..6d188b9 100644
--- a/libraries/spectrum-royale.md
+++ b/libraries/spectrum-royale.md
@@ -24,6 +24,6 @@ permalink: /libraries/spectrum-royale
 
 Using the Adobe Spectrum system with Royale
 
-[Spectrum CSS](https://opensource.adobe.com/spectrum-css/){:target="_blank"} 
is an open-source implementation of Spectrum, Adobe’s design system. It 
includes components and resources to make applications more cohesive. Adobe has 
created Spectrum to support large application ecosystems that benefit from 
sharing design elements to provide a consistent experience for their users, and 
large development teams. According to 
[Adobe](https://spectrum.adobe.com/){:target="_blank"}, "Spectrum prov [...]
+[Spectrum CSS](https://opensource.adobe.com/spectrum-css/){:target="_blank"} 
is an open-source implementation of Spectrum, Adobe's design system. It 
includes components and resources to make applications more cohesive. Adobe has 
created Spectrum to support large application ecosystems that benefit from 
sharing design elements to provide a consistent experience for their users, and 
large development teams. According to 
[Adobe](https://spectrum.adobe.com/){:target="_blank"}, "Spectrum prov [...]
 
-You can incorporate the resources of Spectrum into your Royale project. See 
[examples of Royale and Spectrum working 
together](https://unhurdle.github.io/spectrum-royale){:target="_blank"} with 
downloadable source code.
+You can incorporate the resources of Spectrum into your [Apache 
Royale](https://royale.apache.org/) project. See [examples of Royale and 
Spectrum working 
together](https://unhurdle.github.io/spectrum-royale){:target="_blank"} with 
downloadable source code.
diff --git a/linter.md b/linter.md
index 26b60ff..18d685d 100644
--- a/linter.md
+++ b/linter.md
@@ -26,7 +26,7 @@ Discover common issues in your _.as_ and _.mxml_ source files
 
 ## User Guide
 
-Below are some pointers to help you get started with the Royale linter in 
various environments.
+Below are some pointers to help you get started with the [Apache 
Royale](https://royale.apache.org/) linter in various environments.
 
 ### Command line
 
diff --git a/linter/aslint-config-file.md b/linter/aslint-config-file.md
index fadb7cf..66369d6 100644
--- a/linter/aslint-config-file.md
+++ b/linter/aslint-config-file.md
@@ -24,7 +24,7 @@ permalink: /linter/aslint-config-file
 
 Configure the Royale linter for a specific project
 
-If the current working directory contains an _aslint-config.xml_ file, the 
[**aslint**](/linter/) tool will conveniently load this file automatically to 
configure its options.
+If the current working directory contains an _aslint-config.xml_ file, the 
[**aslint**](/linter/) tool included with [Apache 
Royale](https://royale.apache.org/) will conveniently load this file 
automatically to configure its options.
 
 The root of this file is an `<aslint-config>` element. To specify a [linter 
option](linter/linter-options), add it as a child element.
 
diff --git a/migrate-an-existing-app.md b/migrate-an-existing-app.md
index 8e5fdc2..18eb9f4 100644
--- a/migrate-an-existing-app.md
+++ b/migrate-an-existing-app.md
@@ -24,7 +24,7 @@ permalink: /migrate-an-existing-app
 
 Move from other technologies to Royale
 
-If you have an existing application and want to start using Royale to extend 
or maintain it, the following documents may help you.
+If you have an existing application and want to start using [Apache 
Royale](https://royale.apache.org/) to extend or maintain it, the following 
documents may help you.
 
 * [Migrate From Flex](migrate-an-existing-app/migrate-from-flex)
 
diff --git a/migrate-an-existing-app/emulation.md 
b/migrate-an-existing-app/emulation.md
index b40d240..7cee019 100644
--- a/migrate-an-existing-app/emulation.md
+++ b/migrate-an-existing-app/emulation.md
@@ -15,7 +15,7 @@ permalink: /migrate-an-existing-app/emulation
 
 Create in Royale the Flex components you need
 
-Apache Royale offers a growing list of components that let you build your 
application and deploy it almost anywhere. However, there are still many 
features that were available in Adobe and Apache Flex and are "coming soon" in 
Royale. Most of these components relied on Flex APIs and either Adobe Flash or 
Adobe AIR, which a Royale application compiled into JavaScript and running on a 
browser cannot do.
+[Apache Royale](https://royale.apache.org/) offers a growing list of 
components that let you build your application and deploy it almost anywhere. 
However, there are still many features that were available in Adobe and Apache 
Flex and are "coming soon" in Royale. Most of these components relied on Flex 
APIs and either Adobe Flash or Adobe AIR, which a Royale application compiled 
into JavaScript and running on a browser cannot do.
 
 Royale is creating a set of **emulation** components to replace the Flex 
components that depended on Flash features. These components do not promise 
100% backward compatibility and may not use the same class hierarchy as Flex. 
But they do approximate what the equivalent components in Flex did.
 
diff --git a/migrate-an-existing-app/flex-equivalents.md 
b/migrate-an-existing-app/flex-equivalents.md
index 9c21a42..f577ea8 100644
--- a/migrate-an-existing-app/flex-equivalents.md
+++ b/migrate-an-existing-app/flex-equivalents.md
@@ -15,7 +15,7 @@ permalink: /migrate-an-existing-app/flex-equivalents
 
 Working with Royale is _almost_, but _not quite_, like working with Flex
 
-Royale is not a one-for-one migration of Flex, for several reasons. A lot of 
Flex code presumes, and takes advantage of, features available in the Adobe AIR 
environment or the Flash Player plugin. Other Flex elements are more bulky than 
they could best be as they try to cover a wide range of possible events and 
situations, so a great deal of the code in an application may be there "just in 
case" and is never actually used.
+[Apache Royale](https://royale.apache.org/) is not a one-for-one migration of 
Flex, for several reasons. A lot of Flex code presumes, and takes advantage of, 
features available in the Adobe AIR environment or the Flash Player plugin. 
Other Flex elements are more bulky than they could best be as they try to cover 
a wide range of possible events and situations, so a great deal of the code in 
an application may be there "just in case" and is never actually used.
 
 Moving from Flex to Royale is straightforward for most of your application's 
functions, such as getting and manipulating data, performing calculations, and 
moving objects through their life cycles in the application. However, some Flex 
features, especially among UI components and functions, do not have direct 
Royale equivalents.
 
diff --git a/migrate-an-existing-app/migrate-from-flex.md 
b/migrate-an-existing-app/migrate-from-flex.md
index 203af31..bbabb6c 100644
--- a/migrate-an-existing-app/migrate-from-flex.md
+++ b/migrate-an-existing-app/migrate-from-flex.md
@@ -27,7 +27,7 @@ permalink: /migrate-an-existing-app/migrate-from-flex
 
 New life for your Flex applications
 
-If you have developed applications using the [Apache Flex 
SDK](https://flex.apache.org/){:target='_blank'}, or Adobe Flex before it, your 
applications probably combine [MXML](features/mxml) and 
[ActionScript](features/as3) files along with resources like images and audio 
files; and some of the MXML files have <fx:Script> tags with ActionScript 
snippets inside them. If that is the case, you will find yourself at home 
working with Apache Royale. The big difference is not so much the code y [...]
+If you have developed applications using the [Apache Flex 
SDK](https://flex.apache.org/){:target='_blank'}, or Adobe Flex before it, your 
applications probably combine [MXML](features/mxml) and 
[ActionScript](features/as3) files along with resources like images and audio 
files; and some of the MXML files have <fx:Script> tags with ActionScript 
snippets inside them. If that is the case, you will find yourself at home 
working with [Apache Royale](https://royale.apache.org/). The big differ [...]
 
 It is not yet possible to just import an existing Flex application into Apache 
Royale and then produce output in JavaScript that will run almost anywhere. 
However, you may need to do less hands-on conversion than you think to get to 
where you can use Royale to build your application, transpiled to JavaScript.
 
diff --git a/presentations/presentations.md b/presentations/presentations.md
index 483153b..06f9d98 100644
--- a/presentations/presentations.md
+++ b/presentations/presentations.md
@@ -18,7 +18,7 @@ permalink: /presentations/presentations
 
 Slides, Videos and other material from talks and sessions
 
-Here are links to videos (and PDFs of the slide decks, when available) of 
presentations on Apache Royale.
+Here are links to videos (and PDFs of the slide decks, when available) of 
presentations on [Apache Royale](https://royale.apache.org/).
 
 ## ApacheCon 2020
 
diff --git a/testing.md b/testing.md
index 27c08d7..6d89b85 100644
--- a/testing.md
+++ b/testing.md
@@ -37,4 +37,4 @@ Over time we will add pointers to general testing guides, and 
tips and tricks mo
 
 ## Unit tests
 
-Apache Royale includes the [RoyaleUnit](testing/royaleunit) library for unit 
testing.
+[Apache Royale](https://royale.apache.org/) includes the 
[RoyaleUnit](testing/royaleunit) library for unit testing.
diff --git a/testing/royaleunit.md b/testing/royaleunit.md
index a90c673..3ec16e7 100644
--- a/testing/royaleunit.md
+++ b/testing/royaleunit.md
@@ -26,7 +26,7 @@ A unit testing library for Apache Royale
 
 ## What RoyaleUnit does
 
-RoyaleUnit is an extensible testing framework for ActionScript classes and 
provides extensions for working with the Royale Framework. The RoyaleUnit 
framework is used to automate unit and integration testing.
+RoyaleUnit is an extensible testing framework for ActionScript classes and 
provides extensions for working with the [Apache 
Royale](https://royale.apache.org/) Framework. The RoyaleUnit framework is used 
to automate unit and integration testing.
 
 ## Requirements
 
diff --git a/testing/royaleunit/create-a-unit-test.md 
b/testing/royaleunit/create-a-unit-test.md
index 55587e0..7cda9d6 100644
--- a/testing/royaleunit/create-a-unit-test.md
+++ b/testing/royaleunit/create-a-unit-test.md
@@ -22,7 +22,7 @@ permalink: /testing/royaleunit/create-a-unit-test
 
 # Create a unit test
 
-An example of creating unit tests with RoyaleUnit
+An example of creating unit tests with RoyaleUnit for [Apache 
Royale](https://royale.apache.org/)
 
 ## Test cases
 
diff --git a/tutorials.md b/tutorials.md
index f7f45c6..9f4d2c5 100644
--- a/tutorials.md
+++ b/tutorials.md
@@ -23,7 +23,7 @@ permalink: /tutorials
 
 ## Presentations, examples and how-to guides
 
-Here you can find links to tutorials and how-to blog articles that will help 
you get going in Royale and learn how its features can make what you want to do 
easy and reliable.
+Here you can find links to tutorials and how-to blog articles that will help 
you get going in [Apache Royale](https://royale.apache.org/) and learn how its 
features can make what you want to do easy and reliable.
 
   * [Presentation](presentations/presentations) slide decks and videos
   * [Hello World](get-started/hello-world)
diff --git a/tutorials/royale-in-a-week.md b/tutorials/royale-in-a-week.md
index 4e50c03..bd493b8 100644
--- a/tutorials/royale-in-a-week.md
+++ b/tutorials/royale-in-a-week.md
@@ -23,6 +23,6 @@ permalink: /tutorials/royale-in-a-week
 
 A comprehensive introduction to Apache Royale
 
-_Royale in a Week_ is a comprehensive introduction to Apache Royale, based on 
the classic _Flex in a Week_ series for Adobe (and Apache) Flex. You do not 
have to have worked with Flex in order to follow this material.
+_Royale in a Week_ is a comprehensive introduction to [Apache 
Royale](https://royale.apache.org/), based on the classic _Flex in a Week_ 
series for Adobe (and Apache) Flex. You do not have to have worked with Flex in 
order to follow this material.
 
 When it is complete, the material will be available online, in downloadable 
PDFs with sample files, and through a video series. It will be available at no 
charge.
diff --git a/user-interface.md b/user-interface.md
index 9784f84..a6a30d2 100644
--- a/user-interface.md
+++ b/user-interface.md
@@ -28,7 +28,7 @@ Developers know that the data layer, the business layer, and 
the user interface
 
 A good "user experience" includes not just getting the process result you 
want, but how comfortable you were working with the UI. How easy is it to do 
what you want to do? How "pleasant" and intuitive is the display? It is not for 
nothing that the title of one of the key books on user experience is _Don't 
Make Me Think_.
 
-Apache Royale provides tools, structures, features, and component sets that 
help you create a user interface that helps your end-users do what they want to 
do.
+[Apache Royale](https://royale.apache.org/) provides tools, structures, 
features, and component sets that help you create a user interface that helps 
your end-users do what they want to do.
 
 * [Component Sets](component-sets)
   * [Basic](component-sets/basic)
diff --git a/user-interface/alerts.md b/user-interface/alerts.md
index 9311f33..1227fb9 100644
--- a/user-interface/alerts.md
+++ b/user-interface/alerts.md
@@ -23,7 +23,7 @@ permalink: /user-interface/alerts
 
 Send messages to your app users
 
-When a user is working with your application, you may need to get their 
attention to ask them a question, remind them of something they need to do, or 
update them about some app process that just completed (or broke!). Apache 
Royale provides several components that let you get your message out, and one 
of them lets your app user respond.
+When a user is working with your application, you may need to get their 
attention to ask them a question, remind them of something they need to do, or 
update them about some app process that just completed (or broke!). [Apache 
Royale](https://royale.apache.org/) provides several components that let you 
get your message out, and one of them lets your app user respond.
 
 ## Alert
 
diff --git a/user-interface/components.md b/user-interface/components.md
index d5a503d..b0bdef7 100644
--- a/user-interface/components.md
+++ b/user-interface/components.md
@@ -23,7 +23,7 @@ permalink: /user-interface/components
 
 Meet the UI building blocks.
 
-Royale provides a wide range of components to help you design a user interface 
that presents your material clearly and offers a pleasing user experience. As 
with Flex, these include:
+[Apache Royale](https://royale.apache.org/) provides a wide range of 
components to help you design a user interface that presents your material 
clearly and offers a pleasing user experience. As with Flex, these include:
 
   * Layout aids (groups, cards, grids, forms)
   * Ways to display data (lists, text boxes, tables, charts, repeating 
components)
diff --git a/user-interface/layouts.md b/user-interface/layouts.md
index 2b32a73..a74c271 100644
--- a/user-interface/layouts.md
+++ b/user-interface/layouts.md
@@ -23,7 +23,7 @@ permalink: /user-interface/layouts
 
 Organize the components in your UI
 
-Laying out components in Royale works a bit differently than in the Adobe or 
Apache Flex SDKs. If you don’t care about the _why_ and want to get to the 
_how_, skip ahead to the “Royale Layouts" section.
+Laying out components in [Apache Royale](https://royale.apache.org/) works a 
bit differently than in the Adobe or Apache Flex SDKs. If you don’t care about 
the _why_ and want to get to the _how_, skip ahead to the “Royale Layouts" 
section.
 
 The traditional Flex SDKs used a three-phase, optionally frame-delayed, 
validation mechanism. Two phases were top-down; one phase was bottom up. The 
idea was to handle any change anywhere. Also percentages were defined as a 
percentage of the non-fixed area of the container. Just about every object that 
didn’t have explicit widths and heights got measured because measurements 
helped define the minimum sizes for things with percentage widths and heights.
 
diff --git a/welcome/get-involved.md b/welcome/get-involved.md
index 1b73e4f..2d0426f 100644
--- a/welcome/get-involved.md
+++ b/welcome/get-involved.md
@@ -15,7 +15,7 @@ permalink: /welcome/get-involved
 
 Join us to make Apache Royale better!
 
-Apache Royale is a non-profit, open-source project. It grows and thrives on 
contributions, insights, and efforts by people like you. It would be stronger 
with your participation.
+[Apache Royale](https://royale.apache.org/) is a non-profit, open-source 
project. It grows and thrives on contributions, insights, and efforts by people 
like you. It would be stronger with your participation.
 
 ## The Royale team
 
diff --git a/welcome/high-level-view.md b/welcome/high-level-view.md
index ea0e0fa..438456c 100644
--- a/welcome/high-level-view.md
+++ b/welcome/high-level-view.md
@@ -25,7 +25,7 @@ permalink: /welcome/high-level-view
 
 Where we come from
 
-Apache Royale began as _"FlexJS"_, a branch of the [Apache Flex 
project](https://flex.apache.org){:target='_blank'}. The goal was to make a way 
for the many existing Flex applications users have developed to be deployable 
outside of the Adobe Flash and Adobe AIR enviromments.
+[Apache Royale](https://royale.apache.org/) began as _"FlexJS"_, a branch of 
the [Apache Flex project](https://flex.apache.org){:target='_blank'}. The goal 
was to make a way for the many existing Flex applications users have developed 
to be deployable outside of the Adobe Flash and Adobe AIR enviromments.
 
 While Flex may work using Flash in browsers or within AIR on computers with 
traditional keyboards for years to come, Flex developers need to make their 
apps available on mobile devices, which for many end users are now the primary 
computer. The cost of migrating an application to a new coding language is 
high, and the risks around quality control are significant, especially when 
migrating to a less-strict language like JavaScript. Royale helps to minimize 
the cost and the risk of migrati [...]
 
diff --git a/welcome/history.md b/welcome/history.md
index 2bfc7e7..cb23f31 100644
--- a/welcome/history.md
+++ b/welcome/history.md
@@ -25,6 +25,6 @@ At the end of 2011, Adobe changed its business focus and 
decided to stop releasi
 
 Part of [Apache Flex](https://flex.apache.org/){:target='_blank'} work 
involved making it possible to create applications in Flex and then compile and 
distribute them in ways that did not require the Flash Player or Adobe AIR as a 
platform. These efforts, under the code name _"FlexJS"_, made good progress. 
 
-In 2017 it was agreed to split this work into a new Apache project, which 
reached back to the early history of the project for a name. That is how we 
have arrived at "Apache Royale".
+In 2017 it was agreed to split this work into a new Apache project, which 
reached back to the early history of the project for a name. That is how we 
have arrived at ["Apache Royale"](https://royale.apache.org/).
 
 This is a young project, with much to do. Your participation would be very 
[welcome](https://royale.apache.org/get-involved){:target='_blank'}!
diff --git a/welcome/licenses.md b/welcome/licenses.md
index 4d350a3..5e31cdf 100644
--- a/welcome/licenses.md
+++ b/welcome/licenses.md
@@ -16,7 +16,7 @@ About Apache Royale licenses and policies
 
 ## Apache License v2.0
 
-Apache Royale is under __Apache License v2.0__. See:
+[Apache Royale](https://royale.apache.org/) is released under the terms of 
__Apache License v2.0__. See:
 
[ttp://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0){:target='_blank'}
 
 The Apache Royale SDK includes a number of subcomponents with separate 
copyright notices and license terms.
diff --git a/welcome/what-is-royale.md b/welcome/what-is-royale.md
index 9d33c26..ade8680 100644
--- a/welcome/what-is-royale.md
+++ b/welcome/what-is-royale.md
@@ -26,7 +26,7 @@ How Royale fits into the Javascript ecosystem
 When evaluating a framework or project, the first question you might ask is 
how is it the same or different as "x". How does this relate to other options? 
This document attempts to answer those questions.
 
 ## It's a language
-At the heart of Royale, it's a language. Royale is the current shepherd of the 
ActionScript programming language. The most obvious language you would compare 
ActionScript to would be Typescript. The general goals of both are similar -- 
to add type protection for an ECMA language. There are differences between the 
approach taken by Typescript and ActionScript [which are discussed on a 
dedicated page](features/as3/actionscript-vs-typescript).
+At the heart of [Apache Royale](https://royale.apache.org/), it's a language. 
Royale is the current shepherd of the ActionScript programming language. The 
most obvious language you would compare ActionScript to would be Typescript. 
The general goals of both are similar -- to add type protection for an ECMA 
language. There are differences between the approach taken by Typescript and 
ActionScript [which are discussed on a dedicated 
page](features/as3/actionscript-vs-typescript).
 
 ## It's a compiler
 Royale compiles ActionScript for multiple run-times. The ActionScript compiler 
is an important piece of Royale. Currently, the targets are for Flash (mostly 
AIR applications today) and Javascript applications. However the architecture 
was designed to be platform agnostic and other native platforms can be targeted 
in the future.
diff --git a/welcome/why-royale.md b/welcome/why-royale.md
index b56faea..7e2d293 100644
--- a/welcome/why-royale.md
+++ b/welcome/why-royale.md
@@ -23,7 +23,7 @@ permalink: /welcome/why-royale
 
 The advantages of using Royale
 
-Let's face it: there are lots of application frameworks out there and each one 
claims to be the best. What does Royale give you that you don't get with other 
frameworks?
+Let's face it: there are lots of application frameworks out there and each one 
claims to be the best. What does [Apache Royale](https://royale.apache.org/) 
give you that you don't get with other frameworks?
 
 ## Time Proven
 Royale takes the best parts of Flex, which was the first major web application 
framework. The best minds in the field developed Flex, and one of the lead 
architects of Flex led the design of Royale.
diff --git a/working-with-data.md b/working-with-data.md
index 6222a20..4be305e 100644
--- a/working-with-data.md
+++ b/working-with-data.md
@@ -24,7 +24,7 @@ permalink: /working-with-data
 
 Getting, sending, and displaying data in your app
 
-These pages can help you get, send, and display data smoothly and efficiently 
in your Apache Royale apps.
+These pages can help you get, send, and display data smoothly and efficiently 
in your [Apache Royale](https://royale.apache.org/) apps.
 
 * Getting, storing and sending data
   * [Loading external data](working-with-data/loading-external-data)
diff --git a/working-with-data/item-renderers.md 
b/working-with-data/item-renderers.md
index d1ea6eb..1c91843 100644
--- a/working-with-data/item-renderers.md
+++ b/working-with-data/item-renderers.md
@@ -24,7 +24,7 @@ permalink: /working-with-data/item-renderers
 
 Visual representation of data items in lists and other collection components
 
-Collections of data contain objects or items. Several components in Royale, 
like _List_, _DataGrid_, _TabBar_ or _ButtonBar_, can show collections of data 
to the user in different ways. Those components need to describe each item and 
adapt the visualization to the data inside each object. Apache Royale uses 
**Item Renderer** components to render, or visualize, each piece of data in 
each collection object in a collection component.
+Collections of data contain objects or items. Several components in [Apache 
Royale](https://royale.apache.org/), like _List_, _DataGrid_, _TabBar_ or 
_ButtonBar_, can show collections of data to the user in different ways. Those 
components need to describe each item and adapt the visualization to the data 
inside each object. [Apache Royale](https://royale.apache.org/) uses **Item 
Renderer** components to render, or visualize, each piece of data in each 
collection object in a collection c [...]
 
 ## Inline
 
diff --git a/working-with-data/loading-external-data.md 
b/working-with-data/loading-external-data.md
index 0ae647f..1a55d6c 100644
--- a/working-with-data/loading-external-data.md
+++ b/working-with-data/loading-external-data.md
@@ -26,7 +26,7 @@ Dynamic sites and real-time updates lead to good user 
experiences
 
 Unless you are building a brochure-style website that makes a statement and 
provides contact information, you are going to be working with _data_. You will 
get some of that data from your site or application users, but you will 
probably also get a lot from outside your app or website.
 
-Royale provides reliable, fast, and secure ways to get data from remote 
sources, and also to send data.
+[Apache Royale](https://royale.apache.org/) provides reliable, fast, and 
secure ways to get data from remote sources, and also to send data.
 
 The following data types have built-in support:
 
diff --git a/working-with-data/loading-external-data/amf.md 
b/working-with-data/loading-external-data/amf.md
index 7cfab26..ce581b3 100644
--- a/working-with-data/loading-external-data/amf.md
+++ b/working-with-data/loading-external-data/amf.md
@@ -24,7 +24,7 @@ permalink: /working-with-data/loading-external-data/amf
 
 ActionScript Message Format binary protocol
 
-AMF is a great way to send data between an Apache Royale client and a backend 
server. The server could be written in Java, PHP, ColdFusion, .NET, Ruby, 
Python or many other backend technologies.
+AMF is a great way to send data between an [Apache 
Royale](https://royale.apache.org/) client and a backend server. The server 
could be written in Java, PHP, ColdFusion, .NET, Ruby, Python or many other 
backend technologies.
 
 [Action Message Format 
(AMF)](https://en.wikipedia.org/wiki/Action_Message_Format){:target='_blank'} 
is a binary format used to serialize object graphs such as ActionScript objects 
and XML, or send messages between a client and a remote service. The 
ActionScript 3 language provides classes for encoding and decoding from the AMF 
format. Backend servers need to know how to encode and decode AMF.
 
diff --git a/working-with-data/loading-external-data/httpservice.md 
b/working-with-data/loading-external-data/httpservice.md
index e18e888..c28f1ef 100644
--- a/working-with-data/loading-external-data/httpservice.md
+++ b/working-with-data/loading-external-data/httpservice.md
@@ -24,7 +24,7 @@ permalink: 
/working-with-data/loading-external-data/httpservice
 
 Loading external data through REST services
 
-You can load external data in Apache Royale using the `HTTPService` class. Use 
`HTTPService` to make _POST_, _GET_, _PUT_ and _DELETE_ operations for requests 
on external data for 
[REST](https://en.wikipedia.org/wiki/Representational_state_transfer){:target='_blank'}
 services.
+You can load external data in [Apache Royale](https://royale.apache.org/) 
using the `HTTPService` class. Use `HTTPService` to make _POST_, _GET_, _PUT_ 
and _DELETE_ operations for requests on external data for 
[REST](https://en.wikipedia.org/wiki/Representational_state_transfer){:target='_blank'}
 services.
 
 ## Implementations
 
diff --git a/working-with-data/loading-external-data/remoteobject.md 
b/working-with-data/loading-external-data/remoteobject.md
index b108ddb..524f6e8 100644
--- a/working-with-data/loading-external-data/remoteobject.md
+++ b/working-with-data/loading-external-data/remoteobject.md
@@ -24,7 +24,7 @@ permalink: 
/working-with-data/loading-external-data/remoteobject
 
 Remote procedure calls with the AMF binary protocol
 
-RemoteObject lets Apache Royale applications make [Remote Procedure Calls 
(RPCs)](https://en.wikipedia.org/wiki/Remote_procedure_call){:target='_blank'} 
to a back-end server using the [ActionScript Message Format (AMF) 
protocol](working-with-data/loading-external-data/amf). The server can be 
written in Java, PHP, ColdFusion, .NET, Ruby, Python or many other back-end 
technologies.
+RemoteObject lets [Apache Royale](https://royale.apache.org/) applications 
make [Remote Procedure Calls 
(RPCs)](https://en.wikipedia.org/wiki/Remote_procedure_call){:target='_blank'} 
to a back-end server using the [ActionScript Message Format (AMF) 
protocol](working-with-data/loading-external-data/amf). The server can be 
written in Java, PHP, ColdFusion, .NET, Ruby, Python or many other back-end 
technologies.
 
 ## Implementations
 

Reply via email to