Fix broken links, more reorg

docs/build/advanced-concepts/_category_.yml

@@ -1,2 +1,2 @@
 label: Advanced Concepts
-position: 5
+position: 7

docs/build/app-architecture/index.md

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 6
+sidebar_position: 5
 title: App Architecture
 description: Describes building self-custody and app custody applications on Flow Blockchain.
 sidebar_custom_props:

docs/build/basics/_category_.yml

@@ -1,2 +1,2 @@
-label: Basic Concepts
+label: Flow Cadence Protocol
 position: 4

docs/build/flow.md

@@ -44,9 +44,19 @@ To get a complete picture on how to build on Flow, follow the 👈 sidebar top t
 
 If you like to jump right into the deep end of the pool, take a look below for more direct links to advanced topics!
 
+### Learn Cadence
+
+To take advantage of the full power of Flow, you'll need to learn [Cadence].  Learning a new language is an investment, but you'll find that Cadence is safer, more explicit, and less dangerous than other blockchain languages.  Plus, it unlocks the full power of the Flow protocol!
+
+### Build with the EVM
+
+If you're not ready to take the plunge and learn [Cadence], try out "EVM++" by deploying your existing [EVM] contracts.  You'll find that Flow EVM is faster and cheaper than nearly every other EVM solution - without compromising on security.
+
+Deploying on Flow EVM also gives your Solidity contracts access to Flow Cadence features, such as native [VRF].
+
 ### App Development Quickstart
 
-The [Flow App Quickstart](./guides/flow-app-quickstart.md) covers the Flow core concepts, including:
+The [Flow App Quickstart] covers the Flow core concepts, including:
 
 - **App Client:** The app client is the interface through which users interact with your app. Web and mobile applications are typical examples of app clients.
 - **Smart Contract:** A smart contract is a collection of code deployed to a permanent location on the blockchain that defines the core logic for a dApp.
@@ -58,7 +68,7 @@ The [Flow App Quickstart](./guides/flow-app-quickstart.md) covers the Flow core
 
 ### Core Contracts
 
