DEV Community: Michael

Supercharge Your Hytale Modding Workflow with mdevtools

Michael — Sun, 01 Feb 2026 01:29:17 +0000

Tired of restarting your server every time you change a line of code?

In this guide, we’ll set up mdevtools to enable hot-reloading for your Hytale modding environment. By creating a tight loop between your Gradle build and your running server, you can iterate faster and stay in the flow.

I’m actively using this exact workflow right now to build the procedural generation systems for Vex's Dungeon Challenge. When you are tweaking complex dungeon logic or iterating on gameplay mechanics, saving those 30-second restart loops saves hours of development time every week.

Here is how to set it up.

1. Download and Install mdevtools

First, grab the latest mdevtools jar file from CurseForge:

Download mdevtools

Where to place the jar:

Depending on your project structure, place the downloaded jar in the following location:

Project Type	Destination Path
Standard Template (mbround18)	`data/server/Server/builtin`
Custom Setup	Create a `builtin` folder in your server root and drop it there.

2. Configure Your Manifest

To ensure the mod loads correctly without crashing, verify that your hytale-mod.json (or equivalent manifest) contains the dependency fields.

Add the following to your manifest:

"Dependencies": {},
"OptionalDependencies": {}

Note: For single-mod development, leaving these objects empty is perfectly fine. They just need to be present.

3. Automate the Copy Process with Gradle

We need a way to move your compiled jar into the server's mods folder automatically. Add this task to your build.gradle file.

This snippet creates an installModJar task that builds your jar and immediately copies it to the server directory:

// In build.gradle
tasks.register("installModJar", Copy) {
    // 1. Build the jar first
    dependsOn ":plugins:yourmod:jar" 

    // 2. Grab the output file
    from { project(":plugins:yourmod").tasks.named("jar").flatMap { it.archiveFile } }

    // 3. Drop it into the server mods folder
    into file("data/server/Server/mods")
}

4. The "Hot Reload" Script

Finally, we tie it all together with a lightweight Bash script. This allows you to rebuild and replace the jar without restarting your Docker container.

Save this as dev-reload.sh in your project root and make it executable (chmod +x dev-reload.sh).

#!/bin/bash
set -euo pipefail
IFS=$'\n\t'

# Configuration
WATCH_DIR="plugin/src"
BUILD_TASK="installModJar" # Updated to match the Gradle task above
JAR_NAME="plugin-name-0.1.0.jar"
JAR_SOURCE="./plugin/build/libs"
JAR_DEST="data/server/Server/mods"
DEBOUNCE_SECONDS=5

last_build_time=0

build_and_copy() {
  # Run the gradle task we created in Step 3
  ./gradlew "$BUILD_TASK" 
}

hard_reload() {
  build_and_copy
  # NOTE: UI assets do NOT hot reload. 
  # If you have new UI files, uncomment lines below to rebuild assets zip.
  # ./gradlew assetsZip \
  #    && cp "dist/$(ls dist | grep -m1 -E 'assets.*\.zip')" "$JAR_DEST/"

  echo "Restarting Docker container..."
  docker compose restart
  echo "Hard reload complete."
}

echo "=========================================================="
echo " Hytale Dev Loop: Ready."
echo " [r] Reload Code (Hot)"
echo " [h] Hard Reload (Restart Container + UI)"
echo " [e] Exit"
echo "=========================================================="

while true; do
  printf "> "
  IFS= read -r -n1 key
  echo
  case "$key" in
    r|R)
      now=$(date +%s)
      if (( now - last_build_time < DEBOUNCE_SECONDS )); then
        echo "Debounced. Wait a moment before reloading again."
        continue
      fi
      last_build_time=$now
      echo "Rebuilding and hot-swapping..."
      build_and_copy
      ;;
    h|H)
      echo "Hard reload requested..."
      hard_reload
      ;;
    e|E)
      echo "Exiting."
      break
      ;;
    *)
      # Ignore other keys
      ;;
  esac
done

5. Bonus: Better UI Development

