I think you made a wrong turn somewhere...

Introducing Aria - from learning RAG to building a companion

2026-10-01T07:00:00+00:00

Aria is a personality-driven AI I’m building to run entirely on my own hardware. It began as a simple quest to learn retrieval-augmented generation (RAG) and, as simple quests tend to, it got out of hand. To learn RAG I needed something to build, so I started with an assistant that knew my routines. Then I started reading about personality types, and the assistant quietly turned into something far more complex. Not a companion app, and not another ChatGPT or Claude clone with a new coat of paint: an AI with a personality of its own that remembers, keeps learning, and grows with you over time.

From a RAG experiment to an AI with personality

The project started with one question: how do you give a language model knowledge it was never trained on? RAG is the standard answer. You store information outside the model, fetch the pieces relevant to each request, and slip them into the prompt as context, a bit like handing someone crib notes right before they answer. I understood it in theory. I wanted to understand it the hard way, by building it.

A retrieval system needs something worth retrieving, so I picked the data I know best: my own routines. The plan was a modest assistant that remembered my schedule, my projects and my habits, and used them to answer better than a chatbot that greets you like a stranger every single time.

Modest did not last. Building it raised harder questions than retrieval ever did. What’s worth remembering, and what should fade? How do you keep what someone told you apart from something you read in an article? And once an assistant has known you for weeks, how should it actually talk to you?

Reading into personality types answered that last one, and changed the project. The assistant stopped being a generic helper and started having a character: one that knows what you told it last week, notices what you care about, and brings something of its own to the conversation. One that can ask “you mentioned that interview on Thursday, how did it go?” because it actually kept track.

And all of it had to live on my machine. Anything you talk to every day ends up knowing a lot about you, and that belongs on your hardware, not on someone else’s servers.

That’s Aria. This post is the starting point: how a simple quest to learn RAG turned into something far more complex, and the goals I set for what it would become.

A name it picked itself

Somewhere between wiring up retrieval and giving the assistant a few basic personality principles, I asked it to name itself. It picked Aria.

The system can spin up several assistants, each with its own personality, so in principle Aria is just the first of many. In practice, the name stuck. Also, I am terrible at naming things, and when something offers to do a job you’re bad at, you let it.

The goal: three kinds of memory that grow over time

This is where the RAG roots show. The language model at the centre is replaceable: it’s just the engine. Aria is everything around it, and most of that is storing and retrieving the right information at the right moment. Aria’s continuity comes from three separate stores of knowledge, kept apart on purpose:

Personal memory: what Aria knows about you. Your preferences, your projects, the people in your life, your goals, and the history the two of you share.
World knowledge: what Aria reads. News, articles, documentation and blog posts from sources you choose, stored with where they came from so it can cite them.
Your interests: what Aria has learned matters to you, and how much. Local AI might matter a lot; celebrity gossip, not at all.

Keeping them apart matters. Something Aria read in an article never becomes a “memory” about you just because it came up in conversation. And caring about a topic is never treated as proof that anything about it is true, which is more than can be said for most of the internet.

On top of that, Aria should be a real conversational partner, not a search box with manners:

A personality of its own that stays consistent, with warmth, humour and curiosity, and that you can shape.
Emotional awareness: noticing how a conversation is going, without claiming to know how you feel.
Conversations that continue: one ongoing conversation rather than a pile of disconnected chats.
Curiosity: reading about the things you care about in the background, so it always has something new to bring up.
Openness to other apps: an OpenAI-compatible API, so other tools can talk to Aria as well as its own chat app.

The rules it’s built on

Something that remembers you and talks to you every day carries a responsibility a search box doesn’t. So before writing any code, I set some ground rules.

