The best websites in the world tend to follow a similar pattern; they use 3D animations that bring the content to life when a page is scrolled. In this tutorial, we’ll build a simple 3D portfolio using Vite, React, Three.js and Strapi.

A portfolio is a collection of samples of your works. Your portfolio website is likely to be the first place someone goes after reading your CV. So, it’s vital to make a great first impression.

What is Strapi?

Strapi is an open-source Content Management System. It enables the creation of customizable APIs in any frontend application. Strapi is so simple to use because it allows you to create flexible APIs with unique features that you'll love.

To keep things organized, you can create custom content types and relationships between them. It also includes a media library where you can store your images and audio files. We’ll be using Strapi for the content that we’ll be using in our portfolio.

What is Vite?

Vite is a modern, lightning-fast tool for scaffolding and project-bundling. It is quickly gaining traction due to its near-instant code compilation and rapid hot module replacement. It is a JavaScript development server that greatly enhances the frontend development experience. As a result, we can call it a development tool.

It converts your code into something that your browser can understand. Vite allows you to run a development server. It also handles and updates your files based on changes. This process is completed quickly in order to reflect your changes on the browser.

Other features of Vite include:

• Bare module resolving,
• Hot module replacement (HMR),
• On-demand compilation, and
• Advance configuration.

Vite is the next generation front-end tool to build apps faster. It’s why I decided to use it instead of the traditional CRA (create react app).

What is Three.js?

Three.js is a JavaScript framework that allows you to quickly build a 3D or 2D graphic on your web page. With Three.js, we don’t have to use WebGL directly. It’s an abstract layer built on WebGL to make it easier to use. Anyone can use a web browser to view 3D graphics without downloading any extra framework.

Since Three.js is built on JavaScript, adding interactivity between 3D objects and user interfaces is quite simple. This makes Three.js ideal for creating 3D games on the web platform. It also offers exceptional features such as effects, scenes, cameras, etc.

Prerequisites

To follow through this article, you’ll need:

• A basic knowledge of JavaScript and React,
• Node.js installed (v14), and

• Npm or yarn installed (v6 of npm is more suited to install strapi).

  Note: If you have issues while installing strapi, I'll suggest clearing npm cache completely and downgrade to node 14 by uninstalling the higher version of node completely from your system and also anywhere node might appear). Accept the additional installation (the python scripts etc.) this worked for me.

Creating Our Content: Setting up Strapi

To install and create our content in Strapi, we’ll need to install Strapi. Create a folder called strapi-portfolio, cd into it, and run either of the following commands below:

       npx create-strapi-app@latest my-project --quickstart
#or
    yarn create strapi-app my-project --quickstart

This will install all the packages needed for this project. After the installation, our Strapi app will automatically be launched in our browser. We should have something like this:

Following registration, we will be directed to the admin homepage to configure our backend content and APIs.

Create a Collection

Let us begin by creating an Estate collection type. Click Content-Type Builder on your admin homepage, then create a new collection type. Give it a display name, and make sure it's singular, not plural. Strapi automatically pluralizes it. We will call our collection portfolio.

For our portfolio, we’ll need a name in form of text type, about me in form of rich text type, project in form of text type, and project description in form of rich text type.

Let’s go ahead and create them.

Click on Save to save our collection and publish to publish it. Let’s move on to populate our collection:

Populate the Collection

At the top-left corner of the admin page, select Content Manager. This will navigate you to the page where we will add contents to our database.

For this tutorial, I'll be working with dummy texts. Once we are done, we can either save and test it first or we skip that and go ahead to publish it.

Make the portfolio available to consume it in our React frontend. Navigate to Roles under Users and Permissions Plugins. and click on the public. Then, scroll down to permissions.

Under the Portfolio dropdown, select the find and findOne options by clicking on Public. This will make the portfolio content available to the general public.

So, if we try to retrieve it by using the Strapi API, it sends us the data. Now that we’re done, let’s move on to the frontend.

Creating the Frontend

As previously stated, React would serve as our frontend. So, let's get started by installing React and all the necessary packages.

• Open up our terminal once more and navigate the folder where we want to install react.

    npx create-react-app 3d-portfolio

• cd into the just installed folder:

        cd 3d-portfolio

• Next, install axios

     npm install axios

• Lastly, let’s install three.js:

    npm install three

Now that we are done, let’s start our react app:

     npm start

Project Scope

For this project, we’ll use three.js to create our background and axios to fetch our api. We'll give some styling to our portfolio and we are done! As a lover of space, this project will be built with an aspiration matching outer space. You can get some of the images used here.

NOTE: This is just for tutorial purpose.

Creating the Background with Three.js

Navigate to app.jsx in our src folder and edit it to this:

1
2
3
4
5
6
7
8
9
10
11
    import { useState } from 'react'
    import './App.css'
    function App() {
      const [count, setCount] = useState(0)
      return (
        <div className="App">
          <canvas id="bg"></canvas>
        </div>
      )
    }
    export default App