While mdevtools handles your Java code hot-reloading, writing Hytale UI files (.ui) can still be tricky. The game requires a Hard Reload to see UI changes, so you want to catch errors before you restart.

I’ve built a VS Code extension specifically to solve this:

Hytale UI Ultimate

I use this tool to build the interfaces for Vex's Dungeon Challenge. It provides:

Syntax Highlighting for .ui files.
Diagnostics to catch invalid group naming and missing attributes.
Import Navigation (Ctrl+Click) to jump between UI files.

Pairing this extension with the Hard Reload (h) script above gives you the most robust workflow currently possible.

Summary

You now have a terminal dashboard for development. Instead of manually moving files or waiting for long boot times, you can simply press r to inject your new code instantly.

Happy Modding!

Job Search Fatigue? Here’s How to Fight Burnout and Stay Motivated

Michael — Tue, 17 Sep 2024 20:24:46 +0000

Job searching can be difficult, especially in today’s competitive market, where AI and tough economic conditions add pressure, particularly for engineering roles. However, with the right strategies, you can stay upbeat and motivated on your search! Here are some helpful tips:

1. Start Your Day Like You’re Going to Work

This might sound simple, but getting ready in the morning as if you’re heading into the office is incredibly effective. Getting out of bed, following your routine, and dressing for success puts your mind into a productive space. While it may be tempting to lounge around or mindlessly scroll through job listings, sticking to a routine keeps you mentally prepared for that dream job once you land it.

2. Keep a Detailed Job Application Log

Organization is key when applying to multiple jobs. Creating a spreadsheet to track applications, including the job title, company, salary, link to the posting, and interview status, can be a lifesaver. This will save you from scrambling to find information when a recruiter reaches out. A well-kept log keeps you prepared and helps you follow up efficiently.

3. Turn Rejections into Learning Opportunities

Rejection emails aren’t fun, but they can offer valuable insights. After receiving one, refer to your log and look up the original job posting. Then, consider sending a polite message to the hiring manager via LinkedIn. Thank them for the opportunity and ask if there was anything in your resume or skills they noticed that could be improved. Not all managers will reply, but those who do can provide feedback that helps you grow.

4. Take Breaks to Recharge

It may sound counterintuitive, but breaks are essential to maintain focus. Stand up, walk the dog, play with your cat, or simply stretch. Movement boosts blood flow, helping you think more clearly. It also combats the drowsiness that creeps in after hours of job hunting. Staying refreshed ensures you’re applying with energy and enthusiasm.

5. Work on a Side Project

Whether technical or non-technical, take time to work on something just for yourself. Dive into a new programming language, contribute to an open-source project, or even tackle some household tasks. Keeping your brain engaged and learning is key to staying sharp. Bonus points if your side project is on GitHub or GitLab — it helps showcase your skills and keeps you visible to potential employers.

Final Thoughts

You’ve got this! Job searching in today’s world can feel overwhelming, with recruiters buried under resumes and applicants feeling the pressure to send dozens of applications just to get a callback. But remember, you’re not alone. Lean into your network. Now more than ever, securing a job isn’t just about the number of applications; it’s about building relationships. Reach out to former coworkers, check in, and open up a conversation — you never know where it might lead!

Author's Note: I recently lost my job, and these are the guidelines I try to follow every day. With the support of the wagging tails of my two dogs and the encouragement of my wife, I’ve starting each day motivated and with a smile. I hope these tips help you as much as they’ve helped me stay motivated during this process.

How to use Meilisearch with WikiJS

Michael — Wed, 21 Aug 2024 17:56:24 +0000

TLDR

Sauce: https://github.com/mbround18/wikijs-module-meilisearch

The software

What is Meilisearch

Meilisearch is an open-source search engine built for speed and simplicity. Written in Rust, it’s designed to deliver fast, relevant search results with minimal configuration. Meilisearch excels at full-text search and is optimized for performance, even with large datasets. It supports features like typo tolerance and customizable relevance ranking right out of the box.

Link to Meilisearch

What is WikiJS