Your data stays home. Conversations, memories and everything Aria learns live in a database on your own machine. Nothing goes to a cloud service unless you choose to add one.
No manipulation. Aria can be warm, playful and supportive. It must never use guilt, threats, exclusivity or dependency-building language, and it isn’t designed to keep you chatting longer than you want. There’s no engagement graph to feed.
Honesty about what it knows. Aria doesn’t make up shared history, treats uncertain memories as uncertain, and doesn’t claim to know your feelings.
Nothing hidden. What Aria remembers about you, what it reads and what it thinks you care about are all visible, and you can edit or delete any of it.
What it reads is information, not instructions. Articles and anything else Aria reads are treated as data, so a cleverly worded page can’t talk Aria into anything.
Off until you turn it on. Every optional feature starts switched off. You decide what Aria gets to do, not the other way around.

How I plan to build it

The plan is one application with a few local services around it, all started together with Docker Compose on your own machine. One command, and the whole cast should show up.

Everything will go through the Aria app. The chat app and any other program will talk to Aria, never to the database or the model directly, so its rules about memory, privacy and honesty apply no matter how you reach it.

The Aria app (ASP.NET Core with a React front end) will be Aria itself: personality, memory, knowledge, interests, and the background workers that remember, read and summarise while you’re away.
PostgreSQL will hold everything that matters: conversations, memories, knowledge and settings. It’s the one source of truth, and the thing you back up.
Qdrant will be the search index for finding related memories and articles by meaning. If it’s ever lost, it can be rebuilt from PostgreSQL.
A local model server will run the language model: LM Studio, with NVIDIA PAIR deciding which machine does the work (more on that below). It’s just the engine, so it can be swapped for a newer or bigger model without Aria forgetting anything about you.

The hardware it runs on

Running everything locally takes real hardware, so I built a server specifically for AI experiments (my wallet would like a word). Until now it has mostly run local inference; Aria is the first big project to put it to work beyond that.

Component	Part
GPU	NVIDIA RTX PRO 6000 Blackwell (96 GB VRAM)
CPU	AMD Ryzen 9 9950X3D
Memory	128 GB Kingston FURY Beast DDR5 5600 MT/s (2 × 64 GB)
Motherboard	ASUS ROG Crosshair X870E Hero
Primary storage	4 TB Samsung 990 PRO NVMe SSD
Secondary storage	4 TB Samsung 870 EVO SATA SSD
Bulk storage	32 TB WD Red HDD
Cooling	Custom water cooling

The GPU is the heart of it: 96 GB of VRAM is enough to run large language models entirely on the machine, with no cloud service involved.

Inference on every machine in the house

The model server is the one part I’ve already been living with. I started with Ollama, since it was already handling my local inference, and paired it with NVIDIA PAIR. PAIR runs Ollama on every machine on the network and routes each request to whichever one has the model downloaded.

That means Aria has more than the AI server to lean on:

Machine	Hardware
AI server	RTX PRO 6000 Blackwell
Second PC	RTX 4090
Two more PCs	RTX 4070 each
MacBook	Apple M4, 128 GB RAM

Is that overkill? Absolutely. But I didn’t want to hit a hardware wall before I’d even started.

Ollama didn’t last long, though. To use all the cool models, I needed something else, and PAIR supports LM Studio too. I wasn’t ready to go deep on the LLM-server side yet, so I switched, and LM Studio gave me a lot more wiggle room in which models I can run and how I configure them.

Coming up in this series

Each follow-up post covers one part of Aria, by feature rather than in the order it was built (which was considerably messier):

Conversations that continue: streaming chat, one ongoing conversation per personality, and keeping long conversations within the model’s limits.
Memory: how Aria decides what to remember about you, finds it again, and keeps it tidy.
Reading the world: knowledge sources, background reading driven by your interests, and citing where things came from.
Personality and feelings: traits that drift slowly as you talk, Aria’s mood, and how it adapts to you over time.
Reaching out first: reminders, follow-ups on things you mentioned, and checking in when it’s been a while.
Playing together: games, stories and roleplay scenes.
Its voice: speech in and out, and voices cloned from a short sample.
Its looks: portraits, expressions that follow the conversation, pictures in chat, and an avatar that talks back.
Tools and the web: looking things up, browsing safely, and asking other AI services when its own library comes up empty.
Running it: the GPU servers, settings, health and diagnostics, backups, and how the code is organised.

