# Introduction

What is dAppling Network?

Welcome.

## Overview

dAppling is a [web hosting service](https://en.wikipedia.org/wiki/Web_hosting_service) built specifically for Web3 protocols. We provide an easy-to-use, quick interface to create decentralized deployments.

## Mission

Our mission is to provide quick and efficient decentralized web hosting to serve the needs of Web3 protocols. With blockchain technology, decentralized backends have become commonplace, however decentralized frontends are still in their nascency. dAppling is harnessing the power of centralized services with the innovation of [IPFS](https://ipfs.tech/) to provide a simple and easy-to-use hosting service. 

Join us at dAppling, where we don't just help you build your digital garden, we help you plant seeds on the decentralized web that will bloom into a sustainable, vibrant ecosystem. :seedling:

:cactus:*Fun Fact: The oldest known tree in the world is a Bristlecone Pine named Methuselah, estimated to be over 4,800 years old. The exact location of the tree is kept secret to protect it.*


# Projects and Deployments

To get started with dAppling, it's good to know about projects and deployments:

* [Projects](/projects): A project represents the application you've deployed with dAppling. You can have several projects associated with a single repository and multiple deployments for each project. Access all your projects from the dashboard and configure their settings via the project dashboard.
* [Deployments](/deployments): A deployment is the outcome of a successful build for your project. It's initiated when you import an existing project or when you push a Git commit to GitHub. Each deployment automatically generates a unique URL.

:cactus:*Fun Fact: The Titan Arum, also known as the "Corpse Flower," can reach up to 10 feet and emits a smell like rotting flesh to attract pollinators.*[<br>](https://vercel.com/docs/getting-started-with-vercel/projects-deployments#next-steps)


# Import an existing project

Your existing project can be any web project that generates static HTML content, like a website with HTML, CSS, and JavaScript. When you choose one of our [supported frameworks](/legacy-docs/getting-started/frameworks), we'll automatically detect and configure the best build and deployment settings for your chosen framework.

## 1. Connect your Git provider

On the [New Project](https://dappling.network/new) page, click on the Connect Repo button.

Follow the prompts to sign in to your [GitHub](/deployments/git-integrations/dappling-for-github)

## 2. Import your repository

Find the repository in the list that you would like to import and click Select.

## 3. Optionally, configure any settings

dAppling will automatically detect the framework and any required build settings. You can also configure the project settings at this stage, which includes [build and output settings](/builds/configure-a-build) as well as [environment variables](/projects/environment-variables). You can also set these configurations at a later time.

* To update the framework, build command, install command, or output directory edit as needed.
* To set environment variables, expand the Environment Variables section and either paste or copy them in. (coming soon)

## 4. Deploy your project

Click the Deploy button, and dAppling will create the Project and initiate the deployment process according to your selected configurations.

## 5. Share Project

To access your deployment, navigate to the dashboard, choose the Project, and then select the Production Domain. The page is now accessible to anyone with the URL.

:cactus:*Fun Fact: "Guerrilla gardening" is the act of planting flowers and veggies in public spaces to beautify or utilize them.*


# Add a domain

Assigning a custom domain to your project ensures that visitors to your application experience a tailored, brand-aligned experience.

On dAppling, your custom domain can take any format you choose:

* `ethereum.org` (apex domain)
* `blog.ethereum.org` (subdomain)
* `*.ethereum.org` (wildcard domain)

You must already own a domain to use it with dAppling.

For more details on domains with dAppling, check out the [Domains](/domains) overview.

:cactus:*Fun Fact: Worms can eat up to half their body weight in soil and organic matter each day, making them excellent composters.*


# Collaborate

Collaboration plays a crucial role in successful development projects, and dAppling provides powerful features to enhance collaboration among developers. dAppling empowers your team to work together seamlessly.

## Make Changes

Now that your project is publicly available on your chosen domain, it's time to make changes. With dAppling's automatic deployments, this requires no extra effort. By default, when your dAppling project is connected to a Git repository, it will deploy every commit pushed to the repository, regardless of the branch.

Here's a helpful tip:

* A Production environment is built from the main or development branch of your Git repository.
* A Preview environment is created when you deploy from any other branch.
* dAppling provides a URL reflecting the latest commits on that branch, accessible on your dashboard or in a pull request, as you'll see in the next step.

This connection was automatically established for you, so simply push your commits, and you'll start receiving links to deployments right in GitHub.

:cactus:*Fun Fact: There is a species of orchid that looks like a monkey's face, appropriately called the Monkey Face Orchid.*


# Projects

To deploy on dAppling, you need to create a Project, which groups deployments and custom domains.

## Creating a project

1. Navigate to the projects page
2. Click the [New Project](https://dappling.network/new) button

:cactus:*Fun Fact: The world's smallest garden is the "Garden of Eden" micro-sculpture, which fits inside the eye of a needle.*


# Project Dashboard

Learn about the features available for managing projects with the Project Dashboard on dAppling.

Each dAppling project has its dedicated dashboard for configuring settings, viewing deployments, and more.

Here's a high-level overview of the dashboard's functionality, with links to more detailed resources.

## Project Details

The Project Overview tab provides an overview of your production deployment, including its deployments, domains, status, and more.

## Deployments

The project dashboard allows you to manage all your current and previous deployments associated with your project. To handle a deployment, select the project in the dashboard and click on the Deployments tab in the top navigation.

## Domains

Each project has the ability for custom DNS or ENS domains.&#x20;

Lean more in [our Domains docs.](/domains)

## Analytics

Each project has the option to have privacy preserving analytics that collects page views and referral sources.&#x20;

\
Learn more in [our dAppling Analytics docs](/legacy-docs/getting-started/site-analytics).

## Settings

The Settings tab enables you to configure your project. You can modify the project's name, specify its root directory, configure environment variables, and more directly within the dashboard.

Learn more in [our project settings docs.](/legacy-docs/getting-started/configure-project-settings)

:cactus:*Fun Fact: Some plants can "hear" the sound of water and grow their roots towards it.*

<br>


# Environment Variables

Environment Variables are key-value pairs configured outside your source code.

Your source code can read these values to change behavior during the Build Step.

dAppling does not support server side code or functions. This means that we only support environment variables that are consumed by the frontend during the build process. These variables will therefore be **public and unencrypted**. All environment variable values will be visible within the build files and to any user that has access to the [Project](/projects).&#x20;

{% hint style="danger" %}
**To ensure the security of your application, do not add sensitive information, such as API keys or secrets, as environment variables.**&#x20;
{% endhint %}

Changes to Environment Variables are not applied to previous deployments, they only apply to new deployments.

## Declare an Environment Variable

To declare an Environment Variable for your deployment, go to the Environment Variables section of your Project Settings.

Most frameworks have specific requirements for the naming of environment variables. For example Create React App requires frontend env variables to be prefixed with `REACT_APP_.`  If the variables are not named with the correct framework prefix, they will not be embedded during the build process.

### Framework Environment Variable Documentation

* [Create React App](https://create-react-app.dev/docs/adding-custom-environment-variables/)
* [NextJs](https://nextjs.org/docs/app/building-your-application/configuring/environment-variables)
* [Vite](https://vitejs.dev/guide/env-and-mode.html)
* [Vue](https://cli.vuejs.org/guide/mode-and-env.html)

:cactus:*Fun Fact: Apples belong to the rose family, Rosaceae, along with pears and plums.*


# Deployments

A dAppling Deployment is the result of a successful build of your Project.

When you create a deployment, dAppling automatically generates a new and unique URL. You can visit this URL to preview your changes in a live environment.

\
You can deploy your projects to dAppling using [Github](/deployments/git-integrations/dappling-for-github).&#x20;

## Git

The most common way to create a Deployment on dAppling is through pushing code to [Git](/deployments/git-integrations/dappling-for-github)[ ](/deployments/git-integrations)repositories.

Creating an automatic Deployment starts by[ importing a Git repository on dAppling](/deployments/git-integrations). This repository can be either private or public. To set up a Git repository, click the [New Project](https://dappling.network/new) button from the dAppling dashboard.

Deploying your application using dAppling's Git integration provides you with the following benefits:

* Streamlined collaboration through pull requests or merge requests.
* The ability to test new features and changes using Preview Deployments before merging them into the main branch to automatically create a Production Deployment.

For further details, explore our [Deploying a Git repository guide.](/deployments/git-integrations/dappling-for-github)

:cactus:*Fun Fact: The Venus flytrap can close its trap in about 0.1 seconds to capture insects for nutrients.*


# Git Integrations

dAppling allows for automatic deployments on every branch push and merges onto the Production Branch of your GitHub projects.

Utilizing Git with dAppling offers several advantages:

* Preview Deployments for every push.
* Production Deployments for the most recent changes from the Production Branch.
* Instant rollbacks when reverting changes assigned to a custom domain (coming soon).

When working with Git, designate a branch as your production branch, typically named "main." After creating a pull request (PR) to that branch, dAppling generates a unique deployment for previewing any changes. Once you're satisfied with the changes, you can merge your PR into the main branch, and dAppling will create a production deployment.

You also have the flexibility to select a different branch as the Production Branch if needed.

## Supported Git Providers

* [GitHub Free](https://github.com/pricing)
* [GitHub Team](https://github.com/pricing)
* [GitHub Enterprise Cloud](https://docs.github.com/en/get-started/learning-about-github/githubs-products#github-enterprise)
* [GitHub Enterprise Server](https://vercel.com/guides/how-can-i-use-github-actions-with-vercel)

## Deploying a Git Repository

Setting up your GitHub repository on dAppling is a straightforward process. Simply click the [New Project](https://dappling.network/new) button located at the top right of your dashboard and follow these steps:

1. After clicking the button, you'll see a list of Git repositories associated with the Git account you've signed up with, and that you have write access to.
2. To choose a different Git namespace, you can utilize the dropdown list on the top left of the section.
3. Once you've selected the Git repository you wish to use for your new project, you'll be directed to a page where you can configure your project before deployment.
4. Here, you can:
   * Select a [Framework Preset.](/legacy-docs/getting-started/frameworks)
   * Choose the root directory of your project.
   * Configure Build Output Settings.
   * Set [Environment Variables.](/projects/environment-variables)
5. Once you've ensured that your settings are correct, click the Deploy button to initiate the deployment process.

## Production Branch

Each time you merge to the Production Branch, a Production Deployment will be automatically generated.

### Default Configuration

When you create a new Project from a Git repository on dAppling, the Production Branch will be selected as the git repositories default branch.

### Customizing the Production Branch

In the Project Settings on the Git page, you have the flexibility to change your Production Branch. Whenever a new commit is pushed to the branch you configure here, a Production Deployment will be created.

## Preview Branches

Preview Branches encompass all Git branches except the Production Branch mentioned earlier. For instance, if your Production Branch is named `main` then all Git branches that are not `main` are considered Preview Branches. While there can be multiple Preview Branches, there is only a single Production Branch.

Preview Branches, as the name implies, serve the purpose of previewing changes before making them available to your visitors (by merging them into Production). By default, each Preview Branch automatically receives its unique Domain whenever a commit is pushed to it.

Once you're satisfied with your changes, you can proceed to merge the respective Preview Branch into your Production Branch.

:cactus:*Fun Fact: The smell of freshly-cut grass is actually a plant distress call, signaling damage to other plants.*


# dAppling for Github

dAppling for GitHub automates the deployment of your GitHub projects with dAppling. It offers Preview Deployment URLs and automatic updates for Custom Domains.

## Supported Github Products

* [GitHub Free](https://github.com/pricing)
* [GitHub Team](https://github.com/pricing)
* [GitHub Enterprise Cloud](https://docs.github.com/en/get-started/learning-about-github/githubs-products#github-enterprise)
* [GitHub Enterprise Server](https://vercel.com/docs/deployments/git/vercel-for-github#using-github-actions)

## A Deployment for Each Push

dAppling for GitHub will deploy every push by default. This includes pushes and pull requests made to branches. This allows those working within the repository to preview changes made before they are pushed to production.

With each new push, if dAppling is already building a previous commit, the current build will be canceled to build the most recent commit so that you always have the latest changes deployed as quickly as possible.

## Updating the Production Domain

When[ Custom Domains](/domains) are configured through a project's domains dashboard, any pushes or merges to the Production Branch (often named "main") will make the latest deployment from a push live on those domains.

## Preview URLs for the Latest Changes for Each Pull Request

The most recent push to any pull request will be automatically accessible at a unique preview URL. This URL is derived from the project name, branch, and team or username. You can find these URLs conveniently provided through a comment on each pull request.

:cactus:*Fun Fact: The stinging nettle has tiny, hair-like needles that inject histamine and other chemicals when touched, causing that well-known stinging sensation.*


# Builds

Understand how the build step works when creating a dAppling Deployment.

When you create a new project or push a new commit to a project on dAppling, you trigger a deployment. A deployment consists of several steps, with the primary focus on the build step, where dAppling validates and builds your source code, and then stores all assets.

For any of the supported frameworks, dAppling will automatically configure the build settings with the most common configurations for the framework. However, if you have specific settings, you can configure the build, output, and environment variables when you create a new dAppling project or within your project's settings.

## Build Limits

It's important to be aware of certain build limitations on dAppling:

* The maximum duration of a build is 25 minutes. If this limit is reached, the build will be interrupted, and the deployment will fail.
* The build container is allocated a specific amount of resources that can be increased by reaching out to our support.

These limitations are essential to consider when working with dAppling to ensure your deployments run smoothly within the specified constraints.

:cactus:*Fun Fact: Bamboo is the fastest-growing plant; some species can grow up to 35 inches in a single day.*


# Package managers

dAppling will automatically detect the package manager used in your project and install the dependencies during deployment. This detection is based on the lock file present in your project, which allows dAppling to infer the correct package manager to use.

## Supported package managers

Here are the supported package managers along with their install commands and versions

| Package Manger | Lock File           | Install Command | Versions |
| -------------- | ------------------- | --------------- | -------- |
| yarn           | `yarn.lock`         | `yarn install`  | 1        |
| npm            | `package-lock.json` | `npm install`   | 6,7,8    |
| pnpm           | `pnpm-lock.yaml`    | `pnpm install`  | 6,7,8    |
| bun            | `bun.lockb`         | `bun install`   | 1        |

\
While dAppling automatically selects the package manager based on your project's lock file, the specific version of that package manager is determined by the version information in the lock file or associated configuration files.

## Manually specifying a package manager

If you wish to manually specify a package manager for all deployments in your project, you can use the build setting in your project's [Build & Development Settings](/builds/configure-a-build). Follow these steps:

1. Navigate to your dashboard and select your project.
2. Select the Settings tab.
3. Add your desired install command. Once saved, it will be applied in your next deployment.

:cactus:*Fun Fact: The world's most poisonous plant is the castor bean plant; just one bean can kill a human.*


# Configure a Build

When you initiate a deployment on dAppling, the platform builds your project. During this process, dAppling performs a clone on your repository.&#x20;

dAppling automatically configures build settings for various front-end frameworks, but you can also customize these settings to suit your project's requirements. To configure your dAppling build with customized settings, follow these steps:

1. Choose a project from the dashboard.
2. Go to its Settings tab.

## Build and Development Settings

If you want to override settings or specify a different framework, you can do so from the Build & Development Settings section.

### Framework Preset

You have a wide range of frameworks to choose from, including Next.js, Svelte, and Vite. In many cases, dAppling automatically detects your project's framework and sets the best settings for you. You can use the drop-down menu inside the Framework Preset settings to select the framework of your choice. This selection will be applied to all deployments within your project.

* [Next.js](https://nextjs.org/docs)
* [Create React App](https://create-react-app.dev/docs/getting-started/)
* [Vite](https://vitejs.dev/)
* Svelte
* Vue
* 11ty
* No Framework

However, if no framework is detected, "Other" will be selected. In this case, the Override toggle for the Build Command will be enabled by default so that you can enter the build command manually. The remaining deployment process is that for default frameworks.

### Build Command

dAppling automatically configures the Build Command based on the framework. If you want to override the Build Command for all deployments in your project, you can specify a custom command.

### Output Directory

After building a project, most frameworks output the resulting build in a directory. Only the contents of this Output Directory will be served statically by dAppling.&#x20;

If dAppling detects a framework, the output directory will automatically be configured.&#x20;

If you update the Override setting, it will be applied on your next deployment.&#x20;

&#x20;If your project doesn't have a public directory, it will serve the files from the root directory.&#x20;

### Install Command

dAppling automatically detects the install command during the build step. It installs dependencies from package.json

For more details, refer to the documentation on manually specifying a package manager. To find out which package managers are supported on dAppling, consult the [package manager support documentation](/builds/package-managers).

## Root Directory

In some projects, the top-level directory of the repository may not be the root directory of the app you'd like to build. For instance, your repository might contain a front-end directory with a standalone Next.js app. For such scenarios, you can specify the project's Root Directory.&#x20;

:cactus:*Fun Fact: The concept of a "Zen garden" originated in Japan and is meant to imitate the essence of nature, not its actual appearance.*


# Build Logs

When you deploy your website to dAppling, the platform generates build logs that display the deployment progress. These build logs contain information about:

* The version of the build tools used.
* Warnings or errors encountered during the build process.
* Details about the files and dependencies that were installed, compiled, or built during the deployment.

Build logs are an invaluable resource for debugging issues that may arise during deployment. If a deployment encounters problems, these logs can assist you in pinpointing the root cause.

To access the build logs, simply navigate to a deployment and scrroll down to the build logs section.

## How build logs work?

Build logs are generated during the build process for all deployments. These logs closely resemble the output of your framework's Build Command, with some minor additions from the dAppling build system. It's important to note that once a build is complete, no new logs will be recorded.

In addition to the list of build actions, you can identify errors or warnings in the logs. These are highlighted with different colors, such as yellow for warnings and red for errors. This color coding provides flexibility in investigating why your build may have failed and which part of your website is affected. It's worth mentioning that build logs are stored indefinitely for each deployment, ensuring you have access to historical information as needed for debugging and analysis.

:cactus:*Fun Fact: Rhubarb leaves are poisonous due to high levels of oxalic acid, even though the stalks are edible.*


# Troubleshoot a Build

## Troubleshoot Build Failures

If your build encounters an issue, dAppling will report the error message on the Deployments page, allowing you to investigate and address the underlying problem.&#x20;

### Investigating Build logs

Build logs offer insights into what occurred during the deployment build and can be accessed by following these steps:

* From your dAppling dashboard, select the project, and then navigate to the Deployments tab.
* Choose the specific deployment. When there are build issues, you will notice an error status next to the deployment name.

On the deployment's page with an error status, you'll find a summary of the error in the preview section. In the Deployment Details section, expand the Building accordion to access the logs.

Scroll through the build logs until you find a red section with the keyword "Error." This keyword may appear once or multiple times. In many cases, the last mention of "Error" may not provide the most indicative information. Look a few lines above to find additional error messages, which can help pinpoint the problem. Sometimes, errors may not be explicitly mentioned, but the output often contains clues about the issue's location.

### Preventing Build Issues

It is advisable to build your project on your local machine first, using the build command specific to your project. This helps catch issues that are specific to your code or your project's dependencies. For instance, if you encounter an error from `npm run build` locally, you can address it before deploying on dAppling.

### Build Duration

The total build duration is shown on the deployments page.

Please note that a build can last a maximum of 25 minutes. If the build exceeds this time limit, the deployment will be canceled, and the error will be shown in the Deployment's Build logs. If you encounter this limit, reach out to our support.

:cactus:*Fun Fact: A group of orchids is known as a "blue," while a group of cacti is known as a "forest."*


# Domains

dAppling has support for both ENS and DNS domains.

## Introduction to Domains

A domain is like an easy-to-remember address for a website on the internet, such as `dAppling.network`.

### DNS: The Domain Name System

DNS translates human-friendly domain names to computer-readable IP addresses, a process known as DNS resolution.

### The DNS Query Process

Here's how a DNS query unfolds:

1. **User's Request:** Enter a domain like `example.dAppling.network` in your browser.
2. **Recursive Resolver:** If the IP is not cached, the browser queries a recursive resolver.
3. **DNS Server Hierarchy:** The resolver consults a series of DNS servers.
4. **IP Address Retrieval:** The authoritative nameserver provides the IP address.

### DNS Network Hierarchy

DNS is structured hierarchically with root, TLD, and authoritative nameservers.

### Efficiency in DNS Queries

DNS queries are optimized for speed, with caching mechanisms in browsers and resolvers.

### Developer Perspective: Setting Up a Site on dAppling.network

Deploying a project on dAppling.network requires configuring DNS settings to point your domain to the correct IP address.

### Configuring DNS Settings on dAppling.network

Your Dashboard provides guidance on setting various DNS records.

### Key DNS Records and Their Functions

* **CNAME (Canonical Name)**
* **A (Address)**
* **NS (Nameserver)**
* **MX (Mail Exchange)**

### SSL Certificates

SSL Certificates ensure a secure connection from your domain to your website.

***

:cactus:*Fun Fact: Cactus can perform photosynthesis at night, unlike most plants, which only do so during the day.*


# ENS

dAppling has support for both ENS and DNS domains.

## Introduction to Ethereum Name Service (ENS)

ENS is a decentralized domain name system built on the Ethereum blockchain. It allows users to assign human-readable names to cryptocurrency addresses, content hashes, and metadata, much like how traditional DNS works.

### ENS vs Traditional DNS

Unlike DNS, which operates on centralized servers, ENS runs on a decentralized network, offering enhanced security and resistance to censorship.

### The ENS Naming Process

ENS uses `.eth` domains, making web addresses more accessible and memorable. For example, `yourproject.eth` can be an address for your website.

### Setting Up a Website with ENS

To host a website using ENS, you first need to acquire an `.eth` domain. You can purchase one at ENS Domains (<https://ens.domains/>)&#x20;

### Integrating ENS with Your Website

Once you have an ENS domain, you can add it with the dAppling app. We set the contenthash of your ENS name to your website's IPFS hash.

### ENS Resolution Process

When a user enters your `.eth` domain, ENS resolves this into a machine-readable content hash, which then retrieves your website content.

### The Role of Ethereum Smart Contracts in ENS

ENS relies on smart contracts for managing domain registrations and record updates, providing a trustless and automated system.

### Why ENS?

Front-end hacks, as seen in recent incidents with platforms like Balancer, Velodrome, and Frax, reveal the vulnerabilities inherent in the traditional domain name systems (DNS).

#### Benefits of Using ENS for Web Hosting

1. **Enhanced Security Against Social Engineering Attacks**: ENS domains offer a higher level of security against social engineering attacks, which have been used to manipulate service providers into redirecting DNS records to malicious sites. ENS operates on the Ethereum blockchain, making it inherently resistant to such attacks due to its decentralized nature.
2. **Decentralization**: ENS is built on the Ethereum blockchain, which means it's decentralized. This decentralization reduces the risk of a single point of failure, which is a common issue with traditional DNS providers.
3. **Reduced Risk of DNS Hijacking**: Since ENS domains are blockchain-based, they are not susceptible to traditional DNS hijacking methods. The control of an ENS domain is determined by the possession of a corresponding private key, making unauthorized changes to DNS records significantly more challenging.
4. **Ownership and Control**: ENS domains provide users with full ownership and control over their domain. Unlike traditional domain names, where the registrar has ultimate control, ENS domain owners have complete authority over their domain without any intermediary.
5. **Transparent and Immutable Record Keeping**: All changes and transactions made in ENS are recorded on the Ethereum blockchain, ensuring transparency and immutability. This feature aids in tracking and verifying any alterations made to a domain, providing an additional layer of security.

:cactus:*Fun Fact: Scientists have resurrected a plant that woolly mammoths used to eat, called Silene stenophylla, from 32,000-year-old seeds.*


# DNS

dAppling has support for both ENS and DNS domains.

### DNS: The Domain Name System

DNS translates human-friendly domain names to computer-readable IP addresses, a process known as DNS resolution.

### The DNS Query Process

Here's how a DNS query unfolds:

1. **User's Request:** Enter a domain like `example.dAppling.network` in your browser.
2. **Recursive Resolver:** If the IP is not cached, the browser queries a recursive resolver.
3. **DNS Server Hierarchy:** The resolver consults a series of DNS servers.
4. **IP Address Retrieval:** The authoritative nameserver provides the IP address.

### DNS Network Hierarchy

DNS is structured hierarchically with root, TLD, and authoritative nameservers.

### Efficiency in DNS Queries

DNS queries are optimized for speed, with caching mechanisms in browsers and resolvers.

### Developer Perspective: Setting Up a Site on dAppling.network

Deploying a project on dAppling.network requires configuring DNS settings to point your domain to the correct IP address.

### Configuring DNS Settings on dAppling.network

Your Dashboard provides guidance on setting various DNS records.

### Key DNS Records and Their Functions

* **CNAME (Canonical Name)**
* **A (Address)**
* **NS (Nameserver)**
* **MX (Mail Exchange)**

### SSL Certificates

SSL Certificates ensure a secure connection from your domain to your website.

***

:cactus:*Fun Fact: Cactus can perform photosynthesis at night, unlike most plants, which only do so during the day.*


# API

## Overview

dAppling has an external API allowing external applications to access dAppling data.

### API URL

{% embed url="<https://dappling.network/api/v1>" %}

### Endpoints

#### /domains

This endpoint provides access to the nameserver information dAppling has been [tracking](https://dappling.network/monitor).

* [/domains](/api/domains)

The /domain endpoint returns an array of all domain items being tracked by dAppling.

* [/domains/{domain}](/api/domains-domain)

The /domains/{domain} endpoint allows users to query a specific domain to view any nameserver information or changes.

### Authentication

To access dAppling data, you must authenticate each request using an Authorization token in the header. Contact dAppling Network via [Twitter](https://twitter.com/dApplingNetwork) if you are interested in accessing the API.

Each API request must include the Authorization header containing a unique token.

#### Example

```javascript
const myHeaders = new Headers();
myHeaders.append("Authorization", {DAPPLING_AUTH_TOKEN});
```

### Errors

Failure to correctly include the token will result in either a 401 or 403 status code.

:cactus:*Fun Fact: Scientifically speaking, bananas are berries, while strawberries are not. Berries are defined as fruits coming from one flower with one ovary and typically have several seeds.*


# /domains

This GET route fetches domain items for which dAppling is monitoring nameserver changes.

## Request

The request object must be formatted as a GET request. The only required header is for [Authentication](/api#authentication).&#x20;

### Examples

```markup
curl --location 'https://dappling.network/api/v1/domains' \
--header 'Authorization: {DAPPLING_AUTH_TOKEN}'
```

```javascript
const myHeaders = new Headers();
myHeaders.append("Authorization", {DAPPLING_AUTH_TOKEN});

const requestOptions = {
  method: "GET",
  headers: myHeaders
};

fetch("https://dappling.network/api/v1/domains", requestOptions)
  .then((response) => response.json())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));
```

## Response

The /domains endpoint returns a 200 status code with an array of the 25 most recent nameserver changes for each domain dAppling is tracking.

### Structure

* **domain**: domain name of the record
* **Nameservers:** an array that contains objects with details about the nameservers associated with the domain
  * Within each "Nameservers" object:
    * **updatedAt:** the last update time of the nameserver records for the domain
    * **records:** an array of strings, each representing a nameserver record associated with the domain. These are the addresses of the DNS servers that manage the DNS records for the domain.

### Example

```json
[
  {
    "domain": "altbox.one",
    "Nameservers": [
      {
        "updatedAt": "2024-03-10T08:35:52.770Z",
        "records": [
          "ns1.3dns.box.",
          "ns2.3dns.box."
        ]
      }
    ]
  },
  {
    "domain": "ottoinbio.it",
    "Nameservers": [
      {
        "updatedAt": "2024-03-10T02:36:25.403Z",
        "records": [
          "bart.ns.cloudflare.com.",
          "becky.ns.cloudflare.com."
        ]
      }
    ]
  },
  {
    "domain": "dappling.fi",
    "Nameservers": [
      {
        "updatedAt": "2024-03-07T04:21:12.193Z",
        "records": [
          "ns-1325.awsdns-37.org.",
          "ns-1809.awsdns-34.co.uk.",
          "ns-456.awsdns-57.com.",
          "ns-581.awsdns-08.net."
        ]
      }
    ]
  },
  {
    "domain": "basedlabs.wtf",
    "Nameservers": [
      {
        "updatedAt": "2024-03-06T00:48:18.493Z",
        "records": [
          "ns1.3dns.box.",
          "ns2.3dns.box."
        ]
      }
    ]
  },
  {
    "domain": "lookbeforeyou.link",
    "Nameservers": [
      {
        "updatedAt": "2024-03-08T07:35:31.981Z",
        "records": [
          "ns1.vercel-dns.com.",
          "ns2.vercel-dns.com."
        ]
      },
      {
        "updatedAt": "2024-03-05T04:00:00.792Z",
        "records": [
          "ns3.vercel-dns.com.",
          "ns4.vercel-dns.com."
        ]
      }
    ]
  },
  {
    "domain": "holistichospitality.one",
    "Nameservers": [
      {
        "updatedAt": "2024-03-04T20:55:15.570Z",
        "records": [
          "ns1.3dns.box.",
          "ns2.3dns.box."
        ]
      }
    ]
  },
  {
    "domain": "adventourz.com",
    "Nameservers": [
      {
        "updatedAt": "2024-03-06T09:26:09.596Z",
        "records": [
          "ns63.domaincontrol.com.",
          "ns64.domaincontrol.com."
        ]
      },
      {
        "updatedAt": "2024-03-03T10:07:25.207Z",
        "records": [
          "ns23.domaincontrol.com.",
          "ns24.domaincontrol.com."
        ]
      }
    ]
  },
  {
    "domain": "ggpvault.com",
    "Nameservers": [
      {
        "updatedAt": "2024-03-01T03:45:19.955Z",
        "records": [
          "dns1.registrar-servers.com.",
          "dns2.registrar-servers.com."
        ]
      }
    ]
  },
  {
    "domain": "seafi.app",
    "Nameservers": [
      {
        "updatedAt": "2024-03-01T03:45:19.980Z",
        "records": [
          "dns1.registrar-servers.com.",
          "dns2.registrar-servers.com."
        ]
      }
    ]
  }
]
```

:cactus:*Fun Fact: The orange carrot was developed in the 17th century in the Netherlands. Before that, carrots were primarily purple, white, or yellow.*


# /domains/{domain}

This GET route returns nameserver data for a single domain.

## Request

The request object must be formatted as a GET request. The only required header is for [Authentication](/api#authentication).&#x20;

### Parameters

The queried domain must be appended to the end of the url as a full root domain (e.g. <https://dappling.network/api/v1/domains/dappling.fi>).

### Examples

```powershell
curl --location 'https://dappling.network/api/v1/domains/dappling.fi' \
--header 'Authorization: {DAPPLING_AUTH_TOKEN}'
```

```javascript
const myHeaders = new Headers();
myHeaders.append("Authorization", {DAPPLING_AUTH_TOKEN});

const requestOptions = {
  method: "GET",
  headers: myHeaders,
};

fetch("https://dappling.network/api/v1/domains/dappling.fi", requestOptions)
  .then((response) => response.json())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));
```

## Response

The /domains/{domain} endpoint returns a 200 status code with the domain object.

### Structure

* **domain**: domain name of the record
* **Nameservers:** an array that contains objects with details about the nameservers associated with the domain
  * Within each "Nameservers" object:
    * **updatedAt:** the last update time of the nameserver records for the domain
    * **records:** an array of strings, each representing a nameserver record associated with the domain. These are the addresses of the DNS servers that manage the DNS records for the domain.

### Example

```
{
  "domain": "dappling.fi",
  "Nameservers": [
    {
      "updatedAt": "2024-03-07T04:21:12.193Z",
      "records": [
        "ns-1325.awsdns-37.org.",
        "ns-1809.awsdns-34.co.uk.",
        "ns-456.awsdns-57.com.",
        "ns-581.awsdns-08.net."
      ]
    }
  ]
}
```

### Errors

If the dAppling database is not tracking a particular domain, it will return a 404 Not Found error.

:cactus:*Fun Fact: Some species of bamboo can grow up to 91 cm (36 in) within a 24-hour period, making it one of the fastest-growing plants in the world.*


# Errors

## 401

A 401 status code is returned if there is no authentication token included in the request headers.

```typescript
401 'Unauthenticated request. Must authenticate to access API'
```

## 403

A 403 status code is returned if there is a misconfigured authentication token in the request headers.

```typescript
403 'Forbidden request. Request is incorrectly configured for authorization.'
```

## 404

A 404 status code is returned if the requested domain is not currently being tracked within the dAppling database.

```typescript
404 'Not Found'
```

:cactus:*Fun Fact: Caffeine, which naturally occurs in coffee plants, serves as a pesticide to deter herbivores from eating them.*


# FAQs

Find answers to some of the most frequently asked questions

If you have questions that are not answered in the docs, send us a message on [Twitter](https://twitter.com/dApplingNetwork). We answer all DMs.&#x20;

### My site deployed successfully, but when I try to access the deployment URL, I get a 504 error.&#x20;

This can happen for a variety of reasons, including the IPFS node pinning your CID being down or out of service, issues with the IPFS gateway, or a high network latency between the you and the node. This does not mean that your content is lost or inaccessible! One potential solution is to use a different [gateway](https://docs.ipfs.tech/concepts/ipfs-gateway/#gateway-providers). Select a gateway from this [list](https://ipfs.github.io/public-gateway-checker/) and append it to your url.&#x20;

For example, if the url that is timing out is: <https://ipfs.io/ipfs/{CID}>, with Cloudflare, your new url would be: <https://cloudflare-ipfs.com/ipfs/{CID}/>

### What does deploying a site through dAppling cost?

dAppling should be free for most lower traffic use-cases (hackathon projects, portfolio sites, open source apps). Full pricing can be seen at dappling.network

### If decentralized deployments are so great, why does dAppling still use centralized infrastructure?

dAppling fully believes in the future and power of decentralized web hosting. However, the current state of web hosting necessitates our use of centralized services. Decentralized infrastructure is constantly growing, and with the development and growth of dAppling, we hope to further that growth. Once web hosting can subsist entirely on a decentralized infrastructure, dAppling will make that switch.

### I have a question/issue/feedback.

We love questions/feedback! *(not so much issues - although we do love improving our services)*&#x20;

DM us on [Twitter](https://twitter.com/dApplingNetwork). Our goal is to bring you an amazing, easy-to-use product so please let us know if you need help, have a suggestion, or would like to chat :smile:&#x20;

### I don't see the chatbot and I have a problem!

Some plugins, extensions, and browsers interfere with Intercom and its chatbot. If it doesn't render, try using a private/incognito window, a different browser, or turn off extensions. If it still doesn't load, dm us on [Twitter](https://twitter.com/dApplingNetwork).&#x20;

:cactus:*Fun Fact: There are very few black flowers in nature. Most of them are actually very deep shades of purple or red. The Black Dahlia is one of the darkest flowers that exist, although even it is not truly black.*


# Community

:cactus:*Fun Fact: There's a kind of moss known as "Rose of Jericho" that can survive extreme dehydration; it opens up and turns green when exposed to water.*


# Legacy Docs

:cactus:*Fun Fact: Potato plants produce small, green fruits that resemble tomatoes, but they're toxic to humans.*


# Getting Started

:cactus:*Fun Fact: The Eucalyptus tree can absorb up to 13 gallons of water per day, which is why it's often used in areas prone to flooding.*


# Connect dAppling App

#### Connecting your Github App

Get started by clicking the “Deploy in 15s” button or the “Login” at the top.

<figure><img src="/files/ZDUR6FfClC5lauQolZ2p" alt=""><figcaption></figcaption></figure>

You will be presented with a callout to connect your Github Account.

<figure><img src="/files/OkzU9cyUCSHiL3VFBXyq" alt=""><figcaption></figcaption></figure>

We currently support projects on GitHub. Sign up for an account on the [GitHub website](https://github.com/) if you haven’t already. Their login flow is pretty awesome. After you have your shiny new account, or your existing account, you should see the login screen as well as the subsequent authorization screen.

![](/files/yY8HON2UMoxD3YyJksQn)                              ![](/files/5h0LgCD6JXmtTq5dmzgt)

We request permission to complete actions on your behalf like downloading the source code, adding comments to PRs and seeing your email. Shortly after you should be re-directed to our site. If not, head back over to [dappling.network](http://dappling.network). You will be presented with your dashboard!

:cactus:*Fun Fact: Mint is a very hardy plant and if not controlled, can take over a garden. Interestingly, planting mint near entrances and around the house can help deter pests like mice and flies.*


# dAppling Garden

#### Dashboard

Get here by clicking on the logo in the top left any time after logging in.

<figure><img src="/files/4fhQQ6qSsXcNnoGchI7Y" alt=""><figcaption></figcaption></figure>

#### Project

Get here by clicking on a project.

<figure><img src="/files/GWHFoHMSaZSvdNgdFDP3" alt=""><figcaption></figcaption></figure>

#### Deployment

Get here by clicking on a deployment in the “deployments” tab, or clicking on the **latest production deployment “Deployed”** button.

<figure><img src="/files/GhYOpu4xbd8Zzulou2q3" alt=""><figcaption></figcaption></figure>

#### Analytics

Get here by clicking on the "analytics" tab.

<figure><img src="/files/DSU9wtS2iBsNaPbHUx8C" alt=""><figcaption></figcaption></figure>

:cactus:*Fun Fact: Ginkgo trees are living fossils. They have been on Earth for over 200 million years, and are so tough that one even survived the atomic bomb in Hiroshima.*


# Deploy a New Project

#### Creating your first project

On your dashboard, your projects will be empty. After you create a project, this dashboard will show all of the projects that exist. After the first one is added, the main button will disappear, but there is always the “+ New Project” button near your username.

<figure><img src="/files/gPSFjFXpJOLcJBTOmtYr" alt=""><figcaption></figcaption></figure>

On the new project magician, you will first need to connect an account. On subsequent project deployments, all of the repos that you authorize here will be available and will not need to be re-added. After clicking connect account, a pop-up will ask to give permissions. These permissions affect the repositories that you explicitly allow.

<figure><img src="/files/HzVI5RBl07NGEqWECa06" alt=""><figcaption></figcaption></figure>

After you’ve connected your repositories, you will see your accounts in the account dropdown. Select the one with the repo you want to deploy.

<figure><img src="/files/YhrlyJ7pzHBDMdo9dUcX" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/HjiZ0quaTSlCRIsir1e9" alt=""><figcaption></figcaption></figure>

#### Configure your app’s settings

Nice! Now we should be seeing a screen with one of two things.

1. we have not detected your project type. You will see only a framework selector.

<figure><img src="/files/vhWGxexuPurpo9Ll7iWh" alt=""><figcaption></figcaption></figure>

2. we have detected your project! You will see some of the build commands partially filled out

<figure><img src="/files/Q96bkQr9ZiQ3uaQdAZkt" alt=""><figcaption></figcaption></figure>

In either case, you should select and double check the settings for your project. If you need help selecting the settings, there are some informational bubbles next to each for more information.

<figure><img src="/files/nxsh6Nqg1oi2J8v7e39y" alt=""><figcaption></figcaption></figure>

#### Build commands.

The ideal way to figure these out would be letting our app auto-detect the settings. However, we realize that all of the edge-cases cannot be covered so there may be some manual steps you will have to do. We recommend you build your code locally first, see where the resulting files are saved to, and then use that knowledge to fill out the settings. If you can find a built “index.html” file, that’s a good sign.

**Framework:** These are the app types that we support currently. React projects created using [Create React App](https://create-react-app.dev/), [NextJs](https://nextjs.org/), and ones without any framework, for example a static site. There is also an “other” choice that may work for your app-type, but we have not done extensive testing with all types. We would be happy to help work through your project. Just hit the green chat icon in the bottom right!

**How do you install dependencies?** This is the package manager that your project uses. We auto-detect this based on the lock file within the code directory. It’s the command used for your initial installation like `npm i`. Do note, we might not have found your code because it is located in a sub-directory. That would be changed in the **Root Directory**. More on that below.

**How do you export your project?** This is a tricky one. Since your app needs to be deployed as a “static” website, this may be abnormal for your regular dev flow. For NextJs as an example, the export commands you need to run are

* `next build`
* `next export`

You’ll see the recommendation is `npx next build && npx next export` which uses [npx](https://www.npmjs.com/package/npx) to call the necessary next commands within your project’s scope.

**Where are the exported files located?** Similar to the exporting of the project, the export directory might be something new to you as well. When you build your project, the static files will go into a folder within your root directory most likely. These are the files that we will upload to serve the app. For NextJs, the directory is “out” by default, and for CRA, it’s “build”.

**Which branch is your production branch?** finally a straight-forward setting! This should be the branch that has the “live” or “production” code for your app. This will be used for what we call “production deployments” and are pushed out to your configured domains.

**Node Version** is the NodeJS version used in your project. By default, we build projects using version 18 (version 16 for Create React App projects). If your project requires a different version, make sure to select that version or it will not build correctly. If you are unsure what version is required for your project, run `node -v` in your terminal or check the `engines` section of your `package.json` file.&#x20;

**Root Directory** is the place in your GitHub repository where the entrypoint of your code is. That usually means it’s either the place where your “package.json” file is located or the “index.html” file of your static site.

Again, if you need any help, please reach out. We want to improve this process as much as we can!

#### Deploy the project

After that is all configured, go to the next page. If there are red errors, your project will likely not deploy. Yellow warnings will likely deploy, but highlight problems potentially worth looking into.

<figure><img src="/files/Y1Rm6TcZHZ0FxjeB9kLK" alt=""><figcaption></figcaption></figure>

You will be presented with the deployment screen which means that your app is being built. After it is complete the page will refresh showing that the build process is complete.

<figure><img src="/files/ND2SLT9BzYkrhrjlAE6X" alt=""><figcaption></figcaption></figure>

Clicking on “View Logs” will take you to the deployment page where you can view the progress of the actual deployment.

<figure><img src="/files/9hHsxhfzckr1dPe4wZAa" alt=""><figcaption></figcaption></figure>

#### Celebrate?

Shortly after, your first project should be deployed! woo hoo!

<figure><img src="/files/EVwLVzzYiTPiTV9UtLCs" alt=""><figcaption></figcaption></figure>

If this screen doesn’t appear so happy, something must have gone wrong. Again, please reach out as we’re trying to improve our app.

:cactus:*Fun Fact: A single teaspoon of garden soil can hold up to one billion bacteria along with various species of fungi, protozoa, and nematodes. These microorganisms help in nutrient cycling and maintaining soil fertility.*


# Create Deployments

So your app was deployed upon initial creation. We automatically assigned a “production” URL for you which looks something like <https://honeysuckle-aloe-tgsrtj6.dappling.network/>. Each deployment will also create a similar looking “preview” domain.

There are two ways we deploy your app

1. manual deployment
2. automatic deployment through GitHub

### Manual Deployment

If you navigate to the deployments tab of your project, you’ll see two buttons to deploy your app manually. There is a preview and production build option.

<figure><img src="/files/VkH74Mu8bFPqDi3Ofukg" alt=""><figcaption></figcaption></figure>

#### Production

On every “production” deployment, we will take your configured production branch (see the settings tab) and create a build. After the build is complete, we will assign both

* your production URL, which never changes through the life of the project
* your configured domains (see the domains tab)

For example, if you configured a domain at <https://ipfs.example.com>, after a successful production deployment, your users will see the new code at the <https://ipfs.example.com> domain.

#### Preview

For each preview build, we go through the same build process as well as using the production branch, but the production domain as well as the configured domains in the domains tab are not updated. instead, we create a newly generated preview url that looks like <https://chive-lily-zfiuy3b.dappling.network> This preview URL will never be updated again.

<figure><img src="/files/mpAdUja41WgPbaKHXFN5" alt=""><figcaption></figcaption></figure>

#### Project page while deploying

<figure><img src="/files/eGgJHI3frircO0kCIK3P" alt=""><figcaption></figcaption></figure>

#### Deployment page while deploying

<figure><img src="/files/ONsM3WCb4AOMbnrMxAAN" alt=""><figcaption></figcaption></figure>

### GitHub Deployment

Like the manual deployment we have production and preview deployments through GitHub automatically upon PR creation.

#### Production

On any push to “main” including when a PR is merged into main, a production deployment is kicked off. You can see this in the project’s deployments.

<figure><img src="/files/iNnqb8AwaObEVSbCq1jo" alt=""><figcaption></figcaption></figure>

#### Preview

When a PR is created and any subsequent pushes to the PR, a preview build is created. This preview build is visible in your project’s deployments as well. It will notify you that it is building first.

<figure><img src="/files/JdRj0ZXH2ZzxKttfZHyP" alt=""><figcaption></figcaption></figure>

After it’s built, you can view the preview URL right in the PR.

<figure><img src="/files/if9SZjVBYeDocBeH6NfR" alt=""><figcaption></figcaption></figure>

:cactus:*Fun Fact: The world's largest flower, Rafflesia arnoldii, can grow to nearly 3 feet in diameter. Ironically, it has a scent akin to rotting flesh.*


# Configure Project Settings

The “Settings” tab on the project has the configuration that is used upon every deployment.

<figure><img src="/files/KgcuT48JYRAFytTv3Uk9" alt=""><figcaption></figcaption></figure>

There is the **build commands** that modify the way your project is built. If something doesn’t seem right on your app’s output on the site, you may have to modify these settings.

The **build variables** allows you to set the variables that can be accessed during the build process. They are not available during runtime and are **not encrypted. Do not store sensitive information in these variables.** Use build variables to manage your build; they allow you to do things like environment configuration, build optimization, or setting global constants.

The git repository and **“production” branch** is where we download the source code. Make sure your code is pushed and up to date here!

Careful about the **delete project** button it’ll make your project disappear.

:cactus:*Fun Fact: The stinging nettle plant has tiny hairs that inject chemicals, causing a stinging sensation when touched. But when carefully cooked, they are safe to eat and rich in nutrients.*


# Verify a Site CID

Every deployment is “pinned” to the decentralized IPFS service. This means that anyone can access it through a network of nodes that share these pieces of data. Since each website has a unique “hash” of the data within, we can leverage cryptographic signatures letting you “verify” that the code deployed is the code you intended to deploy.

To get started, head over to the deployment page. Each deployment is verified individually as even a small change will completely change the hash.

<figure><img src="/files/LxKxqHVD1cQ0Fj8oH29k" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/Bocp9Pnvly1lD2BKI544" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/IHa264eTxRKo8wfIwTXw" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/g2ESGBPOsIRz2rdFHdP4" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/So25R4LfR2pVVAOJztIM" alt=""><figcaption></figcaption></figure>

If you click on “See Verification” [Signer.is](https://signer.is/verify/JTdCJTIyY2xhaW1lZF9tZXNzYWdlJTIyJTNBJTIyYmFmeWJlaWFwMzRxNXV4d3p0ZGI3ZHRrZWZzM3E1aWpjcG5xM3Zsdnp0cDRrb2hya3BjZ2kyNnV2aWUlMjIlMkMlMjJzaWduZWRfbWVzc2FnZSUyMiUzQSUyMjB4ZmYwM2EwYTMzYmVkOTkwZTJmZDMyZGViN2FmZjNmY2I4OWFmOTJiOTQzYWI3MjA3NTc0M2E5ZjQ3NGFlZDc1ODIwMTYyOGUwNzgxMjdiNjQzYzQwNTdlMWJkNGJjNmQ2ZDFjNGZlMTllMGZlODEyNTBlNDFiYmE3YTkzNDJmZTMxYyUyMiUyQyUyMmNsYWltZWRfc2lnbmF0b3J5JTIyJTNBJTIyMHhjMTNlREE2YkZGNjY5YjM4NTg2NTBiYzM0RGQ4ODAyZUY5M0QzMUU5JTIyJTdE) should open up with the verified signature for your deployment’s CID. this can be shared with people interested in seeing the verified deployment signature.

:cactus:*Fun Fact: In botanical terms, a berry is a fleshy fruit produced from a single ovary. By that definition, bananas, tomatoes, and kiwis are berries while strawberries and raspberries are not.*


# Domain Configuration

To add new domains to your project, and to have your new code pushed to them, head over to the project’s domains tab. By default, there is a domain configured for you under the [dappling.network](http://dappling.network) domain.

<figure><img src="/files/UW89vlhlAF9y29IW6PnY" alt=""><figcaption></figcaption></figure>

#### Adding a custom domain

To add a new domain, put the desired domain. Maybe try with a subdomain of `ipfs`. For example, I would like to add a domain for my site [splitcapta.in](http://splitcapta.in). I would:

1. Enter in [ipfs.splitcapta.in](http://ipfs.splitcapta.in) \*\*\*\*in the domains input
2. Press “Add”
3. Wait for the configuration to load

<figure><img src="/files/mP7E5hj9lnDVFBgG5Ikl" alt=""><figcaption></figcaption></figure>

4. Head over to the domain registrar. For my case, I use Namecheap, but this process would be similar for different registrars. You will have to see how to add these DNS settings on a case-by-case basis. Look at your DNS documentation to figure out how to do it if you’re not using Namecheap.

<figure><img src="/files/It4KaoLjr7HlGF28bRJU" alt=""><figcaption></figcaption></figure>

Here is the resulting DNS settings for Namecheap. Notice the “name” is called “Host” and “Value” is called “Value”.

<figure><img src="/files/ESnOxAHuRhOoUBQt2HZS" alt=""><figcaption></figcaption></figure>

After the records propagate (this might take a while), the domain will report as validated, but again, the code will not exist at the URL until the next production deployment.

<figure><img src="/files/BgSxeueozexv2RSJx21k" alt=""><figcaption></figcaption></figure>

To do this, head over to the deployments tab or push to your “production” branch on GitHub. The new domain should be shown in the project page. See [Create Deployments](/legacy-docs/getting-started/create-deployments) for more information about subsequent deployments.

<figure><img src="/files/Au5f0hD2VoEsHRYLkOke" alt=""><figcaption></figcaption></figure>

After that build succeeds, you can see the code at the configured domain: <https://ipfs.splitcapta.in>

#### Google Domains

The same process as above, but add records:

1. navigate the the DNS section
2. make sure you are on default name servers
   1. if not, you will have to change the DNS records wherever the custom name servers are
3. click “manage custom records”

<figure><img src="/files/iF2QsmMWbFaE3MfSpHfd" alt=""><figcaption></figcaption></figure>

Then, add the two new CNAME records and click “save”

<figure><img src="/files/hfg5Q6iKGQWjOKpFOAL0" alt=""><figcaption></figcaption></figure>

:cactus:*Fun Fact: Plants can communicate with each other through their roots and chemical signals. When a plant is under attack, for example, it releases volatile organic compounds that can warn other plants of the danger.*


# ENS Configuration

We offer two different ways of integrating ENS with your project.

### dappling.eth Subdomain

ENS names can be a useful way of disseminating your site to your users. However, they can be expensive. Because we own the dappling.eth ENS name, we are able to assign every project deployed through dAppling a dappling.eth ENS subdomain.&#x20;

We use [NameStone](https://namestone.xyz/) to set and maintain these subdomains.&#x20;

Whenever a project is deployed, a dappling.eth subdomain is automatically assigned to it. This can be edited or deleted as needed.&#x20;

*Note: dappling.eth ENS subdomains cannot be added to projects. If you want to update the subdomain, choose to edit it, as opposed to deleting and re-adding. If you delete the subdomain you will not be able to add a new one to your project.*

<figure><img src="/files/UjEZO173SZ6IMW2MMVWu" alt=""><figcaption></figcaption></figure>

### ENS Name

To add your own ENS name to your project, navigate to the domains tab and add your ENS name.

1. Type your ENS name in the `Associate ENS Name` card.
2. Press "Add"

<figure><img src="/files/0IfTCwLARjuLafv3OOPl" alt=""><figcaption></figcaption></figure>

3. Connect your wallet.

<figure><img src="/files/TA9GPuGGCd3jPf5pWThz" alt=""><figcaption></figcaption></figure>

4. By selecting "Set Content Hash" you will initiate a transaction to set the hash of the project's IPNS key to the content hash of the ENS.&#x20;

Every time you create a new deployment, a new CID is created. Behind the scenes, we update the IPNS associated with your site to point to the new CID. Therefore, while your production CID will change every time you make a change to your project, your IPNS never does. Because we use the IPNS key (which is mutable) instead of the production CID (which is immutable), you will never have to reset the content hash on your ENS unless you want to move it to a different site. dAppling uses IPNS to make assigning the content hash of your ENS name cheap and easy. Your ENS name will always point to the correct version of your site, without you having to spend gas and time updating the content hash.

<figure><img src="/files/Q95KnC8dHQ1HaaBESBCV" alt=""><figcaption></figcaption></figure>

5. Complete the transaction within your wallet.
6. The ENS domain card will signal the valid ENS configuration once the transaction has successfully been completed.

<figure><img src="/files/Z28CLn67KpK31CWdNONl" alt=""><figcaption></figcaption></figure>

7. :tada::tada: Celebrate!! Your ENS name is now pointing to your production CID. You can now navigate to {ENS name}.eth.limo to view the linked content.

:cactus:*Fun Fact: Studies have shown that plants can actually "hear" running water, and their roots will grow towards the sound.*


# Site Analytics

So you want to know what your users have been up to...

Fortunately, dAppling has an analytics package to make configuring your site analytics quick and easy!

### Install dappling-analytics in your project

Add the [dappling-analytics package](https://github.com/alwaysbegrowing/dapplingAnalytics) as a module within your project's repository. This is a very simple package that tracks page views and unique users across your site.

#### Quickstart

1. Add the `dappling-analytics` package to your project

```bash
npm i dappling-analytics
yarn add dappling-analytics
```

2. Inject the Analytics component into your app by adding it to your project's root (make sure to import it from the react directory). This component injects a script into your app every time a page loads that tracks the page view and user information. The information is sent to and stored in dAppling's database and displayed in the `Analytics` tab of your project.

```
import { Analytics } from 'dappling-analytics/react'
```

3. Re-deploy your app to [dAppling](https://dappling.network) and see your garden growing.

#### Example

If you are using a Next.js project, import and add the `Analytics` component to your root.

```typescriptreact
import "./globals.css";
import type { Metadata } from "next";
import { Inter } from "next/font/google";
import { Analytics } from "dappling-analytics/react";

const inter = Inter({ subsets: ["latin"] });

export const metadata: Metadata = {
  title: "Create Next App",
  description: "Generated by create next app",
};

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang="en">
      <body className={inter.className}>
        {children}
        <Analytics />
      </body>
    </html>
  );
}
```

When you push the changes to your main branch, the dAppling app should trigger a production deployment with your new changes. If a new deployment is not triggered, [**create a production deployment**](/legacy-docs/getting-started/create-deployments) **to deploy the analytics changes**.

Your site is now configured with site analytics and you can watch the views roll in!

#### Analytics Panel

To view your analytics, navigate to the project page on [dAppling.network](https://dappling.network) and select the 'analytics' tab. Here you can view the total number of page views for your entire site, the total number of users, the number of views per page, and your page views over time. Change the time frame for the analytics by using the dropdown menu in the top righthand corner of the page.

<figure><img src="/files/KnDcyRQzrsq04YdgqmPD" alt=""><figcaption></figcaption></figure>

:cactus:*Fun Fact: The Silene stenophylla, a type of campion flower, was grown from a 32,000-year-old seed discovered in Siberian permafrost.*


# Verify Smart Contracts

Coming soon!

:cactus:*Fun Fact while you wait: There are around 5,000 potato varieties worldwide. Three thousand of them are found in the Andes alone, the birthplace of the potato.*


# Frameworks

dAppling supports a wide range of the most popular frontend frameworks, optimizing how your site builds and runs no matter what tool you use.

Deploying on dAppling with one of our supported frameworks gives you access to many of our features, such as:

* Preview deployments
* Automatic CI/CD
* Analytics

## List of supported Frameworks

* [Next.js](https://nextjs.org/docs)
* [Create React App](https://create-react-app.dev/docs/getting-started/)
* [Vite](https://vitejs.dev/)
* Svelte
* Vue
* 11ty
* No Framework

🌵 *Fun Fact: Many traditional cultures believe in planting according to lunar phases, a practice called "moon gardening". Some gardeners still swear by this method today, suggesting it can affect the growth of plants and their ability to absorb nutrients.*


# Learn

:cactus:*Fun Fact: "Espalier" is the practice of training trees or shrubs to grow flat against a wall or fence.*


# Web Hosting

### Overview

Web hosting is a fundamental aspect of the digital world. It allows individuals, companies, and organizations to make their websites accessible on the internet. At dAppling, we strive to make hosting a simple, easy process for Web3 devs.

### Understanding Web Hosting

Web hosting is a service provided by hosting providers that allocates space on a web server for a website to store its files. These servers store the HTML, CSS, JavaScript files, and media content that comprises the website. When users want to access a website, their browsers send a request to the server hosting the site, which then sends the required files back to the browser.&#x20;

dAppling uses Amazon Web Services to store and manage centralized deployments, and Interplanetary File System ([IPFS](/legacy-docs/learn/ipfs)) to store and manage decentralized deployments. This dual-hosting approach ensures&#x20;

### Importance of Web Hosting

The digital age has emphasized the importance of having an online presence. Web hosting services are crucial for maintaining an online presence and making the site accessible to users around the globe.&#x20;

#### Decentralization

With the growth of blockchain technology such as custom blockchains and smart contracts, decentralized backends have become more accessible than ever. However, Web3 frontends rely heavily on centralized web hosting services, meaning services that are provided by a central organization such as Amazon Web Services or Cloudflare. As a protocol's frontend is integral to its presence, development, and community, the lack of decentralized hosting services is a major barrier to full decentralization.

### Benefits of Web Hosting

#### Accessibility and Uptime

One of the primary benefits of web hosting is the ability to make a website accessible 24/7. At dAppling, with our use of both centralized and decentralized hosting infrastructure, we can guarantee a high uptime, meaning your website will remain accessible without interruptions 99% of the time. Even if centralized services go down, the nature of decentralization ensures your website remains accessible.

#### Scalability

As your business or website grows, your web hosting services can grow with it. The nature of decentralization allows for easy scalability - as more nodes are added, websites can be served faster and more efficiently.

#### Technical Support

Using a web hosting service such as dAppling means you do not need to spend time, resources, or effort learning about and implementing decentralized hosting infrastructure. Instead, dAppling provides an easy-to-use, simple UI to guide you through the process of hosting your site. With dAppling, you can deploy your site in less than 2 minutes, start to finish.&#x20;

If you have any questions or need customer support, simply connect with us on [Twitter](https://twitter.com/dApplingNetwork).

### Conclusion

Web hosting is a critical service for anyone looking to establish an online presence. With the ability to keep websites accessible, offer technical support, manage and control data, provide SEO opportunities, and enable scalability, the benefits are clear. dAppling is working to create an easy and simple hosting experience.

:cactus:*Fun Fact: Composting can help reduce landfill waste by up to 30%. Not only is it a great way to recycle organic waste, but it also enriches the soil in your garden, promoting healthier plant growth.*


# Decentralization

### Overview

Decentralization has become a pervasive and transformative principle across various sectors, redefining traditional models of organization and governance. At its core, decentralization involves the dispersion of power, authority, and decision-making processes from a central authority to multiple nodes or individuals. This paradigm shift promotes greater autonomy, resilience, and democratization in systems, whether it be in technology, finance, or even social structures. By distributing control and resources, decentralization mitigates the risks associated with single points of failure and fosters innovation, collaboration, and inclusivity. From blockchain networks and peer-to-peer systems to decentralized finance and governance models, the concept of decentralization continues to gain traction as a catalyst for a more open, transparent, and equitable future.

dAppling focuses specifically on applying decentralization to Web3 frontends. Decentralized frontend deployments are an innovative method of application distribution that involves spreading out data and web resources across multiple nodes, rather than hosting everything in one centralized location.

### Understanding Decentralized Frontend Deployments

Decentralized frontend deployments utilize decentralized networks, such as blockchain networks or peer-to-peer networks, to host and deliver web applications. Unlike traditional centralized models, where all resources are hosted and controlled by a single entity, decentralized deployments distribute resources across multiple nodes or servers.

dAppling uses [IPFS](/legacy-docs/learn/ipfs) which is a peer-to-peer protocol. Simply put, individual computers join the [IPFS](/legacy-docs/learn/ipfs) network and are able to serve content to anyone who requests it. You deploy your website to IPFS using dAppling's infrastructure, and anytime a user requests your website, any computer on the IPFS network can deliver your content to that user.&#x20;

### Importance of Decentralized Frontend Deployments

As Web3 grows and we become more digitally connected, the need for reliable, secure, and high-performing web applications has skyrocketed. The conventional centralized hosting model, while effective to some degree, has several shortcomings, such as single points of failure, potential for censorship, and susceptibility to DDoS attacks.

Decentralized frontend deployments address these issues by ensuring no single entity has total control over the network. This provides higher resilience against attacks and failures, greater privacy and security, and lower latency due to the proximity of resources.

### Benefits of Decentralized Frontend Deployments

#### Increased Reliability and Availability

Decentralized deployments inherently eliminate single points of failure because the application and its data are not stored on one single server, but spread across multiple nodes, or computers. Even if one node fails, others can still serve the application, providing increased availability and reliability.

#### Resistance to Censorship

Because there is no central authority that controls a decentralized network, it is virtually impossible for an entity to manipulate or censor information. This ensures a free and open web where information is democratically distributed.&#x20;

dAppling simply facilitates the decentralized deployment process and therefore does not have any control or authority over the content being deployed.

#### Trustlessness

As no single entity has total control over the network, decentralization deployments are trustless deployments. You do not need to trust dAppling to host and maintain your site. Once it is deployed on IPFS, dAppling cannot move, change, or remove your site; it will remain on IPFS in its deployed form as long as the IPFS network exists.

#### Lower Latency

In a decentralized network, data can be served from the geographically nearest node, reducing the distance that data must travel and consequently reducing latency. This can greatly improve the speed and performance of web applications, especially for users who are geographically distant from the central server in a traditional centralized model.

### Conclusion

The decentralization of frontend deployments represents an evolution of the web development landscape. By distributing resources across multiple nodes, these deployments offer enhanced reliability, improved security, trustlessness, resistance to censorship, and lower latency.

While there are still challenges to be faced in managing and scaling these systems, dAppling is taking advantage of the power of decentralization to provide a quintessentially Web3 hosting experience.

:cactus:*Fun Fact: Regular gardening can burn up to 330 calories an hour, which is more than walking at a moderate pace. It's also been found to decrease the risk of dementia by up to 36% in some studies.*


# IPFS

### Overview

The [InterPlanetary File System (IPFS) ](https://ipfs.tech)is a protocol and network designed to create a content-addressable, peer-to-peer method of storing and sharing data in a distributed file system. Basically, IPFS provides a decentralized infrastructure for distributing content, such as files that comprise websites. dAppling utilizes its decentralized design which presents numerous benefits, making it a valuable tool in Web3 frontend development.&#x20;

### Understanding IPFS

IPFS is a decentralized alternative to the standard [Hypertext Transfer Protocol (HTTP)](https://en.wikipedia.org/wiki/HTTP). Instead of relying on a central location to request and receive data, IPFS operates on a distributed network of nodes that find and deliver data based on its content, not its location. This content-addressability ensures that data isn't tied to a specific location and can be served by any node that holds it.

#### How IPFS Works&#x20;

1. **Content Identifiers (CIDs)**: Every file and all of the blocks within those files are given a unique content identifier (CID). This CID is a cryptographic hash of the content in the file. If any part of the file changes, the CID changes too. This system allows IPFS to track each piece of content and every version of it, providing an inherent version control mechanism. It also provides de-duplication since identical files (with the same CID) won't be stored multiple times.
   * On dAppling, each successful deployment is assigned a CID. You can access this through the project overview page, or on the individual deployment page. The CID you receive on dAppling is the IPFS CID, meaning you can use it to directly access your content through IPFS. However, dAppling also makes accessing IPFS deployments simple by pinning the files and assigning it a stable name using IPNS.
2. **Distributing Content:** When a node looks to access a file, it uses the CID to request the file from the IPFS network. Because files are broken into blocks, the requesting node can fetch different blocks from different nodes. This means that the speed of data retrieval isn't limited by a single server's capacity and can result in faster delivery times.
3. **Data Persistence**: IPFS operates with a model called "unpinning" and "pinning". By default, files retrieved by a node are cached or "pinned" to that node for a short period and then discarded to free up space, a process known as "unpinning". However, if a node wants to ensure the persistence of a file on the network, it can choose to "pin" the file permanently. This allows the node to serve that file to others even if the original provider goes offline.
   * dAppling automatically pins all deployments using filebase for quick, easy access to your content.
4. **Decentralized Naming System**: IPFS also includes a decentralized naming system called IPNS (InterPlanetary Naming System). While CIDs in IPFS are great for content-addressability, they change every time the content changes. If you want to keep a stable name while updating the content, you can use IPNS. With IPNS, you can create a mutable pointer to your content and update it as your content changes.
5. **Transport Protocols**: IPFS isn't tied to a specific method of moving data. Instead, it works on top of other network transport protocols like TCP, UDP, and others. This makes it versatile and adaptable to various network conditions.

### Importance of IPFS

With the ever-increasing volume of data being created, shared, and consumed, the limitations of traditional data storage and transfer methods are being tested. Centralized systems are vulnerable to outages, censorship, and attacks. Additionally, they can create data inefficiencies and redundancies. IPFS is designed to address these issues, allowing for a more robust, efficient, and resilient web.

### Benefits of IPFS

#### Decentralization and Redundancy

With IPFS, files and data are distributed across multiple nodes in the network. This decentralization means there's no single point of failure. If one node goes down, the data can still be accessed from another node. This redundancy enhances the reliability and robustness of data storage and retrieval.

#### Efficiency

IPFS allows nodes to fetch data from the closest or fastest nodes available, not just from a central server. This results in faster data transfer times and less strain on the network. In addition, identical files are stored only once in the network, saving storage space and further increasing efficiency.

#### Permanence and Version Control

Content in IPFS is identified by its hash, which changes with every modification to the file. This makes it possible to track versions of files and datasets over time. Even if the original provider of the file goes offline, the content can still be available from other nodes.

#### Resistance to Censorship

Since there's no central authority in IPFS, it's much harder to censor or control data. Information can't be manipulated or removed by a single entity, preserving the democratic nature of information.

### Conclusion

IPFS represents a significant step forward in the way we handle data on the web. With its decentralized design, it ensures more reliable, efficient, and resilient data storage and transfer. The system's resistance to censorship and support for version control also contributes to a more democratic and open internet. Though there are challenges in implementing and operating within the IPFS network, the potential benefits are substantial and well-suited to Web3 protocols.&#x20;

:sunflower:*Fun Fact: The tallest sunflower ever recorded was over 30 feet (9.17 meters) tall. It was grown by Hans-Peter Schiffer in Germany in 2014.*


# IPNS

### Overview of IPNS (InterPlanetary Naming System)

[IPNS](https://docs.ipfs.tech/concepts/ipns/#mutability-in-ipfs), which stands for InterPlanetary Naming System, is an important part of the IPFS ecosystem. While IPFS provides a way to access files based on their content, IPNS provides a way to access files based on a stable identifier. This makes it easier to manage and reference files that may change over time.

### How IPNS Works

**Mutable Identifiers**

The key feature of IPNS is its ability to provide mutable identifiers, as opposed to the immutable content identifiers (CIDs) that IPFS uses. When content changes, its CID in IPFS changes too, making it a bit inconvenient for frequently updated resources like websites. IPNS solves this by providing a constant name (identifier) for changing content.

**Name Publishing**

An IPNS name is essentially a public-private key pair. The public key is the name, and the owner uses the corresponding private key to sign records, providing proof of ownership. When you want to update the content that your IPNS name points to, you create a new IPFS record, sign it with your private key, and then broadcast that information to the network.

**Time-to-Live (TTL)**

IPNS records come with a Time-to-Live (TTL) feature, meaning they expire after a set amount of time. This ensures that you don't access outdated pointers, and it allows content owners to update their records accordingly.

### Benefits of IPNS

**Dynamic Content**

IPNS is invaluable for serving dynamic content that changes over time. With IPNS, you can keep the same identifier while changing the content it points to.

**Versioning and Redirection**

Since IPNS names can point to different content at different times, they can be used for versioning. You can easily redirect an IPNS name to point to the latest version of your content.

**Decentralization and Security**

Like IPFS, IPNS benefits from being a part of a decentralized system. The use of cryptographic key pairs ensures that only the owner can update the content that an IPNS name points to, adding an extra layer of security.

### Use Cases

**Decentralized Websites**

Decentralized applications (dApps) and websites can use IPNS to maintain stable URLs while their content changes.

dAppling uses IPNS to make assigning the content hash of your ENS name cheap and easy. By setting your ENS name's content hash to be the IPNS key as opposed to the CID, and updating the IPNS name to point to your most recent production CID on each deployment, your ENS name will always point to the correct version of your site, without you having to spend gas and time updating the content hash.

#### Conclusion

IPNS provides a critical layer of functionality atop IPFS, enabling mutable pointers to immutable content. It offers the best of both worlds, combining the permanence and integrity of CIDs with the flexibility of mutable identifiers.

:cactus:*Fun Fact: The idea of "square foot gardening" was popularized by Mel Bartholomew in the 1970s. It's a way to grow more in less space.*


# Access Points

For protocols to develop and thrive, their content must be generally accessible. Since IPFS does not use the HTTP standard, dAppling is particularly concerned about providing easy, diverse access points for our users.&#x20;

dAppling offers two main access points:

1. [Domain Name System](/legacy-docs/learn/access-points/domain-name-system)
2. [Ethereum Name Service](/legacy-docs/learn/access-points/ethereum-name-service)

:cactus:*Fun Fact: The world's smallest flowering plant is the Wolffia, also known as the watermeal. These tiny flowers are just 0.3mm long and are often mistaken for dust on the surface of the water.*


# Domain Name System

### Domain Management

Domain management is one method of creating an access point. It involves the process of managing and maintaining domain names and their related services. dAppling offers traditional domain management from within our UI to make domains and deployments easy and quick to manage.

#### Understanding Domain Management

Domain management refers to the administration of one or more domain names used by individuals or organizations for their websites. It includes registering new domain names, renewing existing ones, transferring domains between registrars, managing DNS settings, and more. In essence, domain management ensures that a domain name correctly leads users to the desired website and that all associated services function properly.

#### Importance of Domain Management

Domain names serve as your address on the internet. Since IPFS uses complicated CIDs to track content, creating and maintaining a domain is vital to ensuring your presence remains consistent and accessible. Poor domain management can lead to missed renewals, unintended service interruptions, or security vulnerabilities, all of which can negatively impact your online presence.

#### Key Aspects of Domain Management

**Domain Registration**

This is the process of purchasing and registering a domain name from a domain registrar. The domain name is leased for a certain period (usually one year), after which it must be renewed.

#### Domain Renewal

Domains must be renewed periodically to ensure continued ownership. Failing to renew a domain on time can result in the domain becoming available for others to purchase. Automatic renewal settings can be used to avoid accidental expiry.

#### Domain Transfers

If you decide to change your domain registrar, you'll need to initiate a domain transfer. This process can involve unlocking the domain, obtaining a transfer code, and coordinating between the old and new registrars.

#### DNS Management

DNS (Domain Name System) management involves configuring your domain to point to the right web server. This usually includes setting up A records, CNAME records, MX records for email, and potentially other DNS settings. dAppling allows users to setup CNAME records to create and manage subdomains.&#x20;

#### Domain Security

This involves implementing measures to protect your domain from potential threats. This may include enabling domain locking to prevent unauthorized transfers, implementing DNSSEC for secure DNS responses, and utilizing WHOIS privacy to protect your personal information displayed in the public WHOIS database.

### Conclusion

Accessibility is a cornerstone of developing and thriving protocols, especially when deviating from the conventional HTTP standard, such as with IPFS. This places a significant emphasis on creating easy and efficient access points for users. Within these access points, domain management is a key component, responsible for crucial tasks like domain registration, renewal, transfers, DNS management, and security. With proper domain management, we ensure that the content remains reachable and secure. dAppling remains steadfast in offering these access points, making the shift from conventional protocols to IPFS smoother and more manageable.

:cactus:*Fun Fact: The Square Foot method of gardening allows you to grow more in less space by using a grid system. One square foot garden can potentially produce the same yield as a traditional garden five times its size.*


# Ethereum Name Service

### Ethereum Name Service (ENS) Integration

In addition to traditional domain management features, dAppling supports integration with [Ethereum Name Service (ENS)](https://docs.ens.domains/), a critical service for those working in the decentralized web space. ENS offers human-readable addresses in place of long, complex Ethereum addresses or IPFS CIDs.

**Understanding ENS in Domain Management**

ENS functions like a decentralized DNS, built on top of the Ethereum blockchain. Instead of relying on centralized domain registrars, you can register `.eth` domains that are fully under your control as long as you hold the corresponding Ethereum private keys. This functionality brings another layer of decentralization and control to domain management.

**Importance of ENS in a Decentralized Environment**

For platforms like dAppling that operate on IPFS and prioritize decentralized protocols, ENS serves as a bridge between the traditional web and the decentralized web. It simplifies user access points by allowing for human-readable domain names, making it easier for users to interact with dApps or access content stored on IPFS.

**Key Features of ENS in Domain Management**

1. **ENS Registration**: Just like you'd register a `.com` or `.org` domain, you can register a `.eth` domain via Ethereum transactions.
2. **ENS Renewal**: ENS domains also have a renewal cycle, usually paid in ETH or any supported ERC-20 token.
3. **ENS Resolvers**: These are smart contracts that resolve ENS names to various resources, such as Ethereum addresses or IPFS CIDs.
4. **ENS and Subdomains**: You can also create subdomains under your main `.eth` domain. This can be incredibly useful for categorizing content or dApps.
5. **Interoperability**: One of the most powerful features is the ability to link ENS domains to traditional DNS domains, offering seamless interaction between the centralized and decentralized webs.

**ENS and Domain Security**

ENS domains come with blockchain-level security, meaning the security of your domain is as robust as the Ethereum network itself. You can also add extra layers of protection like setting up admin and resolver roles for enhanced control.

#### Conclusion

Domain management is crucial for creating easy-to-access points in both the traditional and decentralized web. dAppling takes it a notch higher by offering not just classic domain management features but also seamless ENS integration. With this approach, transitioning from conventional protocols like HTTP to decentralized ones like IPFS becomes more fluid and user-friendly.

:cactus:*Fun Fact: Plants can see! kind of... They have photoreceptors like "phytochrome" that detect light colors, helping them decide when to flower or grow taller.*