Wiki.js is a modern, open-source wiki software that offers a powerful and flexible platform for managing and sharing content. Built on Node.js, it’s designed to be lightweight, fast, and easy to use, with a sleek and intuitive interface that makes it accessible for users of all skill levels.

Link to Wikijs

How to integrate the two

Prerequisites

Running instance of Meilisearch
Running instance of wikijs

If you dont have these, you can use this docker compose.

Using the docker compose

Download the docker compose into a directory.
Create a folder called pkg
Create a folder called tmp
Create a folder called config.
In the config folder, for this demo download this config
Run docker compose up to have it generate the files as needed.

Installing the module

Navigate to the module that integrates them on github.com/mbround18/wikijs-module-meilisearch
Navigate to the releases tab
On the latest release download the Meilisearch.zip file.
Extract the zip to /wiki/server/modules/search/meilisearch on your wikijs server. If you are using compose, docker compose down and extract the zip file into your ./pkg folder.
Restart your wikijs server.

Setting up the module.

Its recommended for a production instance, have meilisearch generate a new key for your app to use. You can do so via this curl command:
curl --request POST \
  --url http://localhost:7700/keys \
  --header 'Authorization: Bearer demo' \
  --header 'Content-Type: application/json' \
  --data '{
    "description": "Wikijs Integration",
    "actions": ["*"],
    "indexes": ["wiki_index"],
    "expiresAt": "2042-04-02T00:42:42Z"
}'
change the word demo to your master key. If you are following along with docker compose this will work with just demo. Unless you changed it in the compose file. Then use what you set for $MEILI_MASTER_KEY.

Log into your wikijs instance, for compose demo you might have to create the initial login. Just remember to set the url to http://localhost:3000 on that inital setup screen.
Navigate to the admin dashboard.
Click Search Engine
Enable Meilisearch
Adjust the API key and host as needed.
Click Apply, if you do not get a green toast message, simply click apply again. This can happen due to the task in Meilisearch stalling while creating the index.

Its setup now what?

Now you can start using Meilisearch to search your wiki! If you have existing content, you can click rebuild and it should add all your content to meilisearch! :)

As you use wikijs normally it will Create, Update, and Delete documents in Meilisearch as part of normal page rendering.

If you want to see a live example of this, on my Dungeons and Dragons wiki we have this integrated already. It has been amazing to recall character data or scene data at your fingertips in an instant.

Note about implementation, currently the suggestions match who lines. In the future, ill rewrite that segment to truncate and have smaller suggestions.

Docker Caching with Compose

Michael — Thu, 18 Jul 2024 16:33:27 +0000

When working with Docker Compose, enabling caching can significantly speed up your builds by reusing layers from previous builds. This article will guide you through the process of setting up caching for Docker Compose, ensuring your development workflow is as efficient as possible.

Prerequisites

Before we start, make sure you have the following installed:

Docker CLI
yq CLI (YAML processor)
docker-compose.yaml file

Step-by-Step Guide

Skip the Step-by-Step and go straight to the sauce.

Step 1: Check for Necessary Tools

First, we need to ensure that the required tools are installed on your system. Here’s a script that checks for Docker CLI, yq CLI, and the presence of the docker-compose.yaml file.

# Check for Docker CLI
if ! command -v docker &> /dev/null
then
    echo "Docker CLI not found. Please install Docker."
    exit 1
fi

# Check for yq CLI
if ! command -v yq &> /dev/null
then
    echo "yq CLI not found. Please install yq."
    exit 1
fi

# Check for docker-compose.yaml
if [ ! -f ./docker-compose.yaml ]; then
    echo "docker-compose.yaml not found. Please ensure the file exists in the current directory."
    exit 1
fi

Step 2: Set Up Preflight Script

The preflight script prepares the environment for caching. It sets up a temporary file path for the caching configuration.

# Set up necessary environment variables if not already set
: "${DOCKER_IMAGE:=your_default_docker_image}"
: "${DOCKER_REGISTRY:=your_default_docker_registry}"
: "${DOCKER_USER:=your_default_docker_user}"
: "${DOCKER_PASSWORD:=your_default_docker_password}"