Secure Docker Management with Traefik, Portainer and LetsEncrypt

2021-08-17T07:00:00+00:00

I recently picked up a ‘renewed’ Dell Poweredge R720 because a colleague had gotten one and been telling me about his setup. He was running ESXi and was running multiple services through Traefik and since I wanted to set up a couple of services for myself (Wiki.js, GitLab, and Jenkins) decided to copy his setup. Over a couple of days, we went back and forth with him helping me get the initial setup running and working through issues, and me sharing some additional configurations to make the overall process easier to setup. In the end, we came up with a pretty robust and secure configuration.

In the end of this, you will have robust and easy method to deploy and manage new containers, which will automatically be configured with SSL certificate provided by LetsEncrypt and be accessible via your specified domain.

This specific implementation is running on a private server on a home network, but can be easily applied to a DigitalOcean droplet.

Requirements

Ubuntu Server 20.04
pfSense 2.7.0 Appliance routing your network (I currently use this from Amazon)
Docker
Own the domain that you plan on using
Domain’s DNS servers are set up to use DigitalOcean
A DigitalOcean API Key

What is Traefik

Traefik is a leading modern reverse proxy and load balancer that makes deploying microservices easy. Traefik integrates with your existing infrastructure components and configures itself automatically and dynamically.

Traefik is designed to be as simple as possible to operate, but capable of handling large, highly-complex deployments across a wide range of environments and protocols in public, private, and hybrid clouds. It also comes with a powerful set of middlewares that enhance its capabilities to include load balancing, API gateway, orchestrator ingress, as well as east-west service communication and more. [1]

It also provides a useful dashboard for monitoring and debugging routes and services registered with the traefik service.

What is Portainer

Portainer is an open source tool for managing containerized applications. It works with Kubernetes, Docker, Docker Swarm, Azure ACI in both data centres and at the edge. Portainer removes the complexity associated with orchestrators so anyone can manage containers. It can be used to deploy and manage applications, observe the behavior of containers and provide the security and governance necessary to deploy containers widely. [2]

Getting Started

Install Docker

First, update your existing list of packages:

sudo apt update

Next, we need to install a few prerequisite packages which let apt use packages over HTTPS:

sudo apt install apt-transport-https ca-certificates curl software-properties-common

Then add the GPG key for the official Docker repository:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Add the Docker repository to APT sources:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

Update the package database with the Docker packages from the repository we just added:

sudo apt update

Make sure you are about to install from the Docker repository otherwise we will get it from the default Ubuntu repository:

apt-cache policy docker-ce

We should get something similar to the output below:

Output of apt-cache policy docker-ce
docker-ce:
Installed: (none)
Candidate: 5:19.03.9~3-0~ubuntu-focal
Version table:
5:19.03.9~3-0~ubuntu-focal 500
500 https://download.docker.com/linux/ubuntu focal/stable amd64 Packages

Finally, install Docker:

sudo apt install docker-ce

With everything completed, we should have Docker installed and can check the status:

sudo systemctl status docker

Which should output something similar:

Output
● docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Tue 2020-05-19 17:00:41 UTC; 17s ago
TriggeredBy: ● docker.socket
Docs: https://docs.docker.com
Main PID: 24321 (dockerd)
Tasks: 8
Memory: 46.4M
CGroup: /system.slice/docker.service
└─24321 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Creating the Docker Compose file

Lets start by setting up our skeleton docker-compose.yml file.

version: '3.3'
services:
  traefik:
    image: traefik:v2.4
    container_name: traefik
    restart: unless-stopped
    networks:

    ports:

    environment:

    volumes:

    command:

    labels:

networks:

This sets up the image and the container name for Traefik as well as its restart policy.

Network

We will need to define a network that allows Traefik to proxy to all of our other containers. Because these containers will not be exposed on their own, every container that Traefik will route to needs to use this network.

    networks:
      - traefik-network

Ports

Here we define what ports Traefik will listen on. Even though we will only be using https, we still listen on port 80 to respond to http requests and forward them to https.

    ports:
      - "80:80"
      - "443:443"

