Refreshed ocre docs with updated steps for building and flashing the ocre runtime, as well as other various QOL improvements.

gonzolively · gonzolively · commit bc55fe8df147 · 2024-12-18T11:15:17.000-07:00
diff --git a/docs/guides/aot.md b/docs/guides/aot.md
@@ -0,0 +1,17 @@
+---
+title: Ahead of Time Compilation (AOT) For Ocre Containers
+layout: default
+parent: Guides 
+nav_order: 0
+
+# Update once guide is done
+nav_exclude: true
+search_exclude: true
+---
+
+May need this for reference:
+
+https://wasmedge.org/docs/start/build-and-run/aot/
+
+{: .important}
+Steps to be updated soon
diff --git a/docs/guides/index.md b/docs/guides/index.md
@@ -2,7 +2,10 @@
 title: Guides
 layout: default
 nav_order: 5 
-has_children: true 
+has_children: true
+
+# Update once pages are added/complete
+has_toc: false 
 ---
 
 # Guides
diff --git a/docs/guides/porting-c-code.md b/docs/guides/porting-c-code.md
@@ -2,5 +2,12 @@
 title: Port an Existing C Application
 layout: default
 parent: Guides 
-nav_order: 0 
----
+nav_order: 0
+
+# Update once guide is done
+nav_exclude: true
+search_exclude: true
+---
+
+{: .important}
+Steps to be updated soon
diff --git a/docs/quickstart/firmware/hardware.md b/docs/quickstart/firmware/hardware.md
@@ -9,7 +9,8 @@ nav_order: 2
 
 This guide covers building and flashing the Ocre runtime onto actual development boards. While simulated environments are great for initial testing, deploying to real hardware allows you to test your applications under authentic conditions and take advantage of board-specific features like sensors and networking capabilities.
 
-Please refer to the board-specific documentation in our [Board Support](../../../board-support) section for detailed setup instructions and requirements for your board before attempting to flash Ocre.
+{: .note}
+Please refer to the "Building and Flashing the Ocre Runtime" section for your board in our in our [Board Support](../../../board-support) section for your boards name, as well as any additional setup instructions should you need them.
 
 ---
 
@@ -74,7 +75,7 @@ west build -b BOARD_NAME ./application -d build -- -DMODULE_EXT_ROOT=`pwd`/appli
 ```
 
 {: .note}
- See the [Board Support](../../../board-support) section in your docs to see if your board is currently supported. If your board is listed, check the "Building and Flashing the Ocre Runtime" section for your `BOARD_NAME` and other relevant info for flashing the Ocre Runtime to your particular device.
+You can also run the **West Build** task directly from the **Ocre Workspace** file as defined in the [Ocre Workspace File](../../../reference/workspacefile) reference. If you do, be sure to select your board as your build target from the dropdown list of available boards. 
 
 ### **7. Flash the Ocre Runtime to Your Device**
 
diff --git a/docs/quickstart/firmware/index.md b/docs/quickstart/firmware/index.md
@@ -3,18 +3,18 @@ title: Building and Flashing the Ocre Runtime
 layout: default
 parent: Quickstart
 nav_order: 1 
-has_children: true 
+has_children: true
+has_toc: false 
 ---
 
 # Building and Flashing the Ocre Runtime
 
-This section will guide you through the process of building the Ocre runtime from source. Whether you're using a simulated environment for testing or deploying to physical hardware, the initial setup and build steps are identical. The paths diverge only at the final stage: simulated devices simply run the runtime directly, while physical devices require an additional flashing step to load the runtime onto the board. 
-
-{: .note}
-To streamline your development workflow, check out our section on [Setting Up Your Development Environment](dev-environment) just before continuing. There, we walk you through using the "Ocre Workspace" file provided in our repository. This VS Code workspace file includes preconfigured `west` build commands for all supported boards, along with debugging utilities and other helpful settings to make building and flashing the Ocre runtime easier.
+Learn how to build and deploy the Ocre runtime on your chosen development environment. The runtime serves as the foundation for running containerized applications on your target device, whether simulated or physical.
 
 ---
 
-## Sample App
+## Getting Started
+Choose your target platform to begin building and testing the Ocre runtime:
 
-To help you get started, we've included a sample application (`./src/main.c`) that demonstrates basic Ocre runtime usage by writing a simple hello world application to flash and directing the runtime to load and execute it.
+> * [Using a Simulated Device](simulated) (Recommended for first-time users)
+> * [Using a Physical Hardware](hardware)
diff --git a/docs/quickstart/firmware/simulated.md b/docs/quickstart/firmware/simulated.md
@@ -83,7 +83,7 @@ west build -b native_sim ./application -d build -- -DMODULE_EXT_ROOT=`pwd`/appli
 ```
 
 {: .note}