# Preflight script for cacher-preflight
working_dir=$(dirname "$(realpath ./docker-compose.yaml)")
temp_file="$working_dir/docker-compose.caching.yaml"
export CACHE_COMPOSE_PATH=$temp_file
export DOCKER_BUILDKIT=1

Step 3: Set Up Cacher Script

The cacher script modifies the Docker Compose file to include cache settings for each service.

# Copy into cache path, and add caching
cp ./docker-compose.yaml $CACHE_COMPOSE_PATH
services=$(yq -r '.services | keys | .[]' ./docker-compose.yaml)
for service in $services; do
  yq eval -i ".services.${service}.build.cache_from[0] = \"type=registry,ref=$DOCKER_IMAGE:${service}-buildcache\"" $CACHE_COMPOSE_PATH
  yq eval -i ".services.${service}.build.cache_to[0] = \"type=registry,ref=$DOCKER_IMAGE:${service}-buildcache,mode=max\"" $CACHE_COMPOSE_PATH
done

Step 4: Build and Push Script

Finally, the build script builds and pushes the Docker images, utilizing the caching configurations set up in the previous steps.

# Build script for build
docker buildx create --use

# After using buildx, you will need to relogin into docker.
echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USER" --password-stdin $DOCKER_REGISTRY

docker compose -f $CACHE_COMPOSE_PATH build
docker compose -f $CACHE_COMPOSE_PATH push

Conclusion

With this I was able to speed up compilation in CI/CD greatly by utilizing remote caching. :)

Sometimes all we need is a good safe word! Even ChatGPT!

Michael — Sun, 23 Jun 2024 22:27:49 +0000

Using Safe Words with ChatGPT to Solve Complex Problems: A Must-Have Technique

When dealing with complex problems, communication clarity is crucial. In my recent experience, I found that using safe words with ChatGPT significantly enhanced my problem-solving process. Let me share how this simple technique can be a game-changer for developers and problem solvers alike.

The Concept of Safe Words

Safe words are pre-defined signals used in various contexts to indicate a stop or pause, in the case of AI its to get it to stop responding or talking while you have multiple things you want to explain!

My Experience with ChatGPT