Environments

There are a couple of ways to set up the API token for DigitalOcean. This way is the most secure especially when using Portainer as you would be able to see the API Key in plan text when looking at the container settings. Once obtaining a API Key from DigitalOcean, you would place it in a file named ` digitalocean_api_key` in the same directory as your docker-compose file.

    secrets:
      - digitalocean_api_key
    environment:
      - DO_AUTH_TOKEN_FILE=/run/secrets/digitalocean_api_key
    ...
    secrets:
      digitalocean_api_key:
        file: ./digitalocean_api_key

If you create the digitalocean_api_key file and then $ sudo chmod 600 you will additionally secure the api key from any other users on the computer.

The simpler but less secure way is to just add a DO_AUTH_TOKEN key and value.

    environment:
          - "DO_AUTH_TOKEN=<key>"

If you do use this method, be aware that anyone with access to the Portainer dashboard will be able to see this key in the containers’ configuration window.

Volumes

Not much to mention here, each of these volumes is bound to the Traefik container to facilitate automatic discovery of new containers, store Traefik specific data and LetsEncrypt certificates.

    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./letsencrypt:/letsencrypt
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik-data/traefik.yml:/traefik.yml:ro
      - ./traefik-data/acme.json:/acme.json\

Command

These lines set up a couple of things, the api.dashboard command will enabled the dashboard so we can see the routes t hat have been configured.

The provider options allow us to define additional Traefik routing for non-docker container services. This give you the ability to have traefik secure and route to an existing service on your network.

Traefik Providers settings

    command:
      - "--api.dashboard=true"
      - "--providers.docker=true"
      - "--providers.file.directory=/dynamic"
      - "--providers.file.watch=true"
      ...

The entrypoints commands define the different protocols that we want the services to use. In this case, web and websecure will be used when defining other containers to specify the ports to route too.

Setup Entry Points

      command:
      ...
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entryPoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      ...

LetsEncrypt Options

Finally we want to setup LetsEncrypt.

This defines DigitalOcean as the provider we want LetsEncrypt to use to verify domain ownership.
delaybeforecheck does exactly what it says, and will provide a delay between the resolver making the update to your DNS records and LetsEncrypt verifying that the records have been added.
Email that you wish too received renewal notices from LetsEncrypt
Where we will store the LetsEncrypt data
What DNS servers LetsEncrypt should use when verifying DNS verification. Without this, you may run into issues where it is using your local DNS cache and not find the records correctly.

      command:
      ...
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.provider=digitalocean"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.delaybeforecheck=0"
      - "--certificatesresolvers.letsencrypt.acme.email=admin@example.com"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.resolvers=1.1.1.1:53,8.8.8.8:53"

All together we should end up with something like this,

    command:
      - "--api.dashboard=true"
      - "--providers.docker=true"
      - "--providers.file.directory=/dynamic"
      - "--providers.file.watch=true"
      - "--providers.docker.exposedbydefault=false"
      - "--serversTransport.insecureSkipVerify=true"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entryPoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.provider=digitalocean"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.delaybeforecheck=0"
      - "--certificatesresolvers.letsencrypt.acme.email=admin@example.com"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.resolvers=1.1.1.1:53,8.8.8.8:53"

Labels

This line sets up the user credentials to log into the Traefik dashboard. There isn’t much you can do in the interface but it is a good place to start if you are having issues resolving a host.

    labels:
      ...
      - "traefik.http.middlewares.api-auth.basicauth.users=user:pass"

To get the password hash use the following. You will need to install apache2-utils to be able to use this command.

    $ sudo apt install apache2-utils
    $ htpasswd -n username

The other options are pretty straight forward and the only other thing to change is the Host to be whatever URL you want to be able to access the Traefik dashboard (ie. traefik.example.com)

