diff --git a/docs/learn/encyclopedia/contract-development/contract-interactions/stellar-transaction.mdx b/docs/learn/encyclopedia/contract-development/contract-interactions/stellar-transaction.mdx
index 37e234492..7202908d3 100644
--- a/docs/learn/encyclopedia/contract-development/contract-interactions/stellar-transaction.mdx
+++ b/docs/learn/encyclopedia/contract-development/contract-interactions/stellar-transaction.mdx
@@ -376,7 +376,7 @@ public class SorobanExample {
 
 ## XDR Usage
 
-Stellar supports invoking and deploying contracts with a new operation named `InvokeHostFunctionOp`. The [`soroban-cli`] abstracts these details away from the user, but not all SDKs do yet. If you're building a dapp you'll probably find yourself building the XDR transaction to submit to the network.
+Stellar supports invoking and deploying contracts with a new operation named `InvokeHostFunctionOp`. The [`stellar-cli`] abstracts these details away from the user, but not all SDKs do yet. If you're building a dapp you'll probably find yourself building the XDR transaction to submit to the network.
 
 The `InvokeHostFunctionOp` can be used to perform the following Soroban operations:
 
@@ -384,7 +384,7 @@ The `InvokeHostFunctionOp` can be used to perform the following Soroban operatio
 - Upload Wasm of the new contracts.
 - Deploy new contracts using the uploaded Wasm or built-in implementations (this currently includes only the [token contract](../../../../smart-contracts/tokens/stellar-asset-contract.mdx)).
 
-[`soroban-cli`]: /docs/smart-contracts/getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: /docs/smart-contracts/getting-started/setup.mdx#install-the-stellar-cli
 
 There is only a single `InvokeHostFunctionOp` allowed per transaction. Contracts should be used to perform multiple actions atomically, for example, to deploy a new contract and initialize it atomically.
 
diff --git a/docs/learn/encyclopedia/contract-development/types/fully-typed-contracts.mdx b/docs/learn/encyclopedia/contract-development/types/fully-typed-contracts.mdx
index 9338fb89a..0f0675e9b 100644
--- a/docs/learn/encyclopedia/contract-development/types/fully-typed-contracts.mdx
+++ b/docs/learn/encyclopedia/contract-development/types/fully-typed-contracts.mdx
@@ -25,13 +25,13 @@ When you compile a contract created with [soroban-sdk](../../../../tools/sdks/li
 
 Today, these interface types are formatted using [XDR](../../data-format/xdr.mdx), but this [may change](https://github.com/stellar/rs-soroban-sdk/issues/683) down the road.
 
-The important part is that tooling can fetch these interface types to make your life easier. [Soroban CLI](../../../../tools/developer-tools.mdx#cli) is the first tool to do so. Specifically, one subcommand:
+The important part is that tooling can fetch these interface types to make your life easier. [Stellar CLI](../../../../tools/developer-tools.mdx#cli) is the first tool to do so. Specifically, one subcommand:
 
-## `soroban contract invoke`
+## `stellar contract invoke`
 
 Really, every smart contract is its own program, and deserves its own CLI.
 
-So that's what Soroban CLI gives you.
+So that's what Stellar CLI gives you.
 
 A unique CLI for each smart contract. Constructed on-the-fly, right from the on-chain interface types. Including the author's comments. An _implicit CLI_.
 
@@ -69,7 +69,7 @@ Options:
   -h, --help  Print help
 ```
 
-Like any other CLI, you can also get help for any of these subcommands using something like `native balance --help`. Soroban CLI again fetches the on-chain interface types, this time using it to generate a full list of all arguments to the function, and even generates examples.
+Like any other CLI, you can also get help for any of these subcommands using something like `native balance --help`. Stellar CLI again fetches the on-chain interface types, this time using it to generate a full list of all arguments to the function, and even generates examples.
 
 :::tip
 
@@ -83,13 +83,13 @@ soroban contract invoke --network testnet --id CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIX
 
 If you're unfamiliar with the `--` double dash separator, this is a pattern used by other CLIs. Everything after the double dash, sometimes called the [slop](https://github.com/clap-rs/clap/issues/971), gets passed to the child process. An example of another CLI that makes use of this is `cargo run`.
 
-Of course, the exact way that that Soroban CLI parses arguments is an ongoing design discussion. Representing complex custom arguments on the command line is a design challenge no blockchain CLI gets perfect yet; many, including Soroban CLI, currently use JSON. But this has downsides, and other options are possible. [How would you like to see it work?](https://docs.google.com/document/d/1LASaLyxIA2-YqLnn2NqI5NZGnEmdzx9lLh-j7n0-i4A/edit#)
+Of course, the exact way that that Stellar CLI parses arguments is an ongoing design discussion. Representing complex custom arguments on the command line is a design challenge no blockchain CLI gets perfect yet; many, including Stellar CLI, currently use JSON. But this has downsides, and other options are possible. [How would you like to see it work?](https://docs.google.com/document/d/1LASaLyxIA2-YqLnn2NqI5NZGnEmdzx9lLh-j7n0-i4A/edit#)
 
 ## Already the best; just getting started
 
 We love that Soroban will have all contract interface types available on-chain right from day one. No secondary API calls to external services, no secondary API token management, no signing in or creating an account anywhere else, and near-perfect reliability. It's a game-changer within the blockchain space.
 
-Soroban CLI already shows how this can be built into foundational tooling to give developers delightful experiences. And this is only the beginning. At every level of the stack, you can expect—and [build](https://stellar.org/foundation/grants-and-funding)—tooling that makes interacting with any contract predictable and seamless.
+Stellar CLI already shows how this can be built into foundational tooling to give developers delightful experiences. And this is only the beginning. At every level of the stack, you can expect—and [build](https://stellar.org/foundation/grants-and-funding)—tooling that makes interacting with any contract predictable and seamless.
 
 Soon we'll have TypeScript/JavaScript libraries that mirror the behavior of `soroban contract invoke`, customized for browser & nodejs environments. You can expect GUIs that adapt to any given contract on-the-fly, functioning as interactive documentation. If you're writing contracts that make cross-contract calls, most of the code you need can also be auto-generated.
 
diff --git a/docs/learn/fundamentals/stellar-data-structures/assets.mdx b/docs/learn/fundamentals/stellar-data-structures/assets.mdx
index 847d0f22f..2fd8a0611 100644
--- a/docs/learn/fundamentals/stellar-data-structures/assets.mdx
+++ b/docs/learn/fundamentals/stellar-data-structures/assets.mdx
@@ -29,7 +29,7 @@ The public key of the issuing account is linked on the ledger to the asset. Resp
 
 Assets issued on the Stellar network are accessible to smart contracts. Every Stellar asset has reserved a Stellar Asset Contract that can be deployed by anyone who wants to be able to interact with the asset from a contract.
 
-The Soroban CLI can deploy a Stellar Asset Contract for a Stellar asset. Deploying the Stellar Asset Contract for a Stellar asset enables that asset for use with smart contracts.
+The Stellar CLI can deploy a Stellar Asset Contract for a Stellar asset. Deploying the Stellar Asset Contract for a Stellar asset enables that asset for use with smart contracts.
 
 Learn more in the [SAC section](../../../smart-contracts/tokens/stellar-asset-contract.mdx).
 
diff --git a/docs/smart-contracts/example-contracts/TEMPLATE.mdx b/docs/smart-contracts/example-contracts/TEMPLATE.mdx
index ada448a83..b7cbd3b56 100644
--- a/docs/smart-contracts/example-contracts/TEMPLATE.mdx
+++ b/docs/smart-contracts/example-contracts/TEMPLATE.mdx
@@ -145,14 +145,14 @@ target/wasm32-unknown-unknown/release/soroban_hello_world_contract.wasm
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke contract functions using it.
+If you have [`stellar-cli`] installed, you can invoke contract functions using it.
 
 <Tabs groupId="platform" defaultValue={getPlatform()}>
 
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --wasm target/wasm32-unknown-unknown/release/soroban_hello_world_contract.wasm \
     --id 1 \
     -- \
@@ -165,7 +165,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke `
+stellar contract invoke `
     --wasm target/wasm32-unknown-unknown/release/soroban_hello_world_contract.wasm `
     --id 1 `
     -- `
@@ -177,7 +177,7 @@ soroban contract invoke `
 
 </Tabs>
 
-[`soroban-cli`]: ../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../getting-started/setup.mdx#install-the-stellar-cli
 
 ## Further Reading
 
diff --git a/docs/smart-contracts/example-contracts/auth.mdx b/docs/smart-contracts/example-contracts/auth.mdx
index caee82a69..24fb74e76 100644
--- a/docs/smart-contracts/example-contracts/auth.mdx
+++ b/docs/smart-contracts/example-contracts/auth.mdx
@@ -273,10 +273,10 @@ assert_eq!(client.increment(&user_2, &4), 5);
 
 ## Build the Contract
 
-To build the contract into a `.wasm` file, use the `soroban contract build` command.
+To build the contract into a `.wasm` file, use the `stellar contract build` command.
 
 ```sh
-soroban contract build
+stellar contract build
 ```
 
 The `.wasm` file should be found in the `target` directory after building:
@@ -287,15 +287,15 @@ target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke functions on the contract.
+If you have [`stellar-cli`] installed, you can invoke functions on the contract.
 
 But since we are dealing with authorization and signatures, we need to set up some identities to use for testing and get their public keys:
 
 ```sh
-soroban keys generate acc1
-soroban keys generate acc2
-soroban keys address acc1
-soroban keys address acc2
+stellar keys generate acc1
+stellar keys generate acc2
+stellar keys address acc1
+stellar keys address acc2
 ```
 
 Example output with two public keys of identities:
@@ -305,14 +305,14 @@ GA6S566FD3EQDUNQ4IGSLXKW3TGVSTQW3TPHPGS7NWMCEIPBOKTNCSRU
 GAJGHZ44IJXYFNOVRZGBCVKC2V62DB2KHZB7BEMYOWOLFQH4XP2TAM6B
 ```
 
-Now the contract itself can be invoked. Notice the `--source` must be the identity name matching the address passed to the `--user` argument. This allows `soroban` tool to automatically sign the necessary payload for the invocation.
+Now the contract itself can be invoked. Notice the `--source` must be the identity name matching the address passed to the `--user` argument. This allows `Stellar CLI` to automatically sign the necessary payload for the invocation.
 
 <Tabs groupId="platform" defaultValue={getPlatform()}>
 
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --source acc1 \
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm \
     --id 1 \
@@ -327,7 +327,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke `
+stellar contract invoke `
     --source acc1 `
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm `
     --id 1 `
@@ -348,7 +348,7 @@ Run a few more increments for both accounts.
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --source acc2 \
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm \
     --id 1 \
@@ -359,7 +359,7 @@ soroban contract invoke \
 ```
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --source acc1 \
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm \
     --id 1 \
@@ -370,7 +370,7 @@ soroban contract invoke \
 ```
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --source acc2 \
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm \
     --id 1 \
@@ -385,7 +385,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke \
+stellar contract invoke \
     --source acc2 \
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm \
     --id 1 \
@@ -396,7 +396,7 @@ soroban contract invoke \
 ```
 
 ```powershell
-soroban contract invoke \
+stellar contract invoke \
     --source acc1 \
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm \
     --id 1 \
@@ -407,7 +407,7 @@ soroban contract invoke \
 ```
 
 ```powershell
-soroban contract invoke \
+stellar contract invoke \
     --source acc2 \
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm \
     --id 1 \
@@ -421,10 +421,10 @@ soroban contract invoke \
 
 </Tabs>
 
-View the data that has been stored against each user with `soroban contract read`.
+View the data that has been stored against each user with `stellar contract read`.
 
 ```sh
-soroban contract read --id 1
+stellar contract read --id 1
 ```
 
 ```
@@ -439,7 +439,7 @@ It is also possible to preview the authorization payload that is being signed by
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --source acc2 \
     --auth \
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm \
@@ -455,7 +455,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke `
+stellar contract invoke `
     --source acc2 `
     --auth `
     --wasm target/wasm32-unknown-unknown/release/soroban_auth_contract.wasm `
@@ -474,7 +474,7 @@ soroban contract invoke `
 Contract auth: [{"address_with_nonce":null,"root_invocation":{"contract_id":"0000000000000000000000000000000000000000000000000000000000000001","function_name":"increment","args":[{"object":{"address":{"account":{"public_key_type_ed25519":"c7bab0288753d58d3e21cc3fa68cd2546b5f78ae6635a6f1b3fe07e03ee846e9"}}}},{"u32":123}],"sub_invocations":[]},"signature_args":[]}]
 ```
 
-[`soroban-cli`]: ../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../getting-started/setup.mdx#install-the-stellar-cli
 
 ## Further reading
 
diff --git a/docs/smart-contracts/example-contracts/cross-contract-call.mdx b/docs/smart-contracts/example-contracts/cross-contract-call.mdx
index 0f08e9519..230e474b6 100644
--- a/docs/smart-contracts/example-contracts/cross-contract-call.mdx
+++ b/docs/smart-contracts/example-contracts/cross-contract-call.mdx
@@ -225,10 +225,10 @@ assert_eq!(sum, 12);
 
 ## Build the Contracts
 
-To build the contract into a `.wasm` file, use the `soroban contract build` command. Both `contract_call/contract_a` and `contract_call/contract_b` must be built, with `contract_a` being built first.
+To build the contract into a `.wasm` file, use the `stellar contract build` command. Both `contract_call/contract_a` and `contract_call/contract_b` must be built, with `contract_a` being built first.
 
 ```sh
-soroban contract build
+stellar contract build
 ```
 
 Both `.wasm` files should be found in both contract `target` directories after building both contracts:
@@ -243,20 +243,20 @@ target/wasm32-unknown-unknown/release/soroban_cross_contract_b_contract.wasm
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke contract functions. Both contracts must be deployed.
+If you have [`stellar-cli`] installed, you can invoke contract functions. Both contracts must be deployed.
 
 <Tabs groupId="platform" defaultValue={getPlatform()}>
 
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract deploy \
+stellar contract deploy \
     --wasm target/wasm32-unknown-unknown/release/soroban_cross_contract_a_contract.wasm \
     --id a
 ```
 
 ```sh
-soroban contract deploy \
+stellar contract deploy \
     --wasm target/wasm32-unknown-unknown/release/soroban_cross_contract_b_contract.wasm \
     --id b
 ```
@@ -266,13 +266,13 @@ soroban contract deploy \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract deploy `
+stellar contract deploy `
     --wasm target/wasm32-unknown-unknown/release/soroban_cross_contract_a_contract.wasm `
     --id a
 ```
 
 ```powershell
-soroban contract deploy `
+stellar contract deploy `
     --wasm target/wasm32-unknown-unknown/release/soroban_cross_contract_b_contract.wasm `
     --id b
 ```
@@ -288,7 +288,7 @@ Invoke Contract B's `add_with` function, passing in values for `x` and `y` (e.g.
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --id b \
     -- \
     add_with \
@@ -302,7 +302,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke `
+stellar contract invoke `
     --id b `
     -- `
     add_with `
@@ -323,4 +323,4 @@ The following output should occur using the code above.
 
 Contract B's `add_with` function invoked Contract A's `add` function to do the addition.
 
-[`soroban-cli`]: ../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../getting-started/setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/example-contracts/custom-types.mdx b/docs/smart-contracts/example-contracts/custom-types.mdx
index 05205b75f..4ac165128 100644
--- a/docs/smart-contracts/example-contracts/custom-types.mdx
+++ b/docs/smart-contracts/example-contracts/custom-types.mdx
@@ -234,10 +234,10 @@ assert_eq!(
 
 ## Build the Contract
 
-To build the contract, use the `soroban contract build` command.
+To build the contract, use the `stellar contract build` command.
 
 ```sh
-soroban contract build
+stellar contract build
 ```
 
 A `.wasm` file should be outputted in the `target` directory:
@@ -248,14 +248,14 @@ target/wasm32-unknown-unknown/release/soroban_custom_types_contract.wasm
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke contract functions in the Wasm using it.
+If you have [`stellar-cli`] installed, you can invoke contract functions in the Wasm using it.
 
 <Tabs groupId="platform" defaultValue={getPlatform()}>
 
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --wasm target/wasm32-unknown-unknown/release/soroban_custom_types_contract.wasm \
     --id 1 \
     -- \
@@ -268,7 +268,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke `
+stellar contract invoke `
     --wasm target/wasm32-unknown-unknown/release/soroban_custom_types_contract.wasm `
     --id 1 `
     -- `
@@ -288,14 +288,14 @@ The following output should occur using the code above.
 
 Run it a few more times with different increment amounts to watch the count change.
 
-Use the `soroban` to inspect what the counter is after a few runs.
+Use the `stellar-cli` to inspect what the counter is after a few runs.
 
 ```sh
-soroban contract read --id 1 --key STATE
+stellar contract read --id 1 --key STATE
 ```
 
 ```
 STATE,"{""count"":25,""last_incr"":15}"
 ```
 
-[`soroban-cli`]: ../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../getting-started/setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/example-contracts/deployer.mdx b/docs/smart-contracts/example-contracts/deployer.mdx
index 50ea7b308..2631de83e 100644
--- a/docs/smart-contracts/example-contracts/deployer.mdx
+++ b/docs/smart-contracts/example-contracts/deployer.mdx
@@ -452,7 +452,7 @@ target/wasm32-unknown-unknown/release/soroban_deployer_test_contract.wasm
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke the contract function to deploy the test contract.
+If you have [`stellar-cli`] installed, you can invoke the contract function to deploy the test contract.
 
 Before deploying the test contract with the deployer, install the test contract Wasm using the `install` command. The `install` command will print out the hash derived from the Wasm file (it's not just the hash of the Wasm file itself though) which should be used by the deployer.
 
@@ -536,4 +536,4 @@ The following output should occur using the code above.
 5
 ```
 
-[`soroban-cli`]: ../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../getting-started/setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/example-contracts/errors.mdx b/docs/smart-contracts/example-contracts/errors.mdx
index 34794114b..6c95a1d5a 100644
--- a/docs/smart-contracts/example-contracts/errors.mdx
+++ b/docs/smart-contracts/example-contracts/errors.mdx
@@ -289,10 +289,10 @@ client.increment();
 
 ## Build the Contract
 
-To build the contract, use the `soroban contract build` command.
+To build the contract, use the `stellar contract build` command.
 
 ```sh
-soroban contract build
+stellar contract build
 ```
 
 A `.wasm` file should be outputted in the `target` directory:
@@ -310,7 +310,7 @@ Let's deploy the contract to Testnet so we can run it. The value provided as `--
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract deploy \
+stellar contract deploy \
   --wasm target/wasm32-unknown-unknown/release/soroban_errors_contract.wasm \
   --source alice \
   --network testnet
@@ -321,7 +321,7 @@ soroban contract deploy \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract deploy `
+stellar contract deploy `
   --wasm target/wasm32-unknown-unknown/release/soroban_errors_contract.wasm `
   --source alice `
   --network testnet
@@ -340,7 +340,7 @@ Now that we've deployed the contract, we can invoke it.
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --id CC3UMHVTIEH6GGDBW7MM72Q545HBDCXGU3GMIXP23PQVSBFKNZRWT37X \
     --network testnet \
     --source alice \
@@ -353,7 +353,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke `
+stellar contract invoke `
     --id CC3UMHVTIEH6GGDBW7MM72Q545HBDCXGU3GMIXP23PQVSBFKNZRWT37X `
     --network testnet `
     --source alice `
@@ -380,14 +380,14 @@ Caused by:
 ...
 ```
 
-To retrieve the current counter value, use the command `soroban contract read`.
+To retrieve the current counter value, use the command `stellar contract read`.
 
 <Tabs groupId="platform" defaultValue={getPlatform()}>
 
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract read \
+stellar contract read \
   --id CC3UMHVTIEH6GGDBW7MM72Q545HBDCXGU3GMIXP23PQVSBFKNZRWT37X \
   --network testnet \
   --source alice \
@@ -400,7 +400,7 @@ soroban contract read \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract read `
+stellar contract read `
   --id CC3UMHVTIEH6GGDBW7MM72Q545HBDCXGU3GMIXP23PQVSBFKNZRWT37X `
   --network testnet `
   --source alice `
@@ -412,4 +412,4 @@ soroban contract read `
 
 </Tabs>
 
-[`soroban-cli`]: ../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../getting-started/setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/example-contracts/events.mdx b/docs/smart-contracts/example-contracts/events.mdx
index cbca44e59..907425443 100644
--- a/docs/smart-contracts/example-contracts/events.mdx
+++ b/docs/smart-contracts/example-contracts/events.mdx
@@ -221,10 +221,10 @@ assert_eq!(
 
 ## Build the Contract
 
-To build the contract, use the `soroban contract build` command.
+To build the contract, use the `stellar contract build` command.
 
 ```sh
-soroban contract build
+stellar contract build
 ```
 
 A `.wasm` file should be outputted in the `target` directory:
@@ -235,14 +235,14 @@ target/wasm32-unknown-unknown/release/soroban_events_contract.wasm
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke contract functions in the using it.
+If you have [`stellar-cli`] installed, you can invoke contract functions in the using it.
 
 <Tabs groupId="platform" defaultValue={getPlatform()}>
 
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --wasm target/wasm32-unknown-unknown/release/soroban_events_contract.wasm \
     --id 1 \
     -- \
@@ -254,7 +254,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke `
+stellar contract invoke `
     --wasm target/wasm32-unknown-unknown/release/soroban_events_contract.wasm `
     --id 1 `
     -- `
@@ -274,4 +274,4 @@ The following output should occur using the code above.
 
 A single event `#0` is outputted, which is the contract event the contract published. The event contains the two topics, each a `symbol` (displayed as bytes), and the data object containing the `u32`.
 
-[`soroban-cli`]: ../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../getting-started/setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/example-contracts/liquidity-pool.mdx b/docs/smart-contracts/example-contracts/liquidity-pool.mdx
index d8712d3f4..513fcb915 100644
--- a/docs/smart-contracts/example-contracts/liquidity-pool.mdx
+++ b/docs/smart-contracts/example-contracts/liquidity-pool.mdx
@@ -869,10 +869,10 @@ These tests examine the "typical" use-case of a liquidity pool, ensuring that th
 
 ## Build the Contract
 
-To build the contract, use the `soroban contract build` command.
+To build the contract, use the `stellar contract build` command.
 
 ```sh
-soroban contract build
+stellar contract build
 ```
 
 A `.wasm` file should be outputted in the `target` directory:
@@ -883,14 +883,14 @@ target/wasm32-unknown-unknown/release/soroban_liquidity_pool_contract.wasm
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke contract functions using it.
+If you have [`stellar-cli`] installed, you can invoke contract functions using it.
 
 <Tabs groupId="platform" defaultValue={getPlatform()}>
 
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --wasm target/wasm32-unknown-unknown/release/soroban_liquidity_pool_contract.wasm \
     --id 1 \
     -- \
@@ -907,7 +907,7 @@ soroban contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban contract invoke `
+stellar contract invoke `
     --wasm target/wasm32-unknown-unknown/release/soroban_liquidity_pool_contract.wasm `
     --id 1 `
     -- `
@@ -923,4 +923,4 @@ soroban contract invoke `
 
 </Tabs>
 
-[`soroban-cli`]: ../../tools/developer-tools.mdx#cli
+[`stellar-cli`]: ../../tools/developer-tools.mdx#cli
diff --git a/docs/smart-contracts/example-contracts/logging.mdx b/docs/smart-contracts/example-contracts/logging.mdx
index 723bb894c..77cc99cf5 100644
--- a/docs/smart-contracts/example-contracts/logging.mdx
+++ b/docs/smart-contracts/example-contracts/logging.mdx
@@ -96,11 +96,11 @@ Ref: https://github.com/stellar/soroban-examples/tree/v20.0.0/logging
 
 ## How it Works
 
-The [`log!`] macro logs a string. Any logs that occur during execution are outputted to stdout in [`soroban-cli`] and available for tests to assert on or print.
+The [`log!`] macro logs a string. Any logs that occur during execution are outputted to stdout in [`stellar-cli`] and available for tests to assert on or print.
 
 Logs are only outputted if the contract is built with the `debug-assertions` compiler option enabled. This makes them efficient to leave in code permanently since a regular `release` build will omit them.
 
-Logs are only recorded in Soroban environments that have logging enabled. The only Soroban environments where logging is enabled is in Rust tests, and in the [`soroban-cli`].
+Logs are only recorded in Soroban environments that have logging enabled. The only Soroban environments where logging is enabled is in Rust tests, and in the [`stellar-cli`].
 
 Open the files above to follow along.
 
@@ -208,14 +208,14 @@ std::println!("{}", logs.join("\n"));
 
 ## Build the Contract
 
-To build the contract, use the `soroban contract build` command.
+To build the contract, use the `stellar contract build` command.
 
 ### Without Logs
 
 To build the contract without logs, use the `--release` option.
 
 ```sh
-soroban contract build
+stellar contract build
 ```
 
 A `.wasm` file should be outputted in the `target` directory, in the `release` subdirectory:
@@ -229,7 +229,7 @@ target/wasm32-unknown-unknown/release/soroban_logging_contract.wasm
 To build the contract with logs, use the `--profile release-with-logs` option.
 
 ```sh
-soroban contract build --profile release-with-logs
+stellar contract build --profile release-with-logs
 ```
 
 A `.wasm` file should be outputted in the `target` directory, in the `release-with-logs` subdirectory:
@@ -240,14 +240,14 @@ target/wasm32-unknown-unknown/release-with-logs/soroban_logging_contract.wasm
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke contract functions in the using it. Specify the `-v` option to enable verbose logs.
+If you have [`stellar-cli`] installed, you can invoke contract functions in the using it. Specify the `-v` option to enable verbose logs.
 
 <Tabs groupId="platform" defaultValue={getPlatform()}>
 
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban -v contract invoke \
+stellar -v contract invoke \
     --wasm target/wasm32-unknown-unknown/release-with-logs/soroban_logging_contract.wasm \
     --id 1 \
     -- \
@@ -260,7 +260,7 @@ soroban -v contract invoke \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban -v contract invoke `
+stellar -v contract invoke `
     --wasm target/wasm32-unknown-unknown/release-with-logs/soroban_logging_contract.wasm `
     --id 1 `
     -- `
@@ -275,8 +275,8 @@ soroban -v contract invoke `
 The output should include the following line.
 
 ```
-soroban_cli::log::event::contract_log: log="Hello Symbol(me)"
+stellar_cli::log::event::contract_log: log="Hello Symbol(me)"
 ```
 
 [`log!`]: https://docs.rs/soroban-sdk/latest/soroban_sdk/macro.log.html
-[`soroban-cli`]: ../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../getting-started/setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/getting-started/create-an-app.mdx b/docs/smart-contracts/getting-started/create-an-app.mdx
index f9adb586e..3a12ed929 100644
--- a/docs/smart-contracts/getting-started/create-an-app.mdx
+++ b/docs/smart-contracts/getting-started/create-an-app.mdx
@@ -16,12 +16,12 @@ Let's get started.
 
 You're going to need [Node.js](https://nodejs.org/en/download/package-manager/) v18.14.1 or greater. If you haven't yet, install it now.
 
-We want to initialize our current project as an Astro project. To do this, we can again turn to the `soroban contract init` command, which has a `--frontend-template` flag that allows us to pass the url of a frontend template repository. As we learned in [Storing Data](storing-data.mdx#adding-the-increment-contract), `soroban contract init` will not overwrite existing files, and is safe to use to add to an existing project.
+We want to initialize our current project as an Astro project. To do this, we can again turn to the `stellar contract init` command, which has a `--frontend-template` flag that allows us to pass the url of a frontend template repository. As we learned in [Storing Data](storing-data.mdx#adding-the-increment-contract), `stellar contract init` will not overwrite existing files, and is safe to use to add to an existing project.
 
 From our `soroban-hello-world` directory, run the following command to add the Astro template files.
 
 ```sh
-soroban contract init ./ \
+stellar contract init ./ \
   --frontend-template https://github.com/stellar/soroban-astro-template
 ```
 
@@ -50,12 +50,12 @@ This will add the following to your project, which we'll go over in more detail
 
 Before we open the new frontend files, let's generate an NPM package for the Hello World contract. This is our suggested way to interact with contracts from frontends. These generated libraries work with any JavaScript project (not a specific UI like React), and make it easy to work with some of the trickiest bits of Soroban, like encoding [XDR](../../learn/encyclopedia/contract-development/types/fully-typed-contracts.mdx).
 
-This is going to use the CLI command `soroban contract bindings typescript`:
+This is going to use the CLI command `stellar contract bindings typescript`:
 
 ```bash
-soroban contract bindings typescript \
+stellar contract bindings typescript \
   --network testnet \
-  --contract-id $(cat .soroban/contract-ids/hello_world.txt) \
+  --contract-id $(cat .stellar/contract-ids/hello_world.txt) \
   --output-dir packages/hello_world
 ```
 
@@ -403,7 +403,7 @@ If you want to take it a bit further and make sure you understand all the pieces
 - Make a `src/contracts` folder with a `greeter.ts` and an `incrementor.ts`. Move the `new Contract({ ... })` logic into those files. You may also want to extract the `rpcUrl` variable to a `src/contracts/utils.ts` file.
 - Add a `get_value` method to the `increment` contract, and use it to display the current value in the `Counter` component. When you run `npm run dev`, the `initialize` script will run and update the contract and the generated client.
 - Add a "Decrement" button to the `Counter` component.
-- [Deploy](https://docs.astro.build/en/guides/deploy/) your frontend. You can do this quickly and for free [with GitHub](https://docs.astro.build/en/guides/deploy/github/). If you get stuck installing soroban-cli and deploying contracts on GitHub, check out [how we did this](https://github.com/AhaLabs/soroban-tutorial-project/commit/c1f4cfde1bbaf059507100767ee6b43d29b42914).
+- [Deploy](https://docs.astro.build/en/guides/deploy/) your frontend. You can do this quickly and for free [with GitHub](https://docs.astro.build/en/guides/deploy/github/). If you get stuck installing stellar-cli and deploying contracts on GitHub, check out [how we did this](https://github.com/AhaLabs/soroban-tutorial-project/commit/c1f4cfde1bbaf059507100767ee6b43d29b42914).
 - Rather than using NPM scripts for everything, try using a more elegant script runner such as [just](https://github.com/casey/just). The existing npm `scripts` can then call `just`, such as `"setup": "just setup"`.
 - Update the README to explain what this project is and how to use it to potential collaborators and employers 😉
 
@@ -419,7 +419,7 @@ Sometimes the call to `hello` can start failing. You can obviously stub out the
 
 One of the common problems here is that the contract becomes [archived](../../learn/encyclopedia/storage/state-archival.mdx). To check if this is the problem, you can re-run `npm run init`.
 
-If you're still having problems, join our Discord (link above) or [open an issue in GitHub](https://github.com/stellar/soroban-docs/issues/new/choose).
+If you're still having problems, join our Discord (link above) or [open an issue in GitHub](https://github.com/stellar/stellar-docs/issues/new/choose).
 
 ### All contract calls start throwing `403` errors
 
@@ -431,11 +431,13 @@ Some of the things we did in this section:
 
 - We learned about Astro's no-JS-by-default approach
 - We added Astro components and learned how their `script` and `style` tags work
-- We saw how easy it is to interact with Soroban contracts from JavaScript by generating client libraries using `soroban contract bindings typescript`
+- We saw how easy it is to interact with smart contracts from JavaScript by generating client libraries using `stellar contract bindings typescript`
 - We learned about wallets and Freighter
 
-At this point, you've seen a full end-to-end example of building on Soroban! What's next? You choose! You can:
+At this point, you've seen a full end-to-end example of building a contract on Stellar! What's next? You choose! You can:
 
 - See more complex example contracts in the [Tutorials](../example-contracts/README.mdx) section.
-- Learn more about the [internal architecture and design](../../learn/encyclopedia/contract-development/) of Soroban.
+
+- Learn more about the [internal architecture and design](../../learn/encyclopedia/contract-development/) of smart contract on Stellar.
+
 - Check out a more full-featured [example app](https://github.com/stellar/soroban-example-dapp), which uses React rather than vanilla JavaScript and Next.js rather than Astro. This app also has a more complex setup & initialization process, with the option of using a [locally-hosted RPC node](/network/soroban-rpc/admin-guide).
diff --git a/docs/smart-contracts/getting-started/hello-world.mdx b/docs/smart-contracts/getting-started/hello-world.mdx
index d131618bb..3497ccc28 100644
--- a/docs/smart-contracts/getting-started/hello-world.mdx
+++ b/docs/smart-contracts/getting-started/hello-world.mdx
@@ -19,14 +19,14 @@ description: Create your first smart contract in Rust.
 import Tabs from "@theme/Tabs";
 import TabItem from "@theme/TabItem";
 
-Once you've [set up](./setup.mdx) your development environment, you're ready to create your first Soroban contract.
+Once you've [set up](./setup.mdx) your development environment, you're ready to create your first smart contract.
 
 ## Create a New Project
 
 Create a new project using the `init` command to create a `soroban-hello-world` project.
 
 ```sh
-soroban contract init soroban-hello-world
+stellar contract init soroban-hello-world
 ```
 
 The `init` command will create a Rust workspace project, using the recommended structure for including Soroban contracts. Let’s take a look at the project structure:
@@ -46,7 +46,7 @@ The `init` command will create a Rust workspace project, using the recommended s
 
 ### Cargo.toml
 
-The `Cargo.toml` file at the root of the project is set up as Rust Workspace, which allows us to include multiple Soroban contracts in one project.
+The `Cargo.toml` file at the root of the project is set up as Rust Workspace, which allows us to include multiple smart contracts in one project.
 
 #### Rust Workspace
 
@@ -89,7 +89,7 @@ lto = true
 
 #### `release-with-logs` Profile
 
-Configuring a `release-with-logs` profile can be useful if you need to build a `.wasm` file that has logs enabled for printing debug logs when using the [`soroban-cli`]. Note that this is not necessary to access debug logs in tests or to use a step-through-debugger.
+Configuring a `release-with-logs` profile can be useful if you need to build a `.wasm` file that has logs enabled for printing debug logs when using the [`stellar-cli`]. Note that this is not necessary to access debug logs in tests or to use a step-through-debugger.
 
 ```toml
 [profile.release-with-logs]
@@ -299,10 +299,10 @@ The first time you run the tests you may see output in the terminal of cargo com
 
 ## Build the contract
 
-To build a Soroban contract to deploy or run, use the `soroban contract build` command.
+To build a smart contract to deploy or run, use the `stellar contract build` command.
 
 ```sh
-soroban contract build
+stellar contract build
 ```
 
 This is a small wrapper around `cargo build` that sets the target to `wasm32-unknown-unknown` and the profile to `release`. You can think of it as a shortcut for the following command:
@@ -317,16 +317,16 @@ The `.wasm` file contains the logic of the contract, as well as the contract's [
 
 ## Optimizing Builds
 
-Use `soroban contract optimize` to further minimize the size of the `.wasm`. First, re-install soroban-cli with the `opt` feature:
+Use `stellar contract optimize` to further minimize the size of the `.wasm`. First, re-install stellar-cli with the `opt` feature:
 
 ```sh
-cargo install --locked soroban-cli --features opt
+cargo install --locked stellar-cli --features opt
 ```
 
 Then build an optimized `.wasm` file:
 
 ```sh
-soroban contract optimize --wasm target/wasm32-unknown-unknown/release/hello_world.wasm
+stellar contract optimize --wasm target/wasm32-unknown-unknown/release/hello_world.wasm
 ```
 
 This will optimize and output a new `hello_world.optimized.wasm` file in the same location as the input `.wasm`.
@@ -344,4 +344,4 @@ In this section, we wrote a simple contract that can be deployed to a Soroban ne
 Next we'll learn to deploy the HelloWorld contract to Stellar's Testnet network and interact with it over RPC using the CLI.
 
 [rust unit tests]: https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html
-[`soroban-cli`]: setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/getting-started/setup.mdx b/docs/smart-contracts/getting-started/setup.mdx
index 10d4776bc..05164e16b 100644
--- a/docs/smart-contracts/getting-started/setup.mdx
+++ b/docs/smart-contracts/getting-started/setup.mdx
@@ -21,13 +21,13 @@ import Tabs from "@theme/Tabs";
 import TabItem from "@theme/TabItem";
 import { getPlatform } from "@site/src/helpers/getPlatform";
 
-Soroban contracts are small programs written in the [Rust] programming language.
+Stellar smart contracts are small programs written in the [Rust] programming language.
 
 To build and develop contracts you need only a couple prerequisites:
 
 - A [Rust] toolchain
 - An editor that supports Rust
-- [Soroban CLI]
+- [Stellar CLI]
 
 ## Install Rust
 
@@ -45,7 +45,7 @@ On Windows, download and run [rustup-init.exe](https://static.rust-lang.org/rust
 
 :::tip
 
-The soroban CLI uses emojis in its output. To properly render them on Windows, it is recommended to use the [Windows Terminal](https://learn.microsoft.com/en-us/windows/terminal/). See [how to install Windows Terminal](https://learn.microsoft.com/en-us/windows/terminal/install) on Microsoft Learn. If the CLI is used in the built in Windows Command Prompt or Windows PowerShell the CLI will function as expected but the emojis will appear as question marks.
+The Stellar CLI uses emojis in its output. To properly render them on Windows, it is recommended to use the [Windows Terminal](https://learn.microsoft.com/en-us/windows/terminal/). See [how to install Windows Terminal](https://learn.microsoft.com/en-us/windows/terminal/install) on Microsoft Learn. If the CLI is used in the built in Windows Command Prompt or Windows PowerShell the CLI will function as expected but the emojis will appear as question marks.
 
 :::
 
@@ -77,38 +77,38 @@ A popular editor is Visual Studio Code:
 [rust analyzer]: https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer
 [codelldb]: https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb
 
-## Install the Soroban CLI
+## Install the Stellar CLI
 
-The [Soroban CLI](http://github.com/stellar/soroban-cli) can execute Soroban contracts in the same environment the contract will execute on network, however in a local sandbox.
+The [Stellar CLI](https://github.com/stellar/stellar-cli) can execute smart contracts in the same environment the contract will execute on network, however in a local sandbox.
 
-Install the [latest released version](https://github.com/stellar/soroban-cli/releases) of Soroban CLI using `cargo install`.
+Install the [latest released version](https://github.com/stellar/stellar-cli/releases) of Stellar CLI using `cargo install`.
 
 ```sh
-cargo install --locked soroban-cli --version 21.0.0-rc.1
+cargo install --locked stellar-cli
 ```
 
 :::info
 
-Report issues and share feedback about the Soroban CLI [here](https://github.com/stellar/soroban-cli/issues/new/choose).
+Report issues and share feedback about the Stellar CLI [here](https://github.com/stellar/stellar-cli/issues/new/choose).
 
 :::
 
 ### Usage
 
-Run the `soroban` command and you should see output like below.
+Run the `stellar` command and you should see output like below.
 
 ```sh
-soroban
+stellar
 ```
 
 ```console
-$ soroban
+$ stellar
 Build, deploy, & interact with contracts; set identities to sign with; configure networks; generate keys; and more.
 
 Stellar Docs: https://developers.stellar.org
-CLI Full Hep Docs: https://github.com/stellar/soroban-cli/tree/main/FULL_HELP_DOCS.md
+CLI Reference: https://github.com/stellar/stellar-cli/blob/main/FULL_HELP_DOCS.md
 
-Usage: soroban [OPTIONS] <COMMAND>
+Usage: stellar [OPTIONS] <COMMAND>
 
 Commands:
   completion  Print shell completion code for the specified shell
@@ -137,18 +137,18 @@ TESTING_OPTIONS:
 
 :::tip
 
-You can use `soroban completion` to generate shell completion for `bash`, `elvish`, `fish`, `powershell`, and `zsh`. You should absolutely try it out. It will feel like a super power!
+You can use `stellar completion` to generate shell completion for `bash`, `elvish`, `fish`, `powershell`, and `zsh`. You should absolutely try it out. It will feel like a super power!
 
 To enable autocomplete in the current bash shell, run:
 
 ```sh
-source <(soroban completion --shell bash)
+source <(stellar completion --shell bash)
 ```
 
 To enable autocomplete permanently in future bash shells, run:
 
 ```sh
-echo "source <(soroban completion --shell bash)" >> ~/.bashrc
+echo "source <(stellar completion --shell bash)" >> ~/.bashrc
 ```
 
 Users of non-bash shells may need to adapt the above commands to suit their needs.
@@ -157,7 +157,7 @@ Users of non-bash shells may need to adapt the above commands to suit their need
 
 ### Configuring the CLI for Testnet
 
-Soroban has a test network called Testnet that you can use to deploy and test your smart contracts. It's a live network, but it's not the same as the Stellar public network. It's a separate network that is used for development and testing, so you can't use it for production apps. But it's a great place to test your contracts before you deploy them to the public network.
+Stellar has a test network called Testnet that you can use to deploy and test your smart contracts. It's a live network, but it's not the same as the Stellar public network. It's a separate network that is used for development and testing, so you can't use it for production apps. But it's a great place to test your contracts before you deploy them to the public network.
 
 To configure your CLI to interact with Testnet, run the following command:
 
@@ -166,7 +166,7 @@ To configure your CLI to interact with Testnet, run the following command:
 <TabItem value="unix" label="macOS/Linux">
 
 ```sh
-soroban network add \
+stellar network add \
   --global testnet \
   --rpc-url https://soroban-testnet.stellar.org:443 \
   --network-passphrase "Test SDF Network ; September 2015"
@@ -177,7 +177,7 @@ soroban network add \
 <TabItem value="windows" label="Windows (PowerShell)">
 
 ```powershell
-soroban network add `
+stellar network add `
   --global testnet `
   --rpc-url https://soroban-testnet.stellar.org:443 `
   --network-passphrase "Test SDF Network ; September 2015"
@@ -187,7 +187,7 @@ soroban network add `
 
 </Tabs>
 
-Note the `--global` flag. This creates a file in your home folder's `~/.config/soroban/network/testnet.toml` with the settings you specified. This means that you can use the `--network testnet` flag in any Soroban CLI command to use this network from any directory or filepath on your system.
+Note the `--global` flag. This creates a file in your home folder's `~/.config/soroban/network/testnet.toml` with the settings you specified. This means that you can use the `--network testnet` flag in any Stellar CLI command to use this network from any directory or filepath on your system.
 
 If you want project-specific network configurations, you can omit the `--global` flag, and the networks will be added to your working directory's `.soroban/network` folder instead.
 
@@ -198,18 +198,18 @@ When you deploy a smart contract to a network, you need to specify an identity t
 Let's configure an identity called `alice`. You can use any name you want, but it might be nice to have some named identities that you can use for testing, such as [`alice`, `bob`, and `carol`](https://en.wikipedia.org/wiki/Alice_and_Bob).
 
 ```sh
-soroban keys generate --global alice --network testnet
+stellar keys generate --global alice --network testnet
 ```
 
 You can see the public key of `alice` with:
 
 ```sh
-soroban keys address alice
+stellar keys address alice
 ```
 
 Like the Network configs, the `--global` means that the identity gets stored in `~/.config/soroban/identity/alice.toml`. You can omit the `--global` flag to store the identity in your project's `.soroban/identity` folder instead.
 
-By default, `soroban keys generate` will fund the account using [Friendbot](https://developers.stellar.org/docs/fundamentals-and-concepts/testnet-and-pubnet#friendbot). To disable this behavior, append `--no-fund` to the command when running it.
+By default, `stellar keys generate` will fund the account using [Friendbot](https://developers.stellar.org/docs/fundamentals-and-concepts/testnet-and-pubnet#friendbot). To disable this behavior, append `--no-fund` to the command when running it.
 
 [rust]: https://www.rust-lang.org/
-[soroban cli]: setup.mdx#install-the-soroban-cli
+[stellar cli]: setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/guides/cli/README.mdx b/docs/smart-contracts/guides/cli/README.mdx
index 9b25a5692..43943e489 100644
--- a/docs/smart-contracts/guides/cli/README.mdx
+++ b/docs/smart-contracts/guides/cli/README.mdx
@@ -1,8 +1,8 @@
 ---
-title: Soroban CLI
+title: Stellar CLI
 hide_table_of_contents: true
 ---
 
-The [Soroban CLI] is a crucial tool for developers to use while creating and interacting with Soroban smart contracts.
+The [Stellar CLI] is a crucial tool for developers to use while creating and interacting with Soroban smart contracts.
 
-[soroban cli]: ../../../tools/developer-tools.mdx#cli
+[stellar cli]: ../../../tools/developer-tools.mdx#cli
diff --git a/docs/smart-contracts/guides/cli/deploy-stellar-asset-contract.mdx b/docs/smart-contracts/guides/cli/deploy-stellar-asset-contract.mdx
index dbdbfa2c0..1f13d36c5 100644
--- a/docs/smart-contracts/guides/cli/deploy-stellar-asset-contract.mdx
+++ b/docs/smart-contracts/guides/cli/deploy-stellar-asset-contract.mdx
@@ -3,11 +3,11 @@ title: Deploy the Stellar Asset Contract for a Stellar Asset
 hide_table_of_contents: true
 ---
 
-The Soroban CLI can deploy a [Stellar Asset Contract] for a Stellar asset so that any Soroban contract can interact with the asset.
+The Stellar CLI can deploy a [Stellar Asset Contract] for a Stellar asset so that any Stellar smart contract can interact with the asset.
 
 Every Stellar asset has reserved a contract that anyone can deploy. Once deployed any contract can interact with that asset by holding a balance of the asset, receiving the asset, or sending the asset.
 
-Deploying the Stellar Asset Contract for a Stellar asset enables that asset for use on Soroban.
+Deploying the Stellar Asset Contract for a Stellar asset enables that asset for use in smart contracts.
 
 The Stellar Asset Contract can be deployed for any possible Stellar asset, either assets already in use on Stellar or assets that have never seen any activity. This means that the issuer doesn't need to have been created, and no one needs to be yet holding the asset on Stellar.
 
diff --git a/docs/smart-contracts/guides/cli/extend-contract-instance.mdx b/docs/smart-contracts/guides/cli/extend-contract-instance.mdx
index b70db7483..8148c2f48 100644
--- a/docs/smart-contracts/guides/cli/extend-contract-instance.mdx
+++ b/docs/smart-contracts/guides/cli/extend-contract-instance.mdx
@@ -3,7 +3,7 @@ title: Extend a deployed contract instance's TTL
 hide_table_of_contents: true
 ---
 
-You can use the Soroban CLI to extend the TTL of a contract instance like so:
+You can use the Stellar CLI to extend the TTL of a contract instance like so:
 
 ```bash
 soroban contract extend \
diff --git a/docs/smart-contracts/guides/cli/extend-contract-storage.mdx b/docs/smart-contracts/guides/cli/extend-contract-storage.mdx
index a7c7d04e0..0f3c6bf05 100644
--- a/docs/smart-contracts/guides/cli/extend-contract-storage.mdx
+++ b/docs/smart-contracts/guides/cli/extend-contract-storage.mdx
@@ -3,7 +3,7 @@ title: Extend a deployed contract's storage entry TTL
 hide_table_of_contents: true
 ---
 
-You can use the Soroban CLI to extend the TTL of a contract's persistent storage entry. For a storage entry that uses a simple `Symbol` as its storage key, you can run a command like so:
+You can use the Stellar CLI to extend the TTL of a contract's persistent storage entry. For a storage entry that uses a simple `Symbol` as its storage key, you can run a command like so:
 
 ```bash
 soroban contract extend \
diff --git a/docs/smart-contracts/guides/cli/extend-contract-wasm.mdx b/docs/smart-contracts/guides/cli/extend-contract-wasm.mdx
index 21de9824e..214fbd23b 100644
--- a/docs/smart-contracts/guides/cli/extend-contract-wasm.mdx
+++ b/docs/smart-contracts/guides/cli/extend-contract-wasm.mdx
@@ -3,7 +3,7 @@ title: Extend a deployed contract's Wasm code TTL
 hide_table_of_contents: true
 ---
 
-You can use the Soroban CLI to extend the TTL of a contract's Wasm bytecode. This can be done in two forms: if you do or do not have the compiled contract locally. If you do have the compiled binary on your local machine:
+You can use the Stellar CLI to extend the TTL of a contract's Wasm bytecode. This can be done in two forms: if you do or do not have the compiled contract locally. If you do have the compiled binary on your local machine:
 
 ```bash
 soroban contract extend \
diff --git a/docs/smart-contracts/guides/cli/install-deploy.mdx b/docs/smart-contracts/guides/cli/install-deploy.mdx
index ef172d9a8..b65270485 100644
--- a/docs/smart-contracts/guides/cli/install-deploy.mdx
+++ b/docs/smart-contracts/guides/cli/install-deploy.mdx
@@ -3,7 +3,7 @@ title: Install and Deploy a Smart Contract
 hide_table_of_contents: true
 ---
 
-You can combine the `install` and `deploy` commands of the Soroban CLI to accomplish both tasks:
+You can combine the `install` and `deploy` commands of the Stellar CLI to accomplish both tasks:
 
 ```bash
 soroban contract deploy \
diff --git a/docs/smart-contracts/guides/cli/install-wasm.mdx b/docs/smart-contracts/guides/cli/install-wasm.mdx
index 0dd70935c..119d431ac 100644
--- a/docs/smart-contracts/guides/cli/install-wasm.mdx
+++ b/docs/smart-contracts/guides/cli/install-wasm.mdx
@@ -3,7 +3,7 @@ title: Install Wasm Bytecode
 hide_table_of_contents: true
 ---
 
-To use the Soroban CLI to install a compiled smart contract on the ledger, use the `soroban contract install` command:
+To use the Stellar CLI to install a compiled smart contract on the ledger, use the `soroban contract install` command:
 
 ```bash
 soroban contract install \
diff --git a/docs/smart-contracts/guides/cli/restore-contract-storage.mdx b/docs/smart-contracts/guides/cli/restore-contract-storage.mdx
index 8629c8cf0..b2d84157a 100644
--- a/docs/smart-contracts/guides/cli/restore-contract-storage.mdx
+++ b/docs/smart-contracts/guides/cli/restore-contract-storage.mdx
@@ -1,9 +1,9 @@
 ---
-title: Restore archived contract data using the Soroban CLI
+title: Restore archived contract data using the Stellar CLI
 hide_table_of_contents: true
 ---
 
-If a contract's persistent storage entry has been archived, you can restore it using the Soroban CLI. For a storage entry that uses a simple `Symbol` as its storage key, you can run a command like so:
+If a contract's persistent storage entry has been archived, you can restore it using the Stellar CLI. For a storage entry that uses a simple `Symbol` as its storage key, you can run a command like so:
 
 ```bash
 soroban contract restore \
diff --git a/docs/smart-contracts/guides/conventions/upgrading-contracts.mdx b/docs/smart-contracts/guides/conventions/upgrading-contracts.mdx
index 4a8b0a08d..764bbaea7 100644
--- a/docs/smart-contracts/guides/conventions/upgrading-contracts.mdx
+++ b/docs/smart-contracts/guides/conventions/upgrading-contracts.mdx
@@ -179,7 +179,7 @@ assert_eq!(2, client.version());
 
 ## Build the Contract
 
-To build the contract `.wasm` files, run `soroban contract build` in both `upgradeable_contract/old_contract` and `upgradeable_contract/new_contract` in that order.
+To build the contract `.wasm` files, run `stellar contract build` in both `upgradeable_contract/old_contract` and `upgradeable_contract/new_contract` in that order.
 
 Both `.wasm` files should be found in both contract `target` directories after building both contracts:
 
@@ -193,16 +193,16 @@ target/wasm32-unknown-unknown/release/soroban_upgradeable_contract_new_contract.
 
 ## Run the Contract
 
-If you have [`soroban-cli`] installed, you can invoke contract functions. Deploy the old contract and install the wasm for the new contract.
+If you have [`stellar-cli`] installed, you can invoke contract functions. Deploy the old contract and install the wasm for the new contract.
 
 ```sh
-soroban contract deploy \
+stellar contract deploy \
     --wasm target/wasm32-unknown-unknown/release/soroban_upgradeable_contract_old_contract.wasm \
     --id a
 ```
 
 ```sh
-soroban contract install \
+stellar contract install \
     --wasm target/wasm32-unknown-unknown/release/soroban_upgradeable_contract_new_contract.wasm
 ```
 
@@ -215,8 +215,8 @@ c30c71a382438ed7e56669ba172aa862cc813d093b8d2f45e85b47ba38a89ddc
 You also need to call the `init` method so the `admin` is set. This requires us to setup som identities.
 
 ```sh
-soroban keys generate acc1 && \
-soroban keys address acc1
+stellar keys generate acc1 && \
+stellar keys address acc1
 ```
 
 Example output:
@@ -228,7 +228,7 @@ GAJGHZ44IJXYFNOVRZGBCVKC2V62DB2KHZB7BEMYOWOLFQH4XP2TAM6B
 Now call `init` with this key (make sure to substitute with the key you generated).
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --id a \
     -- \
     init \
@@ -238,7 +238,7 @@ soroban contract invoke \
 Invoke the `version` function.
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --id a \
     -- \
     version
@@ -253,7 +253,7 @@ The following output should occur using the code above.
 Now upgrade the contract. Notice the `--source` must be the identity name matching the address passed to the `init` function.
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --source acc1 \
     --id a \
     -- \
@@ -264,7 +264,7 @@ soroban contract invoke \
 Invoke the `version` function again.
 
 ```sh
-soroban contract invoke \
+stellar contract invoke \
     --id a \
     -- \
     version
@@ -276,4 +276,4 @@ Now that the contract was upgraded, you'll see a new version.
 2
 ```
 
-[`soroban-cli`]: ../../getting-started/setup.mdx#install-the-soroban-cli
+[`stellar-cli`]: ../../getting-started/setup.mdx#install-the-stellar-cli
diff --git a/docs/smart-contracts/guides/dapps/initialization.mdx b/docs/smart-contracts/guides/dapps/initialization.mdx
index c3a90cb89..8381fb969 100644
--- a/docs/smart-contracts/guides/dapps/initialization.mdx
+++ b/docs/smart-contracts/guides/dapps/initialization.mdx
@@ -86,7 +86,7 @@ This command will mint 100 tokens to the designated user's account.
 
 By following these steps, you ensure that the Soroban token smart contracts are correctly deployed and initialized, setting the stage for the Dapp to effectively interact with the token.
 
-For a deeper dive into Soroban CLI commands, check out the [Soroban CLI repo](https://github.com/stellar/soroban-cli/tree/main/cmd/soroban-cli/src/commands).
+For a deeper dive into Stellar CLI commands, check out the [Stellar CLI repo](https://github.com/stellar/stellar-cli/tree/main/cmd/soroban-cli/src/commands).
 
 ## Automating Initialization with Scripts
 
diff --git a/docs/smart-contracts/tokens/stellar-asset-contract.mdx b/docs/smart-contracts/tokens/stellar-asset-contract.mdx
index 7b74735a3..a0034de35 100644
--- a/docs/smart-contracts/tokens/stellar-asset-contract.mdx
+++ b/docs/smart-contracts/tokens/stellar-asset-contract.mdx
@@ -50,14 +50,14 @@ Some functionality available on the Stellar network in transaction operations, s
 
 Every Stellar asset on Stellar has reserved a contract address that the Stellar Asset Contract can be deployed to. Anyone can initiate the deploy and the Stellar asset issuer does not need to be involved.
 
-It can be deployed using the [Soroban-CLI] as shown [here](../guides/cli/deploy-stellar-asset-contract.mdx).
+It can be deployed using the [Stellar CLI] as shown [here](../guides/cli/deploy-stellar-asset-contract.mdx).
 
 Or the [Stellar SDK] can be used as shown [here](../../learn/encyclopedia/contract-development/contract-interactions/stellar-transaction.mdx#xdr-usage) by calling `InvokeHostFunctionOp` with `HOST_FUNCTION_TYPE_CREATE_CONTRACT` and `CONTRACT_ID_FROM_ASSET`. The resulting token will have a deterministic identifier, which will be the sha256 hash of `HashIDPreimage::ENVELOPE_TYPE_CONTRACT_ID_FROM_ASSET` xdr specified [here][contract_id].
 
 Anyone can deploy the instances of Stellar Asset Contract. Note, that the initialization of the Stellar Asset Contracts happens automatically during the deployment. Asset Issuer will have the administrative permissions after the contract has been deployed.
 
 [contract_id]: https://github.com/stellar/stellar-xdr/blob/dc23adf60e095a6ce626b2b09128e58a5eae0cd0/Stellar-transaction.x#L661
-[soroban-cli]: ../../tools/developer-tools.mdx#soroban-cli
+[stellar-cli]: ../../tools/developer-tools.mdx#cli
 
 ## Interacting with classic Stellar assets
 
diff --git a/docs/tools/developer-tools.mdx b/docs/tools/developer-tools.mdx
index 866cc6f37..660960b4e 100644
--- a/docs/tools/developer-tools.mdx
+++ b/docs/tools/developer-tools.mdx
@@ -53,13 +53,13 @@ Ortege is an AI-powered blockchain analytics & insights tool for Stellar, making
 
 ## CLI
 
-### [Soroban CLI](https://github.com/stellar/soroban-cli)
+### [Stellar CLI](https://github.com/stellar/stellar-cli)
 
 The command line interface to Soroban smart contracts. It allows you to build, deploy, and interact with smart contracts; configure identities; generate key pairs; manage networks; and more.
 
-Install Soroban CLI as explained in [Setup](../smart-contracts/getting-started/setup#install-the-soroban-cli).
+Install Stellar CLI as explained in [Setup](../smart-contracts/getting-started/setup#install-the-stellar-cli).
 
-Auto-generated comprehensive reference documentation is available [here](https://github.com/stellar/soroban-cli/blob/main/docs/soroban-cli-full-docs.md).
+Auto-generated comprehensive reference documentation is available [here](https://github.com/stellar/stellar-cli/blob/main/FULL_HELP_DOCS.md).
 
 ## Data Indexers
 
diff --git a/network/soroban-rpc/admin-guide.mdx b/network/soroban-rpc/admin-guide.mdx
index 85712e260..3b9c876a5 100644
--- a/network/soroban-rpc/admin-guide.mdx
+++ b/network/soroban-rpc/admin-guide.mdx
@@ -33,7 +33,7 @@ The Quickstart image with the RPC service can run on a standard laptop with 8GB
 
 :::info
 
-It's also possible to run a contract in the local sandbox environment without a network using just the Soroban CLI. See [Run on Sandbox] for more details.
+It's also possible to run a contract in the local sandbox environment without a network using just the Stellar CLI. See [Run on Sandbox] for more details.
 
 :::
 
@@ -56,7 +56,7 @@ Once the image is started, you can check its status by querying the Horizon API:
 curl "http://localhost:8000"
 ```
 
-You can interact with this local node using the Soroban CLI. First, add it as a configured network:
+You can interact with this local node using the Stellar CLI. First, add it as a configured network:
 
 ```bash
 soroban network add standalone \
@@ -88,7 +88,7 @@ This uses [command expansion](https://www.gnu.org/software/bash/manual/html_node
 
 :::
 
-Now that you have a configured network and a funded identity, you can use these within other Soroban CLI commands. For example, deploying a contract:
+Now that you have a configured network and a funded identity, you can use these within other Stellar CLI commands. For example, deploying a contract:
 
 ```bash
 soroban contract deploy \
@@ -127,7 +127,7 @@ docker run --rm -it \
     --enable-soroban-rpc
 ```
 
-And you'll want to configure it for use with the `--network` flag in Soroban CLI:
+And you'll want to configure it for use with the `--network` flag in Stellar CLI:
 
 ```bash
 soroban network add testnet \
@@ -158,7 +158,7 @@ docker run --rm -it \
     --enable-soroban-rpc
 ```
 
-And you'll want to configure it for use with the `--network` flag in Soroban CLI:
+And you'll want to configure it for use with the `--network` flag in Stellar CLI:
 
 ```bash
 soroban network add futurenet \
@@ -523,7 +523,7 @@ For all deployments, we recommend at least 10GB of disk/storage space.
 
 ## Use the RPC Instance
 
-You can configure Soroban CLI to use a remote RPC endpoint:
+You can configure Stellar CLI to use a remote RPC endpoint:
 
 ```bash
 soroban network add --global testnet \
diff --git a/src/pages/docs/learn/interactive/dapps/challenges/challenge-1-payment.mdx b/src/pages/docs/learn/interactive/dapps/challenges/challenge-1-payment.mdx
index 6f6d5c1a3..8e9f4e8c0 100644
--- a/src/pages/docs/learn/interactive/dapps/challenges/challenge-1-payment.mdx
+++ b/src/pages/docs/learn/interactive/dapps/challenges/challenge-1-payment.mdx
@@ -35,7 +35,7 @@ This challenge will guide you through the process of setting up, customizing, an
 
 Before you begin, ensure you have the following installed on your system. You'll also want to be sure you have the most updated versions of Rust and Soroban installed.
 
-- `soroban-cli`: [Install soroban-cli](/docs/smart-contracts/getting-started/setup#install-the-soroban-cli)
+- `stellar-cli`: [Install stellar-cli](/docs/smart-contracts/getting-started/setup#install-the-stellar-cli)
 - `Node` (>=16.14.0 < 17.0.0): [Download Node](https://nodejs.org/en/download/)
 - `Yarn` (v1.22.5 or newer): [Install Yarn](https://yarnpkg.com/getting-started/install)
 - `Freighter Wallet`: [Freighter Wallet](https://freighter.app/)
diff --git a/src/pages/docs/learn/interactive/dapps/challenges/challenge-3-oracle.mdx b/src/pages/docs/learn/interactive/dapps/challenges/challenge-3-oracle.mdx
index 51f864c6c..4d90d8527 100644
--- a/src/pages/docs/learn/interactive/dapps/challenges/challenge-3-oracle.mdx
+++ b/src/pages/docs/learn/interactive/dapps/challenges/challenge-3-oracle.mdx
@@ -32,7 +32,7 @@ Start by installing the required dependencies.
 
 Required:
 
-- `soroban-cli` 20.0.0-rc.4.1: [Install Soroban CLI](/docs/smart-contracts/getting-started/setup#install-the-soroban-cli)
+- `stellar-cli` 20.0.0-rc.4.1: [Install Stellar CLI](/docs/smart-contracts/getting-started/setup#install-the-stellar-cli)
 - `Node` >=v18: [Download Node](https://nodejs.org/en/download/)
 - `Freighter Wallet`: [Freighter Wallet](https://freighter.app/)