In a recent coding project, I was faced with a complex issue involving a { Rust-based game server for Valheim. I needed ChatGPT’s assistance to navigate through multiple steps without losing track of the conversation’s flow or getting overwhelmed by the details. Here’s how I did it:

Setting the Rules

I started by defining a clear rule with ChatGPT: I would feed it information, and it would respond with "Ok" until I used the safe word "Pineapple." This ensured that I could provide all necessary details before ChatGPT processed and responded with a solution.

The Interaction

Here’s a snapshot of our conversation to illustrate this technique:

User:

I have a complex problem I am trying to solve; I will give you information and you will respond with Ok until I respond with Pineapple. Once I say Pineapple in my prompt you will use all the information I have given you and your knowledge base to come up with a potential solution, do you understand?

ChatGPT:

Ok.

User:

I have a UDP and TCP based game server wrapper build in Rust for a game called Valheim.

ChatGPT:

Ok.

User:

I need a way to monitor traffic on ports

"2456:2456/udp"

"2457:2457/udp"

"2458:2458/udp" When it detects no activity it will pause a process by a process name. I have a way to get the process name.

ChatGPT:

Ok.

User:

NOTE: This was a pretty long output. Truncated for the article. it's just a tree of the src folder in the project. I pasted it directly into the chat with GPT so it could have its context.

Here is my src folder:

src
├── huginn
│   ├── Cargo.toml
│   ├── README.md
│   ├── main.rs
│   └── routes
│       ├── metrics.rs
│       ├── mod.rs
│       └── status.rs
├── odin
│   ├── Cargo.toml
│   ├── README.md
│   ├── build.rs
│   ├── cli.rs
│   ├── commands
│   │   ├── backup.rs
│   │   ├── configure.rs
│   │   ├── install.rs
│   │   ├── install_mod.rs
│   │   ├── logs.rs
│   │   ├── mod.rs
│   │   ├── notify.rs
│   │   ├── start.rs
│   │   ├── status.rs
│   │   ├── stop.rs
│   │   └── update.rs
│   ├── constants.rs
TRUNCATED

ChatGPT:

Ok.

User:

src/odin/server/process.rs has this functionality.

ChatGPT:

Ok.

User:

The process is started via this file src/odin/server/startup.rs.

ChatGPT:

Ok.

User:

Pineapple.

ChatGPT:

Given the requirements and the provided code structure, here's a potential solution for monitoring traffic on the specified UDP ports and pausing a process when no activity is detected...

The Benefits

Controlled Flow of Information: By using a safe word, I controlled when ChatGPT should start processing the data, ensuring it had all the context needed.
Reduced Overwhelm: Breaking down the information into manageable chunks made it easier for both me and ChatGPT to handle complex tasks without missing critical details.
Enhanced Focus: This method allowed ChatGPT to focus on providing a well-thought-out solution rather than responding prematurely to incomplete information.

Implementing Safe Words in Your Workflow

To incorporate this technique in your workflow, follow these simple steps:

Define a Safe Word: Choose a unique word that you will use to signal ChatGPT to process the information and respond. Ensure it is a word unlikely to appear in your regular communication to avoid accidental triggers.
Set the Context: Inform ChatGPT at the beginning of your session about the safe word and the process. This helps in aligning the AI's responses to your communication style.
Feed Information Gradually: Provide the necessary details step-by-step, confirming each piece of information with a simple "Ok" response from ChatGPT.
Use the Safe Word: Once you have provided all the required information, use the safe word to signal ChatGPT to start processing and provide a solution.

Conclusion

Now, I will not say this was all daisies. In true GPT fashion it yelled pineapple after a few prompts when it thought it understood everything. It gave me a partial answer which was incorrect, and I had to remind it:

I didn't say pineapple, you did, hold your response until I say pineapple. is that understood?

However, using safe words with ChatGPT is a powerful technique to solve complex problems effectively. It ensures clear communication, reduces overwhelm, and enhances the quality of the solutions provided by the AI. By implementing this strategy, developers and problem solvers can leverage ChatGPT more efficiently, leading to better outcomes and smoother workflows.

Try it out in your next complex problem-solving session and experience the difference it makes!

Setting up an Enshrouded Dedicated Server with Docker

Michael — Sat, 03 Feb 2024 23:50:37 +0000

Sauce

TLDR: GitHub Repository

Introduction

In the realm of gaming, where the digital and the mystical intertwine, setting up a server should not be a task that dampens your spirits. With the advent of Docker, launching an enshrouded server has become as effortless as casting a spell in a world brimming with magic and adventure. This article unveils the arcane secrets to effortlessly deploying your enshrouded server, allowing you to dive into the gameplay without the mundane worries of traditional server setup.

Before You Begin Your Quest

Ensure your toolkit is complete with Docker and Docker Compose installed. These are the wand and spellbook for your journey, essential for summoning your server into existence.

Crafting Your Server with Docker Compose

The heart of your server lies within the docker-compose.yml file—a grimoire where the configurations of your server are inscribed. Here's a snippet to begin conjuring your enshrouded server:

services:
  enshrouded:
    image: mbround18/enshrouded-docker:latest
    build:
      context: .
      dockerfile: Dockerfile
      platforms:
        - linux/amd64
    environment:
      SERVER_NAME: "My Enshrouded Server"
    ports:
      - "15636:15636/udp"
      - "15636:15636/tcp"
      - "15637:15637/udp"
      - "15637:15637/tcp"
    volumes:
      - ./data:/home/steam/enshrouded

With this incantation, your server is but a docker-compose up away from awakening.

Beyond the Basic Spell: Custom Configurations

While the initial setup is akin to a basic spell, the true magic lies in customization. Tailor your server's environment variables within the docker-compose.yml to fit the unique needs of your adventure.

Environment Variable	Description	Default Value
`SERVER_NAME`	Name of the server	"Enshrouded Server"
`PASSWORD`	Password for the server	"" (empty string)
`SAVE_DIRECTORY`	Save directory for the game	"./savegame"
`LOG_DIRECTORY`	Log directory for the server	"./logs"
`SERVER_IP`	IP address for the server	"0.0.0.0"
`GAME_PORT`	Game port for the server	15636
`QUERY_PORT`	Query port for the server	15637
`SLOT_COUNT`	Number of slots for the server	16

Ensuring Your Server Evolves with You

As your quest evolves, so too might your server needs. Updating your server is as simple as adjusting your docker-compose.yml and restarting the server with a simple down and up command. This ensures your server is always aligned with your latest adventures.

Heed the Call for Backup

Before venturing too far into the unknown, heed the wise advice to back up your save files. The realm of Docker and the enshrouded server setup guide offers pathways to integrating auto backups, safeguarding your progress against unforeseen disasters.

I highly recommend adding backups, this is an easy method to accomplish that goal.

Joining Forces for the Greater Good

Embark on your journey with the enshrouded server and Docker, and let your gaming adventures be limited only by your imagination. The path is laid out before you; summon your server, customize your realm, and step forth into the adventure that awaits.

Dockerize Your Palworld Server: A Step-by-Step Guide

Michael — Mon, 22 Jan 2024 07:31:22 +0000

Sauce

Checkout the GitHub repo here!

Introduction

Are you ready to embark on an adventure in Palworld but dread the tedious server setup? Fear not! In this article, I'll show you how to effortlessly launch your Palworld server using Docker, making your setup process as smooth as sailing the calmest seas 🌊. Whether you're aiming for a casual getaway or a challenging survival experience, this guide is your treasure map 🗺️ to a customized Palworld server.

Why Dockerize Your Palworld Server?

Dockerizing your Palworld server offers several unbeatable advantages:

Simplicity: Say goodbye to complicated setup processes. With Docker, you can get your server up and running with just a few commands.
Consistency: Docker ensures your server environment is consistent, mitigating the dreaded "it works on my machine" syndrome.
Customization: Easily switch between different game modes (casual, normal, hard) or fine-tune settings to your heart's content.

Prerequisites

Before we dive in, make sure you have Docker and Docker Compose installed on your machine. These tools are your Swiss Army knife 🛠️ for managing containerized applications.

Configuration Options Galore

One of the coolest aspects of dockerizing your Palworld server is the plethora of configuration options at your fingertips. Want to control the speed of time? Adjust the DAY_TIME_SPEED_RATE and NIGHT_TIME_SPEED_RATE. Looking to tweak the experience points rate? The EXP_RATE setting has got you covered.

And there's more! Customize everything from Pal capture rates to the number of cooperative players allowed. The sky's the limit when it comes to tailoring your Palworld experience.

Let's Get Dockerizing!

Here's a simple docker-compose.yml snippet to start your Palworld server:

version: "3.8"
services:
  palworld-server:
    image: mbround18/palworld-docker:latest
    environment:
      PRESET: "casual"
    ports:
      - "8211:8211"
      - "27015:27015"
    volumes:
      - "./data:/home/steam/palworld"

With this setup, you're just a docker-compose up away from your Palworld adventure. Customize the environment variables as you see fit to create your perfect game world.

Custom Configuration: Beyond the Presets

While presets are a fantastic way to quickly launch your server, don't forget that you can dive deeper into customization. Modify the docker-compose.yml to include any specific settings you desire:

environment:
  EXP_RATE: "1.5"

Updating Your Server

To update your server settings, simply adjust your docker-compose.yml file and restart your server. This flexibility ensures your Palworld server can evolve alongside your adventures.

Embarking on your Palworld journey has never been easier. With Docker, you're equipped to launch, customize, and manage your server with unprecedented ease. So gather your Pals, set sail for adventure, and remember: in Palworld, your imagination is the only limit! 🚀🌌

The True Price of My Open Source Journey

Michael — Tue, 21 Nov 2023 19:56:44 +0000

Ever wondered what it costs to be an Open Source Software (OSS) developer? I decided to break down my monthly expenses to give you a glimpse into the financial side of my passion for OSS. While I don't do it for the money, sharing this information might help those considering a similar path.

Monthly Expenditure Overview

Tools I Invest In

GitHub Pro: $4 USD/month
- Essential for managing numerous repos with added features and higher limits.
DockerHub Pro: $5 USD/month
- Pro features assist in larger projects with vulnerability scanning and image inspections.
Dedicated Servers: $65 USD/month
- Playground for development and hosting production-grade projects, like my Valheim project.
IDE (IntelliJ): $249 USD/year
- Unbeatable integrations for efficient development.
Dbeaver: $23 USD/month
- The go-to IDE for databases in my opinion.
Cloud Services (AWS/Azure/Google Cloud/B2 Backblaze): $27 USD/month
- Covers backups, static sites, databases, and more.

Yearly Cost: $1,737 USD

Cost-Free Tools

Open Source Tools
- Utilizing free and powerful tools like K8sLens, croc, kubectl, curl, bind-tools (including dig, nc), grep, aria2, terraform, rclone, and many more.

Not Calculated but Still Costs

Time Investment
- Spending an average of 20 hours per week on OSS development.
Living Expenses
- Utilities, housing, and daily sustenance.
Education
- Investing time and money into a Bachelor's and Master's in STEM fields.
Hardware and Technology
- Continuous investment in equipment for development.

Why Share This?

While I'm not in it for the money, the true cost of my OSS journey involves much more than what's reflected in these numbers. It's a labor of love, a commitment of time, and a dedication to personal and professional growth. If you're considering the OSS path, remember, the most valuable contributions often go beyond the balance sheet.

Rapid building with Rust on Windows for WLS2

Michael — Sun, 08 Oct 2023 05:23:51 +0000

Fast Build on Windows for WLS2

This is a quick post y'all! less than 2m read!

Credit markentier.tech with their post here!

Background

I have been struggling compiling on windows with incremental builds & they take forever. After doing lots of Googling I stumbled across the post from markentier.tech. After doing some testing my compile times on a large project for Valheim went from 3-5 minutes to 30 seconds. Back to those beautiful compile times like on my Linux dual boot!

Setup

Install make and rsync
Copy the following Makefile into your repo
Run make wsl.build

Conclusion

This moves your files into a temp directory on your Linux sub-system which allows it to compile directly without the jank of cross system. After compilation it rsyncs only the outputs needed to your target directory if you are using it docker builds or other.

How to append to GitHub Env via JavaScript Action

Michael — Sun, 11 Dec 2022 23:02:17 +0000

Prerequsite

You are creating a JavaScript/TypeScript action for GitHub
You already have a repository going. If not follow this tutorial.

Sauce

DIY

const fs = require('fs');

fs.appendFileSync(process.env["GITHUB_ENV"], "test_var=true");

Core method

const core = require('@actions/core');

core.exportVariable("test_var", "true")

Outcome

This also works for path & step summary :)