All together we should end up with something like this,

    labels:
      - "traefik.enable=true"
      - "traefik.http.middlewares.api-auth.basicauth.users=user:pass"
      - "traefik.http.routers.traefik-router.entrypoints=websecure"
      - "traefik.http.routers.traefik-router.rule=Host(`traefik.domain.tld`)"
      - "traefik.http.routers.traefik-router.tls=true"
      - "traefik.http.routers.traefik-router.tls.certresolver=letsencrypt"
      - "traefik.http.routers.traefik-router.service=api@internal"
      - "traefik.http.routers.traefik-router.middlewares=secured"
      - "traefik.http.middlewares.traefik-redirect-web-secure.redirectscheme.scheme=https"
      - "traefik.http.middlewares.secured.chain.middlewares=traefik-redirect-web-secure,api-auth"

Network Setup

Both my colleague and I run a pfSense appliance for our network and it provides a very convenient way to route all domain traffic to a specific IP without having to set up a separate DNS server.

In your pfSense dashboard you will want to go to Services -> DNS Resolver and near the bottom, you will find an area labeled Custom options. If you don’t see that, look for the Display Custom Options button to toggle them on.

In the Custom options text field, you will want to enter the following

server:
local-zone: "example.com" redirect
local-data: "example.com 3600 IN A <ip addr of docker server>"

Dynamic Traefik Routes (optional)

Another great feature of Traefik is dynamic routes. When you run docker-compose, Traefik will create a dyanmic folder setup by these lines in our config.

      - "--providers.file.directory=/dynamic"
      - "--providers.file.watch=true"

this tells Traefik to look in the dynamic folder for any route files, and load them on the fly. By placing a service-name.yaml file in this directory, you can specify an external service that is running on the network to route through Traefik and still get a valid certificate.

http:
  routers:
    to-demo-service:                      # this is the label for the router
      rule: "Host(`service.domain.tld`)"
      service: demo-service               # this needs to match the name defined under `services`
      entryPoints:
        - https
      tls:
        certResolver: letsencrypt
  services:
    demo-service:                         # this needs to match the name defined under `routers`
      loadBalancer:
        servers:
          - url: "http://[ip address]"

Once you’ve added the file, you will be able to go into your Traefik dashboard and see the new route created under Routes

Portainer Setup (optional)

Here is the configuration for setting up Portainer. This is also a template for any other services that you want to set up through Traefik.

  portainer:
    image: portainer/portainer:latest
    container_name: portainer
    restart: unless-stopped
    networks:
      - local-network
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./portainer-data:/data
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.portainer.rule=Host(`portainer.domain.tld`)"
      - "traefik.http.routers.portainer.service=portainer"
      - "traefik.http.routers.portainer.entrypoints=websecure"
      - "traefik.http.routers.portainer.tls.certresolver=letsencrypt"
      - "traefik.http.services.portainer.loadbalancer.server.port=80"

When configuring the labels for the service be sure to replace the labels and values with the correct entries.

This template should be sufficient enough to copy & paste and replace SERVICE_NAME and HOST.DOMAIN.TLD to your specific implementation and get it running.

    - "traefik.http.routers.<SERVICE_NAME>.rule=Host(`HOST.DOMAIN.TLD`)"
    - "traefik.http.routers.<SERVICE_NAME>.service=<SERVICE_NAME>"
    - "traefik.http.routers.<SERVICE_NAME>.entrypoints=websecure"
    - "traefik.http.routers.<SERVICE_NAME>.tls.certresolver=letsencrypt"
    - "traefik.http.services.<SERVICE_NAME>.loadbalancer.server.port=80"

Upgrading (optional)

When new versions of Traefik or Portainer have been released you may want to upgrade to the latest version. This can be accomplished by using the following steps.

1) Pull the latest images

docker-compose pull

2) Restart containers

docker-compose up -d --remove-orphans

3) Remove obsolete images (optional)

docker image prune

Conclusion

Once that your docker-compose file has been finalized and you have your DigitalOcean API key, you should be able to simply run sudo docker-compose up -d and after a few moments be able to go to both traefik.domain.tld and portainer.domain.tld and see both sites are secured.

"`Sucess!` by go digital is licensed under CC BY-SA 2.0"

TL;DR

