chore: created docs 0.8.x (#1009)

## Description

<!-- Provide a concise and descriptive summary of the changes
implemented in this PR. -->

### Introduces a breaking change?

- [ ] Yes
- [ ] No

### Type of change

- [ ] Bug fix (change which fixes an issue)
- [ ] New feature (change which adds functionality)
- [ ] Documentation update (improves or adds clarity to existing
documentation)
- [ ] Other (chores, tests, code style improvements etc.)

### Tested on

- [ ] iOS
- [ ] Android

### Testing instructions

<!-- Provide step-by-step instructions on how to test your changes.
Include setup details if necessary. -->

### Screenshots

<!-- Add screenshots here, if applicable -->

### Related issues

<!-- Link related issues here using #issue-number -->

### Checklist

- [ ] I have performed a self-review of my code
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have updated the documentation accordingly
- [ ] My changes generate no new warnings

### Additional notes

<!-- Include any additional information, assumptions, or context that
reviewers might need to understand this PR. -->

Author: mkopcins

docs/versioned_docs/version-0.8.x/01-fundamentals/01-getting-started.md

@@ -0,0 +1,138 @@
+---
+title: Getting Started
+slug: /fundamentals/getting-started
+keywords:
+  [
+    react native,
+    react native ai,
+    react native llm,
+    react native qwen,
+    react native llama,
+    react native executorch,
+    executorch,
+    on-device ai,
+    pytorch,
+    mobile ai,
+  ]
+description: 'Get started with React Native ExecuTorch - a framework for running AI models on-device in your React Native applications.'
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+## What is ExecuTorch?
+
+[ExecuTorch](https://executorch.ai) is a novel AI framework developed by Meta, designed to streamline deploying PyTorch models on a variety of devices, including mobile phones and microcontrollers. This framework enables exporting models into standalone binaries, allowing them to run locally without requiring API calls. ExecuTorch achieves state-of-the-art performance through optimizations and delegates such as Core ML and XNNPACK. It provides a seamless export process with robust debugging options, making it easier to resolve issues if they arise.
+
+## React Native ExecuTorch
+
+React Native ExecuTorch is our way of bringing ExecuTorch into the React Native world. Our API is built to be simple, declarative, and efficient. Plus, we’ll provide a set of pre-exported models for common use cases, so you won’t have to worry about handling exports yourself. With just a few lines of JavaScript, you’ll be able to run AI models (even LLMs 👀) right on your device—keeping user data private and saving on cloud costs.
+
+## Compatibility
+
+React Native Executorch supports only the [New React Native architecture](https://reactnative.dev/architecture/landing-page).
+
+If your app still runs on the old architecture, please consider upgrading to the New Architecture.
+
+For supported React Native and Expo versions, see the [Compatibility table](../07-other/01-compatibility.mdx).
+
+## Installation
+
+Installation is pretty straightforward, use your package manager of choice to install the package and some peer dependencies required to streamline model downloads. If you want to implement your custom model fetching logic, see [this document](../08-resource-fetcher/02-custom-adapter.md).
+
+<Tabs>
+  <TabItem value="npm" label="NPM">
+
+    ```
+    npm install react-native-executorch
+    # For Expo projects
+    npm install react-native-executorch-expo-resource-fetcher
+    # For bare React Native projects
+    npm install react-native-executorch-bare-resource-fetcher
+    ```
+
+  </TabItem>
+  <TabItem value="pnpm" label="PNPM">
+
+    ```
+    pnpm install react-native-executorch
+    # For Expo projects
+    pnpm install react-native-executorch-expo-resource-fetcher
+    # For bare React Native projects
+    pnpm install react-native-executorch-bare-resource-fetcher
+
+    ```
+
+  </TabItem>
+  <TabItem value="yarn" label="YARN">
+
+    ```
+    yarn add react-native-executorch
+    # For Expo projects
+    yarn install react-native-executorch-expo-resource-fetcher
+    # For bare React Native projects
+    yarn install react-native-executorch-bare-resource-fetcher
+    ```
+
+  </TabItem>
+</Tabs>
+
+:::warning
+Before using any other API, you must call `initExecutorch` with a resource fetcher adapter at the entry point of your app:
+
+```js
+import { initExecutorch } from 'react-native-executorch';
+import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
+// or BareResourceFetcher for Expo projects
+
+initExecutorch({ resourceFetcher: ExpoResourceFetcher });
+```
+
+Calling any library API without initializing first will throw a `ResourceFetcherAdapterNotInitialized` error.
+:::
+
+Our library offers support for both bare React Native and Expo projects. Please follow the instructions from [Loading models section](./02-loading-models.md) to make sure you setup your project correctly. We encourage you to use Expo project if possible. If you are planning to migrate from bare React Native to Expo project, the link (https://docs.expo.dev/bare/installing-expo-modules/) offers a guidance on setting up Expo Modules in a bare React Native environment.
+
+If you plan on using your models via require() instead of fetching them from a url, you also need to add following lines to your `metro.config.js`:
+
+```json
+// metro.config.js
+...
+    defaultConfig.resolver.assetExts.push('pte')
+    defaultConfig.resolver.assetExts.push('bin')
+...
+```
+
+This allows us to use binaries, such as exported models or tokenizers for LLMs.
+
+:::warning
+When using Expo, please note that you need to use a custom development build of your app, not the standard Expo Go app. This is because we rely on native modules, which Expo Go doesn’t support.
+:::
+
+:::info
+Because we are using ExecuTorch under the hood, you won't be able to build iOS app for release with simulator selected as the target device. Make sure to test release builds on real devices.
+:::
+
+Running the app with the library:
+
+```bash
+yarn <ios | android> -d
+```
+
+## Supporting new models in React Native ExecuTorch
+
+Adding new functionality to the library follows a consistent three-step integration pipeline:
+
+1. **Model Serialization:** We export PyTorch models for specific tasks (e.g., object detection) into the \*.pte format, which is optimized for the ExecuTorch runtime.
+
+2. **Native Implementation:** We develop a C++ execution layer that interfaces with the ExecuTorch runtime to handle inference. This layer also manages model-dependent logic, such as data pre-processing and post-processing.
+
+3. **TS Bindings:** Finally, we implement a TypeScript API that bridges the JavaScript environment to the native C++ logic, providing a clean, typed interface for the end user."
+
+## Good reads
+
+If you want to dive deeper into ExecuTorch or our previous work with the framework, we highly encourage you to check out the following resources:
+
+- [ExecuTorch docs](https://pytorch.org/executorch/stable/index.html)
+- [React Native RAG](https://blog.swmansion.com/introducing-react-native-rag-fbb62efa4991)
+- [Offline Text Recognition on Mobile: How We Brought EasyOCR to React Native ExecuTorch](https://blog.swmansion.com/bringing-easyocr-to-react-native-executorch-2401c09c2d0c)

docs/versioned_docs/version-0.8.x/01-fundamentals/02-loading-models.md

@@ -0,0 +1,94 @@
+---
+title: Loading Models
+---
+
+There are three different methods available for loading model files, depending on their size and location.
+
+## Prerequisites
+
+In our library, you can use two different resource fetching mechanisms. One is implemented using Expo FileSystem, the other one uses external library. We encourage you to use implementation utilizing Expo if possible.
+
+To use the Expo adapter, please add these libraries:
+
+```bash
+yarn add react-native-executorch-expo-resource-fetcher
+yarn add expo-file-system expo-asset
+```
+
+and then add the following code in your React Native app:
+
+```typescript
+import { initExecutorch } from 'react-native-executorch';
+import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
+
+initExecutorch({
+  resourceFetcher: ExpoResourceFetcher,
+});
+```
+
+If you cannot use Expo in your project, proceed with the following steps:
+
+```bash
+yarn add react-native-executorch-bare-resource-fetcher
+yarn add @dr.pogodin/react-native-fs @kesha-antonov/react-native-background-downloader
+```
+
+and
+
+```typescript
+import { initExecutorch } from 'react-native-executorch';
+import { BareResourceFetcher } from '@react-native-executorch/bare-adapter';
+
+initExecutorch({
+  resourceFetcher: BareResourceFetcher,
+});
+```
+
+**1. Load from React Native assets folder (For Files < 512MB)**
+
+```typescript
+useExecutorchModule({
+  modelSource: require('../assets/llama3_2.pte'),
+});
+```
+
+**2. Load from remote URL:**
+
+For files larger than 512MB or when you want to keep size of the app smaller, you can load the model from a remote URL (e.g. HuggingFace).
+
+```typescript
+useExecutorchModule({
+  modelSource: 'https://.../llama3_2.pte',
+});
+```
+
+**3. Load from local file system:**
+
+If you prefer to delegate the process of obtaining and loading model and tokenizer files to the user, you can use the following method:
+
+```typescript
+useExecutorchModule({
+  modelSource: 'file:///var/mobile/.../llama3_2.pte',
+});
+```
+
+:::info
+The downloaded files are stored in documents directory of your application.
+:::
+
+## Predefined Models
+
+Our library offers out-of-the-box support for multiple models. To make things easier, we created aliases for our model exported to `pte` format. For full list of aliases, check out: [API Reference](../06-api-reference/index.md#models---classification)
+
+## Example
+
+The following code snippet demonstrates how to load model and tokenizer files using `useLLM` hook:
+
+```typescript
+import { useLLM } from 'react-native-executorch';
+
+const llama = useLLM({
+  modelSource: 'https://.../llama3_2.pte',
+  tokenizerSource: require('../assets/tokenizer.bin'),
+});
+```

docs/versioned_docs/version-0.8.x/01-fundamentals/03-frequently-asked-questions.md

@@ -0,0 +1,50 @@
+---
+title: Frequently Asked Questions
+---
+
+This section is meant to answer some common community inquiries, especially regarding the ExecuTorch runtime or adding your own models. If you can't see an answer to your question, feel free to open up a [discussion](https://github.com/software-mansion/react-native-executorch/discussions/new/choose).
+
+### What models are supported?
+
+Each hook documentation subpage (useClassification, useLLM, etc.) contains a supported models section, which lists the models that are runnable within the library with close to no setup. For running your custom models, refer to `ExecuTorchModule` or `useExecuTorchModule`.
+
+### How can I run my own AI model?
+
+To run your own model, you need to directly access the underlying [ExecuTorch Module API](https://pytorch.org/executorch/stable/extension-module.html). We provide [React hook](../03-hooks/03-executorch-bindings/useExecutorchModule.md) along with a [TypeScript alternative](../04-typescript-api/03-executorch-bindings/ExecutorchModule.md), which serve as a way to use the aforementioned API without the need of diving into native code. In order to get a model in a format runnable by the runtime, you'll need to get your hands dirty with some ExecuTorch knowledge. For more guides on exporting models, please refer to the [ExecuTorch tutorials](https://pytorch.org/executorch/stable/tutorials/export-to-executorch-tutorial.html). Once you obtain your model in a `.pte` format, you can run it with `useExecuTorchModule` and `ExecuTorchModule`.
+
+### How React Native ExecuTorch works under the hood?
+
+The general workflow for each functionality in our library goes like this:
+
+- You call a functionality from TypeScript
+- TypeScript calls C++ function like model inference or data processing via JSI
+- C++ returns result to TypeScript back via JSI
+- You get results in TypeScript
+
+Using JSI enables us using **zero-copy data transfer** and **fast, low-level C++**.
+
+### Can you do function calling with useLLM?
+
+If your model supports tool calling (i.e. its chat template can process tools) you can use the method explained on the [useLLM page](../03-hooks/01-natural-language-processing/useLLM.md).
+
+If your model doesn't support it, you can still work around it using context. For details, refer to [this comment](https://github.com/software-mansion/react-native-executorch/issues/173#issuecomment-2775082278).
+
+### Can I use React Native ExecuTorch in bare React Native apps?
+
+Yes, staring from version `0.8.x` you can use React Native ExecuTorch in bare React Native apps. You just need to use bare React Native resource fetcher instead of Expo one, see: [Loading models section](./02-loading-models.md) for more details.
+
+### Do you support the old architecture?
+
+The old architecture is not supported and we're currently not planning to add support.
+
+### Can I run GGUF models using the library?
+
+No, as of now ExecuTorch runtime doesn't provide a reliable way to use GGUF models, hence it is not possible.
+
+### Are the models leveraging GPU acceleration?
+
+While it is possible to run some models using Core ML on iOS, which is a backend that utilizes CPU, GPU and ANE, we currently don't have many models exported to Core ML. For Android, the current state of GPU acceleration is pretty limited. As of now, there are attempts of running the models using a Vulkan backend. However the operator support is very limited meaning that the resulting performance is often inferior to XNNPACK. Hence, most of the models use XNNPACK, which is a highly optimized and mature CPU backend that runs on both Android and iOS.
+
+### Does this library support XNNPACK and Core ML?
+
+Yes, all of the backends are linked, therefore the only thing that needs to be done on your end is to export the model with the backend that you're interested in using.

docs/versioned_docs/version-0.8.x/01-fundamentals/04-glossary-of-terms.md

@@ -0,0 +1,59 @@
+# Glossary of Terms
+
+This glossary defines key concepts used throughout the React Native ExecuTorch ecosystem, covering high-level machine learning terms and library-specific components.
+
+## Backend
+
+The execution engine responsible for running the actual computations of a model on specific hardware.
+
+- **XNNPACK:** A highly optimized library for floating-point neural network inference on ARM, x86, and WebAssembly. It is the default CPU backend for ExecuTorch.
+
+- **Core ML:** Apple's framework for optimizing and running machine learning models on iOS, macOS, and iPadOS devices. Using the Core ML backend allows ExecuTorch to delegate operations to the Apple Neural Engine (ANE) for significantly faster and more energy-efficient inference.
+
+## Forward Function
+
+The primary method of a PyTorch module (usually `forward()`) that defines the computation performed at every call. In the context of ExecuTorch, this is the logic that gets exported and compiled. When you run inference in React Native, you are essentially invoking this compiled forward function with new inputs.
+
+## Inference
+
+The process of using a trained machine learning model to make predictions or generate outputs for given input data.
+
+## Out-of-the-Box Support
+
+Refers to features, models, or architectures that work immediately with React Native ExecuTorch without requiring custom compilation, manual kernel registration, or complex configuration. For example, standard Llama architectures have out-of-the-box support, meaning you can download the `.pte` file and run it instantly.
+
+## Prefill
+
+The initial phase of generating text with an LLM (Large Language Model) where the model processes the entire input prompt (context) at once.
+
+- **Why it matters:** This step is computationally intensive because the model must "understand" all provided tokens simultaneously.
+
+- **Performance Metric:** "Time to First Token" (TTFT) usually measures the speed of the prefill phase.
+
+## Quantization
+
+A technique to reduce the size of a model and speed up inference by representing weights and activations with lower-precision data types (e.g., converting 32-bit floating-point numbers to 8-bit integers).
+
+- **Benefits:** Drastically lowers memory usage (RAM) and saves battery life on mobile devices.
+
+- **Trade-off:** Slight reduction in model accuracy, though often negligible for deployment.
+
+## Tensor
+
+The fundamental data structure in PyTorch and ExecuTorch. A tensor is a multi-dimensional array (like a matrix) that holds the inputs, weights, and outputs of a model.
+
+- **Example:** An image might be represented as a tensor of shape `[3, 224, 224]` (3 color channels, 224 pixels high, 224 pixels wide).
+
+## Token
+
+The basic unit of text that an LLM reads and generates. A token can be a word, part of a word, or even a single character.
+
+- **Rule of thumb:** 1,000 tokens is roughly equivalent to 750 words in English.
+
+- **Context:** Models have a "Context Window" limit (e.g., 2048 tokens), which is the maximum number of tokens they can remember from the conversation history.
+
+## Tokenization
+
+The process of converting raw text (strings) into a sequence of numerical IDs (tokens) that the model can understand.
+
+- **TokenizerModule (Component):** In React Native ExecuTorch, the `Tokenizer` is a utility class that handles encoding text into tensors and decoding output tensors back into readable text strings.

docs/versioned_docs/version-0.8.x/01-fundamentals/_category_.json

@@ -0,0 +1,6 @@
+{
+  "label": "Fundamentals",
+  "link": {
+    "type": "generated-index"
+  }
+}

docs/versioned_docs/version-0.8.x/02-benchmarks/_category_.json

@@ -0,0 +1,6 @@
+{
+  "label": "Benchmarks",
+  "link": {
+    "type": "generated-index"
+  }
+}