const fs = require("fs");

export function appendEnv(key, value) {
  fs.appendFileSync(process.env["GITHUB_ENV"], `${key}=${value}`);
}

export function appendPath(path) {
  fs.appendFileSync(process.env["GITHUB_PATH"], path);
}

export function appendStepSummary(content) {
  fs.appendFileSync(process.env["GITHUB_STEP_SUMMARY"], content);
}

FoundryVTT - Want a video background on login?

Michael — Sun, 30 Oct 2022 21:32:46 +0000

Prerequisites

It is suggested that you have a way to inject scripts into your foundry instance. I have a tutorial on this via "How to Hijack your head (HTML head tag)" which uses Cloudflare

Simplified

Open Cloudflare or the method of script injection.
Add the following injection:

<script
  src="https://gist.githubusercontent.com/mbround18/e4853df98392eb8569a4fd4042723859/raw/1dcd190a521e35786a43dcce806a588ad0bb2bea/video-background.js"
  async
  defer
  type="text/javascript"
  crossorigin="anonymous"
></script>

2.1. If you are using the Cloudflare method of injecting it would be something like this:

class ElementHandler {
  element(element) {
    element.append(
      `<script src="https://gist.githubusercontent.com/mbround18/e4853df98392eb8569a4fd4042723859/raw/1dcd190a521e35786a43dcce806a588ad0bb2bea/video-background.js" async defer type="text/javascript" crossorigin="anonymous"></script>`,
      { html: true }
    );
    console.log("injected");
  }
}