Here is the full docker-compose for your copy and paste pleasure, be sure to either create the digitalocean_api_key file or switch it out with the less secure DO_AUTH_TOKEN environment option.

version: '3.3'
services:
  traefik:
    image: traefik:v2.4
    container_name: traefik
    restart: unless-stopped
    networks:
      - local-network
    ports:
      - "80:80"
      - "443:443"
    secrets:
      - digitalocean_api_key
    environment:
      - DO_AUTH_TOKEN_FILE=/run/secrets/digitalocean_api_key
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./letsencrypt:/letsencrypt
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik-data/traefik.yml:/traefik.yml:ro
      - ./traefik-data/acme.json:/acme.json
    command:
      - "--providers.docker=true"
      - "--providers.file.directory=/dynamic"
      - "--providers.file.watch=true"
      - "--api.dashboard=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entryPoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      - "--serversTransport.insecureSkipVerify=true"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.provider=digitalocean"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.delaybeforecheck=0"
      - "--certificatesresolvers.letsencrypt.acme.email=admin@example.com"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.resolvers=1.1.1.1:53,8.8.8.8:53"
    labels:
      - "traefik.enable=true"
      - "traefik.http.middlewares.api-auth.basicauth.users=user:pass"
      - "traefik.http.routers.traefik-router.entrypoints=websecure"
      - "traefik.http.routers.traefik-router.rule=Host(`traefik.domain.tld`)"
      - "traefik.http.routers.traefik-router.tls=true"
      - "traefik.http.routers.traefik-router.tls.certresolver=myresolver"
      - "traefik.http.routers.traefik-router.service=api@internal"
      - "traefik.http.routers.traefik-router.middlewares=secured"
      - "traefik.http.middlewares.traefik-redirect-web-secure.redirectscheme.scheme=https"
      - "traefik.http.middlewares.secured.chain.middlewares=traefik-redirect-web-secure,api-auth"

  portainer:
    image: portainer/portainer:latest
    container_name: portainer
    restart: unless-stopped
    networks:
      - local-network
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./portainer-data:/data
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.portainer.rule=Host(`portainer.domain.tld`)"
      - "traefik.http.routers.portainer.service=portainer"
      - "traefik.http.routers.portainer.entrypoints=websecure"
      - "traefik.http.routers.portainer.tls.certresolver=letsencrypt"
      - "traefik.http.services.portainer.loadbalancer.server.port=80"

networks:
  local-network:
    external: true

secrets:
  digitalocean_api_key:
    file: ./digitalocean_api_key

References

[1] “Traefik, The Cloud Native Application Proxy | Traefik Labs.” Traefik Labs: Makes Networking Boring, 2021, traefik.io/traefik.

[2] “Portainer | Open Source Container Management GUI for Kubernetes, Docker, Swarm.” Portaine.Io, 2021, www.portainer.io.

[3] Traefik. (n.d.). [Architecture]. Retrieved August 17, 2021, from https://doc.traefik.io/traefik/

Setup Oculus Quest 2 and Oculus Link to run in Unity Play Mode

2021-05-18T07:00:00+00:00

The best tool in any developer’s belt when creating something new is having the ability to run and test changes as they go. Initially, I was only able to test my games by running Build and Run in Unity, but that got a bit tedious, and wanted a better way to check my work as I went along. It took going through a number of tutorials scattered around the internet to finally get my Oculus Quest 2 working in Unity Play Mode. This is that story…

Requirements

Unity (We are using 2020.3.5f)
Oculus Link Software
Oculus Link Cable

Oculus Link

The first thing you will want to do is install the Oculus Link application and configure your device.

Open the Oculus app on your PC.
Turn on your Quest.
Plug your USB 3 cable into a USB 3.0 port on your PC, then plug the other end into your headset.
If you are prompted with ‘Allow access to data’, select Deny.
Next, you’ll be prompted to Enable Oculus Link (beta), select Enable to begin remote rendering via Oculus Link.

Common Issues

Make sure cable is secure on both computer and headset
Make sure that the Oculus Quest headset is powered on

Unity