-The Flow blockchain implements core functionality using its own smart contract language, [Cadence](https://cadence-lang.org/docs/language/). The core functionality is split into a set of contracts, so-called [core contracts](../build/core-contracts/index.md):
+The Flow blockchain implements core functionality using its own smart contract language, [Cadence]. The core functionality is split into a set of contracts, called the [core contracts]:
 
 - **Fungible Token:** The FungibleToken contract implements the Fungible Token Standard. It is the second contract ever deployed on Flow.
 - **Flow Token:** The FlowToken contract defines the FLOW network token.
@@ -69,17 +79,17 @@ The Flow blockchain implements core functionality using its own smart contract l
 
 ### FLOW Token
 
-The [FLOW](../build/core-contracts/03-flow-token.md) token is the native currency for the Flow network. Developers and users can use FLOW to transact on the network. Developers can integrate FLOW directly into their apps for peer-to-peer payments, service charges, or consumer rewards. FLOW can be held, transferred, or transacted peer-to-peer.
+The [FLOW] token is the native currency for the Flow network. Developers and users can use FLOW to transact on the network. Developers can integrate FLOW directly into their apps for peer-to-peer payments, service charges, or consumer rewards. FLOW can be held, transferred, or transacted peer-to-peer.
 
 ### Technical Background
 
-- The [Flow Technical Primer](https://www.onflow.org/primer) is a great place to start to understand how Flow works.
-- The [Three technical whitepapers](https://www.onflow.org/technical-paper) cover the unique innovation behind the Flow blockchain network in-depth.
+- The [Flow Technical Primer] is a great place to start to understand how Flow works.
+- The [Three technical whitepapers] cover the unique innovation behind the Flow blockchain network in-depth.
 
 ### Tokenomics
 
-- To understand more about Flow's Token Economics, and the **FLOW token**, you can read the [Flow Token Economics](https://www.onflow.org/flow-token-economics) guide.
-- FLOW tokens are Flow's native Fungible Token. To learn more about how to work with them in your applications, go [here](../build/core-contracts/03-flow-token.md).
+- To understand more about Flow's Token Economics, and the **FLOW token**, you can read the [Flow Token Economics] guide.
+- FLOW tokens are Flow's native Fungible Token. To learn more about how to work with them in your applications, review the [FLOW] article.
 
 [digital assets]: https://www.onflow.org/post/flow-blockchain-cadence-programming-language-resources-assets
 [multi-role architecture]: https://www.onflow.org/primer
@@ -95,3 +105,10 @@ The [FLOW](../build/core-contracts/03-flow-token.md) token is the native currenc
 [Guide for Solidity Developers]: https://cadence-lang.org/docs/solidity-to-cadence
 [account abstraction]: https://flow.com/account-abstraction
 [bridge]: https://developers.flow.com/ecosystem/bridges
+[Flow App Quickstart]: ./guides/flow-app-quickstart
+[core contracts]: ../build/core-contracts/index
+[FLOW]: ../build/core-contracts/03-flow-token
+[Flow Technical Primer]: https://www.onflow.org/primer
+[Three technical whitepapers]: https://www.onflow.org/technical-paper
+[Flow Token Economics]: https://www.onflow.org/flow-token-economics
+[VRF]: ../evm/guides/vrf

docs/build/guides/flow-app-quickstart.md

@@ -29,7 +29,7 @@ FCL (aka Flow Client Library) wraps the logic needed to communicate with the Flo
 
 :::
 
-This guide assumes a good understanding of React. The concepts are easy to understand and apply to other libraries and framework. A strong understanding of Cadence (Flow's smart contract language) is not required. More information on Cadence, [learning the Cadence language](../smart-contracts/cadence.md).
+This guide assumes a good understanding of React. The concepts are easy to understand and apply to other libraries and framework. A strong understanding of Cadence (Flow's smart contract language) is not required. More information on Cadence, [learning the Cadence language](https://cadence-lang.org/docs/language/).
 
 ### FCL concepts covered:
 

docs/build/guides/mobile/react-native-quickstart.md

@@ -12,7 +12,7 @@ sidebar_position: 4
 
 FCL-JS is the easiest way to start building decentralized applications. FCL (aka Flow Client Library) wraps much of the logic you'd have to write yourself on other blockchains. Follow this quick start and you'll have a solid overview of how to build a shippable dapp on Flow.
 
-We're going to make an assumption that you know or understand React; however, the concepts should be easy to understand and transfer to another framework. While this tutorial will make use of Cadence (Flow's smart contract language), you do not need to know it. Instead, we recommend later diving into [learning the Cadence language](../../smart-contracts/cadence.md) once you've gotten the core FCL concepts down.
+We're going to make an assumption that you know or understand React; however, the concepts should be easy to understand and transfer to another framework. While this tutorial will make use of Cadence (Flow's smart contract language), you do not need to know it. Instead, we recommend later diving into [learning the Cadence language](https://cadence-lang.org/docs/language/) once you've gotten the core FCL concepts down.
 
 In this tutorial, we are going to interact with an existing smart contract on Flow's testnet known as the [Profile Contract](https://testnet.flowdiver.io/contract/A.ba1132bc08f82fe2.Profile). Using this contract, we will create a new profile and edit the profile information, both via a wallet. In order to do this, the FCL concepts we'll cover are:
 
@@ -293,17 +293,17 @@ await fcl.query({
 });
 ```
 
-Inside the query you'll see we set two things: `cadence` and `args`. Cadence is Flow's smart contract language we mentioned. For this tutorial, when you look at it you just need to notice that it's importing the `Profile` contract from the account we named `0xProfile` earlier in our config file, then also taking an account address, and reading it. That's it until you're ready to [learn more Cadence](https://cadence-lang.org/docs/tutorial/first-steps).
+Inside the query you'll see we set two things: `cadence` and `args`. Cadence is Flow's smart contract language we mentioned. For this tutorial, when you look at it you just need to notice that it's importing the `Profile` contract from the account we named `0xProfile` earlier in our config file, then also taking an account address, and reading it. That's it until you're ready to [learn more Cadence](https://cadence-lang.org/docs).
 
 In the `args` section, we are simply passing it our user's account address from the user we set in state after authentication and giving it a type of `Address`.  For more possible types, [see this reference](../../../tools/clients/fcl-js/api.md#ftype).
 
 Go ahead and click the "Send Query" button. You should see "No Profile." That's because we haven't initialized the account yet.
 
 ## Initializing the Account
 
-For the Profile contract to store a Profile in a user's account, it does so by initializing what is called a "resource." A resource is an ownable piece of data and functionality that can live in the user's account storage. This paradigm is known is as "resource-oriented-programming", a principle that is core to Cadence and differentiates its ownership model from other smart contract languages, [read more here](../../smart-contracts/cadence.md#intuiting-ownership-with-resources). Cadence makes it so that resources can only exist in one place at any time, they must be deliberately created, cannot be copied, and if desired, must be deliberately destroyed.
+For the Profile contract to store a Profile in a user's account, it does so by initializing what is called a "resource." A resource is an ownable piece of data and functionality that can live in the user's account storage. This paradigm is known is as "resource-oriented-programming", a principle that is core to Cadence and differentiates its ownership model from other smart contract languages, [read more here](https://cadence-lang.org/docs/#intuiting-ownership-with-resources). Cadence makes it so that resources can only exist in one place at any time, they must be deliberately created, cannot be copied, and if desired, must be deliberately destroyed.
 
-> There's a lot more to resources in Cadence than we'll cover in this guide, so if you'd like to know more, check out [this Cadence intro](../../smart-contracts/cadence.md).
+> There's a lot more to resources in Cadence than we'll cover in this guide, so if you'd like to know more, check out [this Cadence intro](https://cadence-lang.org/docs).
 
 To do this resource initialization on an account, we're going to add another function called `initAccount`. Inside of that function, we're going to add some Cadence code which says, *"Hey, does this account have a profile? If it doesn't, let's add one."* We do that using something called a "transaction." Transactions occur when you want to change the state of the blockchain, in this case, some data in a resource, in a specific account. And there is a cost (transaction fee) in order to do that; unlike a query.
 

docs/build/smart-contracts/_category_.yml

@@ -1,5 +1,5 @@
 label: Writing and Deploying Smart Contracts
-position: 7
+position: 6
 customProps:
     icon: 🧱
     description: How to deploy smart contracts to mainnet and testnet

docs/tools/clients/fcl-js/index.md

@@ -118,7 +118,7 @@ See the [Flow App Quick Start](../../../build/guides/flow-app-quickstart.md).
 
 See the full [API Reference](./api.md) for all FCL functionality.
 
-Learn Flow's smart contract language to build any script or transactions: [Cadence](../../../build/smart-contracts/cadence.md).
+Learn Flow's smart contract language to build any script or transactions: [Cadence](https://cadence-lang.org/docs).
 
 Explore all of Flow [docs and tools](/).
 

docs/tools/clients/fcl-js/index.mdx.txt

@@ -132,7 +132,7 @@ See the [Flow App Quick Start](../../guides/flow-app-quickstart.mdx).
 
 See the full [API Reference](./api.md) for all FCL functionality.
 
-Learn Flow's smart contract language to build any script or transactions: [Cadence](../../../build/guides/smart-contracts/cadence.md).
+Learn Flow's smart contract language to build any script or transactions: [Cadence](https://cadence-lang.org/docs).
 
 Explore all of Flow [docs and tools](/).
 

docs/tools/clients/fcl-js/scripts.md

@@ -29,7 +29,7 @@ console.log(response) // 3
 
 ### A more complicated Script
 
-Things like [Resources](../../../build/smart-contracts/cadence.md#resources) and [Structs](../../../build/smart-contracts/cadence.md#structures) are fairly common place in Cadence.
+Things like [Resources](https://cadence-lang.org/docs/language/resources) and [Structs](https://cadence-lang.org/docs/language/composite-types#structures) are fairly common place in Cadence.
 
 In the following code snippet, our script defines a struct called `Point`, it then returns a list of them.
 

docs/tools/clients/fcl-js/sdk-guidelines.md

@@ -279,7 +279,7 @@ Transaction data is composed and signed with help of the SDK. The signed payload
 ## Transactions
 A transaction is nothing more than a signed set of data that includes script code which are instructions on how to mutate the network state and properties that define and limit it's execution. All these properties are explained bellow. 
 
-📖 **Script** field is the portion of the transaction that describes the state mutation logic. On Flow, transaction logic is written in [Cadence](../../../build/smart-contracts/cadence.md). Here is an example transaction script:
+📖 **Script** field is the portion of the transaction that describes the state mutation logic. On Flow, transaction logic is written in [Cadence](https://cadence-lang.org/docs). Here is an example transaction script:
 ```
 transaction(greeting: String) {
   execute {
@@ -315,7 +315,7 @@ transaction {
 ```
 
 📖 **Gas limit** is the limit on the amount of computation a transaction requires, and it will abort if it exceeds its gas limit.
-Cadence uses metering to measure the number of operations per transaction. You can read more about it in the [Cadence documentation](../../../build/smart-contracts/cadence.md).
+Cadence uses metering to measure the number of operations per transaction. You can read more about it in the [Cadence documentation](https://cadence-lang.org/docs).
 
 The gas limit depends on the complexity of the transaction script. Until dedicated gas estimation tooling exists, it's best to use the emulator to test complex transactions and determine a safe limit.
 

docs/tools/clients/flow-go-sdk/index.mdx → docs/tools/clients/flow-go-sdk/index.md

@@ -510,7 +510,7 @@ Executing a transaction requires couple of steps:
 
 A transaction is nothing more than a signed set of data that includes script code which are instructions on how to mutate the network state and properties that define and limit it's execution. All these properties are explained bellow.
 
-📖 **Script** field is the portion of the transaction that describes the state mutation logic. On Flow, transaction logic is written in [Cadence](../../../build/smart-contracts/cadence.md). Here is an example transaction script:
+📖 **Script** field is the portion of the transaction that describes the state mutation logic. On Flow, transaction logic is written in [Cadence](https://cadence-lang.org/docs). Here is an example transaction script:
 
 ```
 transaction(greeting: String) {
@@ -549,7 +549,7 @@ transaction {
 ```
 
 📖 **Gas limit** is the limit on the amount of computation a transaction requires, and it will abort if it exceeds its gas limit.
-Cadence uses metering to measure the number of operations per transaction. You can read more about it in the [Cadence documentation](../../../build/smart-contracts/cadence.md).
+Cadence uses metering to measure the number of operations per transaction. You can read more about it in the [Cadence documentation](https://cadence-lang.org/docs).
 
 The gas limit depends on the complexity of the transaction script. Until dedicated gas estimation tooling exists, it's best to use the emulator to test complex transactions and determine a safe limit.
 

docs/tools/clients/unity-sdk/samples/ui-usage.md

@@ -199,7 +199,7 @@ flow.AccountContractRemoved
 
 ### Scripts
 
-Scripts are cadence code that you write and are executed on the blockchain. They can contain arguments and return values, and can interact with Smart Contracts. Scripts are read-only - they cannot mutate anything on the blockchain. Anything held in local memory is discarded when the script finishes execution. For more information on programming see [Cadence](../../../../build/smart-contracts/cadence.md).
+Scripts are cadence code that you write and are executed on the blockchain. They can contain arguments and return values, and can interact with Smart Contracts. Scripts are read-only - they cannot mutate anything on the blockchain. Anything held in local memory is discarded when the script finishes execution. For more information on programming see [Cadence](https://cadence-lang.org/docs).
 
 **Execute Simple Script At Latest Block**
 
@@ -257,7 +257,7 @@ For more information about Transactions, see [cadence/language/transactions](htt
 
 For more information about Transaction signing, see [concepts/transaction-signing](../../../../build/basics/transactions.md#signing-a-transaction).
 
-For more information about Cadence programming, see [cadence](../../../../build/smart-contracts/cadence.md).
+For more information about Cadence programming, see [Cadence](https://cadence-lang.org/docs).
 
 **Signing In**
 

docs/tools/vscode-extension/index.mdx → docs/tools/vscode-extension/index.md

@@ -2,7 +2,7 @@
 title: Cadence VS Code Extension
 ---
 
-This extension integrates [Cadence](../../build/smart-contracts/cadence.md), the resource-oriented smart contract programming language of [Flow](https://www.onflow.org/), into [Visual Studio Code](https://code.visualstudio.com/).
+This extension integrates [Cadence](https://cadence-lang.org/docs), the resource-oriented smart contract programming language of [Flow](https://www.onflow.org/), into [Visual Studio Code](https://code.visualstudio.com/).
 It provides features like syntax highlighting, type checking, code completion, etc.
 
 Note that most editing features (type checking, code completion, etc.) are implemented in the [Cadence Language Server](https://github.com/onflow/cadence/tree/master/languageserver).