DIY

1) Head on over to GitHub, if you dont have an account I suggest creating one.
2) Click the plus icon in the upper right-hand corner.
3) Click new Gist
4) Give your gist a title.
5) Create a function:

function videoBackground() {
  // Next bit of code goes here!
}

videoBackground();

6) Lets first parse out the extension, we will be using a video & source elements which need a type

const body = document.querySelector("body"); // This bit gives us the body
const background = body.style.backgroundImage
  .replace('url("', "")
  .replace('")', ""); // This parses out the background image.

7) Now with the background accessible and parsed out, lets grab the file extension:

const parts = background.split(".");
const extension = parts[parts.length - 1];

8) With the extension on hand we need to parse out the type of file it is:

let type;
switch (extension) {
  case "avi":
    type = "video/avi";
    break;
  case "ogv":
    type = "video/ogg";
    break;
  case "mp4":
    type = "video/mp4";
    break;
  default:
    return;
}

9) The bit of code above should give us a few options for video backgrounds.
10) Now, lets append our video background to the body:

if (type) {
  let videoBackground = document.querySelector("#video-background"); // This bit cheks for the element.
  if (!videoBackground) {
    // If not exist we create it.
    videoBackground = document.createElement("video");
    videoBackground.id = "video-background";
    videoBackground.autoplay = true;
    videoBackground.muted = true; // Turn this to false if you want the audio.
    videoBackground.loop = true;
    body.appendChild(videoBackground); // Append it to the body.
  }
  let source = document.querySelector("#video-background source"); // Check for the background source.
  if (!source) {
    source = document.createElement("source");
    videoBackground.appendChild(source); // Apend source element.
  }
  source.src = background; // Set background
  source.type = type; // Set type
}