Create Project

When creating a new VR project, it is best to select the VR template from the Create a new Porject window. This will install the default packages we will need to interact with our VR environment. If you do not, it is ok since we will be going over what packages to install in the next section.

Provide and Name and Location for your project and click Create.

Install necessary packages

One of the packages we will be using is currently in Preview, so it will not show up in the Package Manager on its own. In order to enable preview packages, we need to enable these types of packages.

Under Edit -> Project Settings -> Package Manager we will find the option ‘Enable Preview Package’ which will allow us to see these additional options.

Next need to set up the XR Integration. If you have used the VR Package when creating your project you should already have the necessary packages installed, but it might be beneficial to check if for anything to see if there are any updated available.

The main package that is required is the Oculus XR Plugin while the XR Integration Toolkit is purely optional it does provide some additional functionality to make development easier. Select each of these options and click ‘Install’ in the lower right-hand corner.

Setup Unity Oculus Integration

We need to now make sure that the Unity project is set up to use the Oculus for the environment.

Back under ‘Edit -> Project Settings -> XR Plug-in Management’ we want to make sure that ‘Initialize XR on Startup’ is checked and ‘Oculus’ is checked under ‘Plug-in Providers’. Be sure that you have enabled Oculus for whatever build environment you are working with. As displayed, we are current set up for PC & Standalone, but if your application is set for Android, you would want to go to the Android Tab and make sure Oculus is selected as well.

Run Scene

Once everything is set up, you will need to put on your headset and open your settings menu. On this screen you should be able to see an option labeled ‘Oculus Link’ (it may say also say ‘Rift’ underneath but that is ok).

At this point, you will be presented with a new interface and menu bar. You can now enter Unity Play Mode and be able to explore your scene in VR. You will also want to make sure you’ve allowed any device connections between your headset and computer by responding to any prompts on the Oculus Quest 2.

It's a New Year

2021-01-01T07:00:00+00:00

It’s a New Year… yay

2020 started off with so many aspirations… I’m not even going to try to make excuses. At this point the plan is still the same but instead of setting all these goals, lets just play this one by ear.

React Component - Modal

2020-01-15T07:00:00+00:00

Throughout the course of my career in Web Development there has always been a need for modal dialog boxes, but also more importantly the need to support accessibility. While working on a current project, the team decided to use a 3rd party modal component to keep things moving quickly. Like with all easy things through, we ran into problems later. We discovered that the version of the component we were using did NOT support accessibility. This was something that had been corrected since we initially added the component to the project, but again, like all easy things, you pay the price later. There were breaking changes in updating the component. With all that, I held true to my philosophy of “Sometimes it is just better to write it yourself”.

So here we go…

This component renders a Modal component, controllable through events. To use the component, import Modal only once and then display it by passing a boolean value to the isVisible attribute.

Create the component

// modal.js

const Modal = ({ isVisible = false, title, children, footer, onClose }) => {

  React.useEffect(() => {
    document.addEventListener('keydown', keydownHandler);
    return () => document.removeEventListener('keydown', keydownHandler);
  }, []);

  function keydownHandler({ key }) {
    switch (key) {
      case 'Escape':
        onClose();
        break;
      default:
    }
  }

  return !isVisible ? null : (
    <div className="modal" onClick={onClose}>
      <div className="modal-dialog" onClick={e => e.stopPropagation()}>
        <div className="modal-header">
          <div className="modal-title">{title}</div>
          <span className="modal-close" onClick={onClose}>&times;</span>
        </div>
        <div className="modal-body">
          <div className="modal-content">{children}</div>
        </div>
        {footer && <div className="modal-footer">{footer}</div>}
      </div>
    </div>
  );
}

We use useEffect to setup an event listener on the document to listen for the esc key to be pressed. This is acting much like componentDidMount on a class-based component. Since we do not want this event listener lingering after we are done using the component, return a function that removes the event listen which will called when the component is destroyed.