Here, we just displayed a canvas. This is all we need for a three.js scene. I’ll give an explanation on what scenes are as we’re building.

Let’s head over to index.css to give the canvas fixed positioning and also pin it to the top left corner of the screen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    * {
        margin: 0;
        padding: 0;
    }
    body {
        color: #fff;
        font-family: Arial, Helvetica, sans-serif;
    }
    canvas {
        position: fixed;
        top: 0;
        left: 0;
        z-index: -1;
    }

This will serve as a background for our portfolio. Now, we’ll go back to our app.jsx file and import our Three.js library and also useEffect from react:

1
2
3
    import { useSEffect } from 'react';
    import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
    import * as THREE from "three";

Our three.js codes will be written inside a ueEffect function. Let’s create that inside our function app():

1
2
3
      useEffect(() => {
    
     }, []);

There are some things we need when working with Three.js for 3D development. These are some examples:

• Scene - a scene is a container of layers. It also holds our objects, cameras, and lights.
• Camera - allows the perception of the object to replicate three dimensions.
• Renderer - used to render the actual graphic to the scene.

Let’s paste this code block inside our useEffect function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
     const scene = new THREE.Scene();
        const camera = new THREE.PerspectiveCamera(
          75,
          window.innerWidth / window.innerHeight,
          0.1,
          1000
        );
        const renderer = new THREE.WebGLRenderer({
          canvas: document.querySelector("#bg"),
        });
        renderer.setPixelRatio(window.devicePixelRatio);
        renderer.setSize(window.innerWidth, window.innerHeight);
        camera.position.setZ(30);
        renderer.render(scene, camera);

We created a scene and a perspective camera. The perspectiveCamera behaves similar to how the human eyeballs do. We also initailized a renderer. The renderer is going to take in the canvas element and also some other configurations. Let’s paste this right after our renderer.render

1
2
3
4
5
6
7
8
9
10
11
12
     const geometry = new THREE.TorusGeometry(10, 3, 16, 100);
        const material = new THREE.MeshStandardMaterial({ color: 0xff6347 });
        const torus = new THREE.Mesh(geometry, material);
        scene.add(torus);
        const pointLight = new THREE.PointLight(0xffffff);
        pointLight.position.set(5, 5, 5);
        const ambientLight = new THREE.AmbientLight(0xffffff);
        scene.add(pointLight, ambientLight);
        const lightHelper = new THREE.PointLightHelper(pointLight);
        const gridHelper = new THREE.GridHelper(200, 50);
        scene.add(lightHelper, gridHelper);
        const controls = new OrbitControls(camera, renderer.domElement);

We created geometry, material, and torus. A geometry is a set of vectors that define the object itself. For example, in Three.js, there are a bunch of geometry such as cylinder, cone, box, etc.

We are also instantiating a new pointLight with a colour of white, setting its values, and adding it to our scene. We also instantiated an ambient light. It will give lightening to the entire scene equally.

We also added a ightHelper and a gridHelper. A lightHelper is used to show the position of a pointLight, while the gridHelper draws a two-dimensional grid.

Lastly, for our background, let’s paste this :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
      function addStar() {
          const geometry = new THREE.SphereGeometry(0.25);
          const material = new THREE.MeshStandardMaterial({ color: 0xffffff });
          const star = new THREE.Mesh(geometry, material);
          const [x, y, z] = Array(3)
            .fill()
            .map(() => THREE.MathUtils.randFloatSpread(100));
          star.position.set(x, y, z);
          scene.add(star);
        }
        Array(250).fill().forEach(addStar);
        const spaceTexture = new THREE.TextureLoader().load("your image");
        scene.background = spaceTexture;
        const avatarTexture = new THREE.TextureLoader().load(
          "your image"
        );
        const avatar = new THREE.Mesh(
          new THREE.BoxGeometry(3, 3, 3),
          new THREE.MeshBasicMaterial({ map: avatarTexture })
        );
        scene.add(avatar);
        const planetTexture = new THREE.TextureLoader().load(
          "your image"
        );
        const planet = new THREE.Mesh(
          new THREE.SphereGeometry(3, 32, 32),
          new THREE.MeshStandardMaterial({ map: planetTexture })
        );
        scene.add(planet);
        planet.position.z = 30;
        planet.position.setX(-10);
        function moveCamera() {
          const t = document.body.getBoundingClientRect().top;
          planet.rotation.x += 0.05;
          planet.rotation.y += 0.075;
          planet.rotation.z += 0.05;
          avatar.rotation.y += 0.01;
          avatar.rotation.z += 0.01;
          camera.position.z = t * -0.01;
          camera.position.x = t * -0.0002;
          camera.rotation.y = t * -0.0002;
        }
        document.body.onscroll = moveCamera;
        function animate() {
          requestAnimationFrame(animate);
          torus.rotation.x += 0.01;
          torus.rotation.y += 0.005;
          torus.rotation.y += 0.01;
          controls.update();
          renderer.render(scene, camera);
        }
        animate();