11) In the end, it should look a little something like this
12) Now inject the script using the raw button to get a direct link to the file!

<script
  src="Your link here."
  async
  defer
  type="text/javascript"
  crossorigin="anonymous"
></script>

Rust & Cross-compiling from Linux to Mac on GitHub Actions

Michael — Tue, 09 Aug 2022 21:52:12 +0000

Introduction

So you have a binary that you wish to distribute but you are only able to compile for Windows and Linux at the moment. You have spent hours if not days googling for the appropriate way to cross-compile from Linux to Mac... Well, I am here to tell you I have been there and now provide an easy solution!

The Sauce

Basic Usage

# Setup Rust, use the x86_64-apple-darwin target but the rest can be customized.
- uses: ATiltedTree/setup-rust@v1
  with:
    targets: x86_64-apple-darwin
    rust-version: nightly # Works both with 'stable' and 'nightly'

# Use the v1 of this action
- uses: mbround18/setup-osxcross@v1
  # This builds executables & sets env variables for rust to consume.
  with:
    osx-version: "12.3"

# Checkout your code
- name: Clone your Code
  uses: actions/checkout@v3

# Build your code for apple-darwin based release
- name: Build Your Code
  run: cargo build --release --target x86_64-apple-darwin

Explanation of its Functionality

It creates a folder called osxcross in the github actions working directory. (to avoid interference with any files you might be operating with)
Clones the osxcross repository
It downloads the SDK matching the version you specified from @joseluisq/macosx-sdks
Checks cache
Builds if cache wasn't hit
Sets environment variables for build target x86_64-apple-darwin