-You can also run the **West Build** task directly from the **Ocre Workspace** file as defined in the [Setting Up Your Development Environment](../dev-environment) section. If you do, be sure to select `native_sim` as your build target. 
+You can also run the **West Build** task directly from the **Ocre Workspace** file as defined in the [Ocre Workspace File](../../../reference/workspacefile) reference. If you do, be sure to select `native_sim` as your build target from the dropdown list of available boards. 
 
 ### **7. Run the application**
 
diff --git a/docs/quickstart/first-app/dev-environment/index.md b/docs/quickstart/first-app/dev-environment/index.md
@@ -7,7 +7,7 @@ nav_order: 0
 
 # Setting Up Your Development Environment
 
-The Ocre toolchain for C/C++ is provided as a Docker container image to ensure a consistent development environment for building containerzied applications with Ocre. You can utilize this container in two ways:
+The Ocre toolchain for C/C++ is provided as a Docker container image to ensure a consistent development environment for building containerized applications with Ocre. You can utilize this container in two ways:
 
 1. [Using Visual Studio Code with Dev Containers](#developing-with-visual-studio-code): Provides an integrated development experience with full IDE support and container management.
 
@@ -38,7 +38,7 @@ The dev container can also be run directly in GitHub via [CodeSpaces](https://do
    ```bash
    git clone https://github.com/project-ocre/getting-started.git
    ```
-3. **Open Visual Studio Code**: Launch VSCode on your machine.
+3. **Open Visual Studio Code** 
 4. **Open Folder in Container**:
 - Run the command `Dev Containers: Open Folder in Container...` from the Command Palette (Cmd + Shift + P or Ctrl + Shift + P).
 - Select the folder containing the cloned repository.
diff --git a/docs/quickstart/first-app/first-container/index.md b/docs/quickstart/first-app/first-container/index.md
@@ -3,56 +3,40 @@ title: Building And Deploying Your First Container
 layout: default
 parent: Your First Container
 nav_order: 1
-
-nav_exclude: false 
-search_exclude: true
 ---
 
 # Building and Deploying Your First App
 
-Now that you have set up your development environment, you're ready to build and deploy your first container-based application with Ocre. This guide will walk you through the process of building a sample application from our getting-started repository.
+Now that you have set up your development environment, you're ready to build and deploy your first container-based application with Ocre. 
 
 ---
 
 ## Prerequisites
 
 Before proceeding, ensure you have:
 - Completed the [Setting Up Your Development Environment](../dev-environment) guide
-- Cloned the [`getting-started`](https://github.com/project-ocre/getting-started) repository
 
 ---
 
 ## Building Your First Container
 
-Let's build your first Ocre container using one of our sample applications.
+Let's build your first Ocre container using the "*hello-world*" sample application.
 
-1. **Navigate to the Samples Directory**
+1. **Navigate to *hello-world* sample in the *samples* directory**
   ```
-  cd getting-started/samples
+  cd samples/hello-world
   ```
-2. **Choose a Sample Application:** Browse through the available samples and choose one that interests you. Each sample demonstrates different capabilities of the Ocre platform.
-
-3. **Create and Enter Build Directory:** Once you have jumped into the sample of your choosing, lets create the build directory.
-```
-mkdir build && cd build
-```
-
-4. **Configure the Build**
-```
-cmake -DWASI_SDK_DIR=/opt/wasi-sdk \
-      -DCMAKE_TOOLCHAIN_FILE=/opt/wamr-sdk/app-sdk/wamr_toolchain.cmake ..
-```
-
-5. **Build the Container**
-```
-make
-```
 
-After successful compilation, you'll find a `sample.nbx` file in your build directory (where "sample" matches your chosen sample name). This is your containerized application, ready for deployment.
+2. **Build the WASM Module**
+  ```
+  mkdir build && cd build
+  cmake -DWASI_SDK_DIR=/opt/wasi-sdk -DCMAKE_TOOLCHAIN_FILE=/opt/wamr-sdk/app-sdk/wamr_toolchain.cmake ..
+  make
+  ```
 
-{: .important}
-If the build fails, ensure you're running these commands within the dev container or interactive Docker environment, not on your host system.
+This step results in the creation of a file named `sample_name.wasm`, which will be used by the Ocre CLI to create an Ocre container in the next step.
 
+---
 
 ## Deploying Your First Container
 
diff --git a/docs/reference/ocre-runtime/index.md b/docs/reference/ocre-runtime/index.md
diff --git a/docs/reference/workspacefile.md b/docs/reference/workspacefile.md
@@ -1,25 +1,27 @@
 ---
-title: Setting Up Your Development Environment 
+title: Ocre Workspace File
 layout: default
-parent: Building and Flashing the Ocre Runtime 
-nav_order: 0
+parent: Reference
 ---
 
-# Setting Up Your Development Environment
+# Ocre Workspace File 
 
 This page will guide you through setting up your development environment for the Ocre runtime using our preconfigured VS Code workspace file. The workspace file provides everything you need to build, flash, and debug the runtime with minimal configuration.
 
 ---
 
 ## What is a VS Code Workspace?
 
-A Visual Studio Code workspace allows you to manage multiple folders, settings, and tasks as a single, cohesive environment. Workspaces can save you time by automatically loading recommended settings, extensions, and tasks suited for your project. If you're new to workspaces, we recommend reviewing the [VS Code Workspaces documentation](https://code.visualstudio.com/docs/editor/workspaces) to learn more about their features and usage.
+A Visual Studio Code workspace allows you to manage multiple folders, settings, and tasks as a single, cohesive environment. Workspaces can save you time by automatically loading recommended settings, extensions, and tasks suited for your project.
+
+{: .note}
+If you're new to workspaces, we recommend reviewing the [VS Code Workspaces documentation](https://code.visualstudio.com/docs/editor/workspaces) to learn more about their features and usage.
 
 ---
 
 ## What’s in the "Ocre Workspace" File?
 
-The Ocre runtime workspace file, [**`ocre.code-workspace`**](https://github.com/project-ocre/ocre-runtime/blob/main/ocre.code-workspace), is specifically tailored to help you set up and work with the Ocre runtime efficiently. Located in the root of the repository, this file includes:
+The Ocre runtime workspace file, [**`ocre.code-workspace`**](https://github.com/project-ocre/ocre-runtime/blob/main/ocre.code-workspace), located in the root of the `ocre-runtime` repo, is specifically tailored to help you set up and work with the Ocre runtime efficiently. This file includes:
 
 1. **West Tasks:**
 The workspace file includes a predefined West tasks, which simplifies the process of building and flashing the Ocre runtime. These tasks support several board options, which can be selected directly within VS Code.
@@ -36,6 +38,15 @@ The workspace file also includes debugging profiles specifically for Ocre-compat
 
 This section will guide you through running the essential pre-defined tasks in the Ocre workspace file, including build, flash, and debug operations. These tasks make it easy to quickly set up your development environment for various Ocre-compatible boards without needing to configure each setting manually.
 
+### Loading the Workspace File
+
+1. Navigate to the `application` folder in your `ocre-runtime` project directory.
+2. Locate `ocre.code-workspace`
+3. Double-click the file in your file explorer, then 
+4. Click the blue "Open Workspace" button that appears in the bottom right of your editor.
+
+Once loaded, you'll have access to all preconfigured tasks, debug profiles, and recommended extensions.
+
 ### Running Build and Flash Tasks
 
 The workspace file includes tasks for both building and flashing the Ocre runtime. Follow these instructions to access and run these tasks:
@@ -54,13 +65,4 @@ The workspace also includes debugging profiles configured for Ocre-compatible bo
 2. In the dropdown menu, select the debug profile that matches your target board.
 3. Click "Start Debugging" or press `F5` to begin a session. The debugger will launch with the appropriate settings for your board, streamlining the process for testing and troubleshooting.
 
-With these tasks, you can easily build, flash, and debug the Ocre runtime in a consistent and streamlined manner across different Ocre-compatible devices.
-
----
-
-## Next Steps
-
-With your development environment configured, you're ready to start building the Ocre runtime. Choose your development path below:
-
-- [Build for a Simulated Device](../simulated)
-- [Build for a Physical Device](../hardware)
+With these tasks, you can easily build, flash, and debug the Ocre runtime in a consistent and streamlined manner across different Ocre-compatible devices.
diff --git a/docs/samples/blinky/index.md b/docs/samples/blinky/index.md
@@ -8,37 +8,40 @@ has_children: true
 
 # Blinky Sample
 
-The Blinky sample demonstrates how to build and deploy a simple Ocre container that allows you to interact with device hardware, namely flashing an LED. This is a good introduction to understanding how Ocre containers can perform basic I/O operations.
+Learn how to *build* and *deploy* your first Ocre container using our Blinky sample. This guide demonstrates the fundamental workflow of containerized application development with Ocre.
 
 ---
 
-## Building the Blinky sample
+## Building the Blinky Sample
 
 The following steps will guide you to build the blinky sample.
 
-1. Move into the `blinky` directory (found in `samples`).
+**1.** Move into the `blinky` directory.
 ```
-cd blinky
+cd samples/blinky
 ```
 
-2. Next, build the blinky sample using the following commands:
+**2.** Next, build the blinky sample using the following commands:
 ```
 mkdir build && cd build
 cmake -DWASI_SDK_DIR=/opt/wasi-sdk -DCMAKE_TOOLCHAIN_FILE=/opt/wamr-sdk/app-sdk/wamr_toolchain.cmake ..
 make
 ```
 
-This will create a container image called `blinky.nbx` that we can then deploy to our device.  
+This step results in the creation of a [WASM](https://webassembly.org/) file named `blinky.wasm`, which will be used by the Ocre CLI to create an Ocre container in the next step.
 
-![](BuildBlinky.jpg)
+**3.** Last, lets create an Ocre container using the Ocre CLI. 
 
----
+{: .important}
+Steps to be updated soon
 
-## Deploying the Blinky sample
-The following steps will guide you to deploy the blinky sample to your device.
+___
 
-1. To deploy the blinky sample, simply run the following in your terminal:
-```
-example code
-goes here
-```
+## Deploying the Hello World Sample to Your Device 
+
+Now that you've built your container, let's get it running on your device.
+
+{: .important}
+Steps to be updated soon
+
+---
diff --git a/docs/samples/hello-world/index.md b/docs/samples/hello-world/index.md
@@ -8,36 +8,40 @@ has_children: true
 
 # Hello World Sample
 
-The Hello World sample demonstrates the basic structure of an Ocre container, introducing you to the core components of Ocre's development environment. This page will guide you through the steps to build and deploy the Ocre container, helping you get familiar with Ocre's containerized application process.
+Learn how to *build* and *deploy* your first Ocre container using our Hello World sample. This guide demonstrates the fundamental workflow of containerized application development with Ocre.
 
 ---
 
 ## Building the Hello World Sample
 
 The following steps will guide you to build the Hello World sample.
 
-1. Move into the `hello-world` directory (found in `samples`).
+**1.** Move into the `hello-world` directory.
 ```
-cd hello-world
+cd samples/hello-world
 ```
 
-2. Next, build the hello world sample using the following commands:
+**2.** Next, build the hello world sample using the following commands:
 ```
 mkdir build && cd build
 cmake -DWASI_SDK_DIR=/opt/wasi-sdk -DCMAKE_TOOLCHAIN_FILE=/opt/wamr-sdk/app-sdk/wamr_toolchain.cmake ..
 make
 ```
 
-This will create a container image called `hello-world.nbx` that we can then deploy to our device.  
+This step results in the creation of a [WASM](https://webassembly.org/) file named `hello-world.wasm`, which will be used by the Ocre CLI to create an Ocre container in the next step.
 
-![](BuildHelloWorld.jpg)
+**3.** Last, lets create an Ocre container using the Ocre CLI.
 
----
+{: .important}
+Steps to be updated soon
 
-## Deploying the Hello World Sample
-The following steps will guide you to deploy the hello world sample to your device.
+___
 
-1. To deploy the hello world sample, simply run the following in your terminal:
-```
-example code
-```
+## Deploying the Hello World Sample to Your Device
+
+Now that you've built your container, let's get it running on your device.
+
+{: .important}
+Steps to be updated soon
+
+---
diff --git a/docs/samples/index.md b/docs/samples/index.md