What we did here is:

• Generated many objects for our scene using the math helpers in Three.js to do that.
• Added a simple image background to it. We’ll be using Three.js textureLoader.
• Added our background image, an avatar (image of you).

These are all the configurations that we need for our portfolio.

Fetching our Content

Inside our src folder, let's create a folder called component. Inside this folder, create a file called index.jsx and paste this:

1
2
3
    import axios from "axios";
    const url = "http://localhost:1337/api/portfolios";
    export const readPortfolios = () => axios.get(url);

Here, we are:

• Importing Axios to our app.
• The path to our API.

Axios will be responsible for fetching data from our API and also adding to it. We then go back to our app.jsx and import the just created API folder containing the index.jsx to our app:

1
2
3
4
5
6
7
8
9
10
    import * as component from "./component";

    const [portfolios, setPortfolios] = useState([]);
      useEffect(() => {
        const fetchData = async () => {
          const result = await component.readPortfolios();
          setPortfolios(result.data.data);
          console.log(result.data);
        };
        fetchData();

Almost done! We just need to do two things. First, we need to map and display our contents. we’ll do this by creating writng basic html and calling out our contents in there. Paste this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
     <h1>Hello world</h1>
          {portfolios.length > 0 ? (
            portfolios.map((portfolio, i) => (
              <div className="title" key={i}>
                <div className="portfolio">
                  <h1 className="title"> {portfolio.attributes.myname}</h1>
                  <p className="text">
                    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
                    eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
                    enim ad minim veniam, quis nostrud exercitation ullamco laboris
                    nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor
                    in reprehenderit in voluptate velit esse cillum dolore eu fugiat
                    nulla pariatur. Excepteur sint occaecat cupidatat non proident,
                    sunt in culpa qui officia deserunt mollit anim id est laborum.
                  </p>
                 
                </div>
                <div className="projects">
                  <h1>Projects</h1>
                  <div className="projects-table">
                    <div className="projects-card">
                      <p className="title">Porject1</p>
                      <p className="info">
                        {portfolio.attributes.projectdescription}
                      </p>
                      <button className="btn">check it out here</button>
                    </div>
                    <div className="projects-card">
                      <p className="title">project2</p>
                      <p className="info">
                        {portfolio.attributes.projectdescription}
                      </p>
                      <button className="btn">check it out here</button>
                    </div>
                    <div className="projects-card">
                      <p className="title">project3</p>
                      <p className="info">
                        {portfolio.attributes.projectdescription}
                      </p>
                      <button className="btn">check it out here</button>
                    </div>
                  </div>
                </div>
              </div>
            ))
          ) : (
            <h2></h2>
          )}

Lastly, let’s add some basic styling to it. Go back to index.css and add this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
    .portfolio {
        padding: 4em 3em;
        width: calc(50% - 2em);
    }
    .portfolio .title {
        color: orange;
        font-size: 3em;
        margin-bottom: .5em;
    }
    .portfolio.text {
        letter-spacing: 1px;
        line-height: 1.5;
        color: rgb(226, 208, 208);
        margin-bottom: 1em;
    }
    .btn {
        background: rgb(194, 189, 181);
        color: #fff;
        padding: .5em 1em;
        border-radius: 3px;
        text-decoration: none;
        font-size: 1em;
        margin-top: 1em;
        border: none;
        margin-right: .5em;
        text-transform: uppercase;
        font-weight: bold;
        letter-spacing: 1px;
    }
    .projects h1 {
        text-align: center;
        font-size: 2.5em;
    }
    .projects-table {
        padding: 3em;
        display: flex;
        flex-direction: row;
    }
    .projects-card {
        background-color: rgba(255, 255, 255, .3);
        padding: 1em;
        border-radius: 5px;
        transform: translate(-100px, 100px);
        opacity: 0;
        animation: 1s slideIn;
        animation-delay: 2s;
        animation-fill-mode: forwards;
    }
    @keyframes slideIn {
        to {
            transform: translate(0, 0);
            opacity: 1;
        }
    }
    .projects-card:nth-child(2) {
        margin: 0 2.5em;
        transform: translate(0, 100px);
        animation-delay: 2.2s;
    }
    .projects-card:nth-child(3) {
        transform: translate(100px, 100px);
        animation-delay: 2.4s;
    }
    .projects-card .title {
        font-size: 1.5em;
        color: #fff;
        font-weight: bold;
    }
    .projects-card .info {
        margin: 1em 0;
    }
    .projects-card .btn {
        background: orange;
    }

Check the result in your browser. We have our portfolio running! Here is the link to the code on my Github.

Conclusion

We talked about Vite and Three.js. We also learnt how to create a simple 3D portfolio website with them using Strapi for our content. There are many other things we can build with Strapi. This is why many companies use it so why not you?