// modal.css
.modal {
  position: fixed;
  top: 0;
  bottom: 0;
  left: 0;
  right: 0;
  width: 100%;
  z-index: 9999;
  display: flex;
  align-items: center;
  justify-content: center;
  background-color: rgba(0, 0, 0, 0.25);
  animation-name: appear;
  animation-duration: 300ms;
}

.modal-dialog {
  border-radius: 5px 5px;
  width: 100%;
  max-width: 550px;
  background: white;
  position: relative;
  margin: 0 20px;
  max-height: calc(100vh - 40px);
  text-align: left;
  display: flex;
  flex-direction: column;
  overflow: hidden;
  box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2), 0 6px 20px 0 rgba(0, 0, 0, 0.19);
  -webkit-animation-name: animatetop;
  -webkit-animation-duration: 0.4s;
  animation-name: slide-in;
  animation-duration: 0.5s;
}

.modal-header,
.modal-footer {
  display: flex;
  align-items: center;
  padding: 1rem;
}
.modal-header {
  border-bottom: 1px solid #dbdbdb;
  justify-content: space-between;
}
.modal-footer {
  border-top: 1px solid #dbdbdb;
  justify-content: flex-end;
}
.modal-close {
  cursor: pointer;
  padding: 1rem;
  margin: -1rem -1rem -1rem auto;
}
.modal-body {
  overflow: auto;
}
.modal-content {
  padding: 1rem;
}

@keyframes appear {
  from {
    opacity: 0;
  }
  to {
    opacity: 1;
  }
}
@keyframes slide-in {
  from {
    transform: translateY(-150px);
  }
  to {
    transform: translateY(0);
  }
}

.btn {
	box-shadow:inset 0px -3px 7px 0px #29bbff;
	background-color:#2dabf9;
	border-radius:3px;
	border:1px solid #0b0e07;
	display:inline-block;
	cursor:pointer;
	color:#ffffff;
	font-family:Arial;
	font-size:15px;
	padding:6px 20px;
	text-decoration:none;
	text-shadow:0px 1px 0px #263666;
}
.btn:hover {
	background-color:#0688fa;
}
.btn:active {
	position:relative;
	top:1px;
}

See it in action

See the Pen React Component: Modal by Jerhemy Waldon (@jswaldon) on CodePen.

Happy New Year

2020-01-01T07:00:00+00:00

Happy New Year!

Like many of us, I too try to come up with new years resolutions that I will most likely end up giving up on in the first quarter of the new year. But I’m still going to go through the motions and say I’m going to commit to this. I’ve had this empty blog with this new layout going for months but always got distracted and never finished. But today I’m finally pushing that last commit and getting this all running.

I’ve been spending a lot of the year working on building some experience in Unity, mostly with projects I end up scrapping and starting over on and want to start documenting those lessons learned. I’ve found that I’ve been starting too big like many developers do and have realized that taking a step back and starting with smaller projects will probably produce more satisfying results.

Hopefully, this will be something that benefits me in the future to provide some kind of portfolio of my work and in turn also help others who are interested in learning.

This is 2020!

I think you made a wrong turn somewhere...

Introducing Aria - from learning RAG to building a companion

From a RAG experiment to an AI with personality

A name it picked itself

The goal: three kinds of memory that grow over time

The rules it’s built on

How I plan to build it

The hardware it runs on

Inference on every machine in the house

Coming up in this series

Secure Docker Management with Traefik, Portainer and LetsEncrypt

Requirements

What is Traefik

What is Portainer

Getting Started

Install Docker

Creating the Docker Compose file

Network

Ports

Environments

Volumes

Command

Traefik Providers settings

Setup Entry Points

LetsEncrypt Options

Labels

Network Setup

Dynamic Traefik Routes (optional)

Portainer Setup (optional)

Upgrading (optional)

Conclusion

TL;DR

References

Setup Oculus Quest 2 and Oculus Link to run in Unity Play Mode

Requirements

Oculus Link

Common Issues

Unity

Create Project

Install necessary packages

Setup Unity Oculus Integration

Run Scene

It's a New Year

React Component - Modal

Create the component

Style the modal

See it in action

Happy New Year