HelioHost Wiki - User contributions [en]

Discord Bot - Rust

2026-02-15T03:08:44Z

Lucash: /* Upload Files to Plesk */

== Preface ==
Rust is a compiled, strongly and statically typed general purpose programming language. Compared to Python, Rust applications must be compiled for each operating system and architecture combination, and all variables defined should have a single type.

To learn more about Rust, read [https://doc.rust-lang.org/book/ "The Book"], or follow a more [https://doc.rust-lang.org/rust-by-example/ interactive learning guide] with example code and output.

== Getting Started ==
What to expect in this section:
# Installing Rust and Cargo
# Setting up a Rust project
# Installing needed dependencies (also known as "crates")

To get started, install Rust and Cargo (the package manager for Rust) using [https://rustup.rs/ rustup].

Once installed, create a new project by using Cargo.
<pre>
cargo init ping-pong-rs
</pre>

Running <code>cargo init ping-pong-rs</code> will create a folder named <code>ping-pong-rs</code> with the basic structure of a Rust project.

[[File:Rust_discord_init_folder.png]]

Next, we need to install some dependencies (crates). For this tutorial, we'll be using [https://crates.io/crates/serenity serenity] to interact with Discord, [https://crates.io/crates/tokio tokio] with the "full" feature to manage asynchronous behavior, and [https://crates.io/crates/dotenvy dotenvy] to read your Discord bot token from a file.

To install these crates, use need to use Cargo again.
<pre>
cargo add dotenvy tokio serenity -F tokio/full
</pre>
Once you have the crates installed, you are now ready to code!

== Writing the Discord Bot ==
What to expect in this section:
# Creating an example ping-pong bot
# Building and testing your Discord bot on your machine

We'll be using a modified version of serenity's sample ping-pong bot. Open the <code>main.rs</code> file located in the <code>src</code> folder and paste the following code inside of it:
<pre>
use std::env;

use dotenvy::dotenv;
use serenity::async_trait;
use serenity::model::channel::Message;
use serenity::prelude::*;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
async fn message(&self, ctx: Context, msg: Message) {
if msg.content == "!ping" {
if let Err(why) = msg.channel_id.say(&ctx.http, "Pong!").await {
println!("Error sending message: {why:?}");
}
}
}
}

#[tokio::main]
async fn main() {
// Load all variables from a local environment variable file
dotenv().expect("Expected a .env file to be created");

// Login with a bot token from the environment
let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");

// Set gateway intents, which decides what events the bot will be notified about
let intents = GatewayIntents::GUILD_MESSAGES
| GatewayIntents::DIRECT_MESSAGES
| GatewayIntents::MESSAGE_CONTENT;

// Create a new instance of the Client, logging in as a bot.
let mut client = Client::builder(&token, intents)
.event_handler(Handler)
.await
.expect("Err creating client");

println!("Starting bot");

// Start listening for events by starting a single shard
if let Err(why) = client.start().await {
println!("Client error: {why:?}");
}
}
</pre>

Next, you'll need to copy your Discord bot token into a file named <code>.env</code>. '''This file should be located in the same place as the <code>src</code> folder, NOT inside of it'''.

[[File:Rust_env_folder_structure.png]]

The environment file should contain your token:
<pre>
DISCORD_TOKEN=your_discord_bot_token
</pre>

Finally, you are now ready to run your bot locally to test it out!
<pre>
cargo run
</pre>
The run command will build and run your bot locally. Remember, Rust is a compiled language. This means that your bot must be compiled before it can be run, this can take around a minute.
<pre>
lucas@fozziebear:~/heliohost/ping-pong-rs$ cargo run
Compiling proc-macro2 v1.0.106
Compiling quote v1.0.44
.
.
.
Compiling hyper-rustls v0.27.7
Compiling reqwest v0.12.28
Compiling ping-pong-rs v0.1.0 (/home/lucas/heliohost/ping-pong-rs)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 41.00s
Running `target/debug/ping-pong-rs`
Starting bot
</pre>

You should see the message <code>Starting bot</code> at the end if everything compiled successfully.

Once your project is up and running, return to Discord and type <code>!ping</code> in the channel your bot is located in and see it return your message!

[[File:Rust_discord_pong.png]]

== Building your Discord Bot for HelioHost ==
What to expect in this section:
# How to build the correct file to work in HelioHost

Rust applications must be built to run on the machine that you want to run your application on. In simple terms, this means that to run a Rust Discord bot on HelioHost, you should build a Linux x86_64 application.

For users that are writing code on a Windows machine (this does not include WSL2), or a MacOS machine, you will need to cross compile to the correct architecture.

=== Building a release binary on the same architecture and host ===
If you are on a system that '''matches''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. Simply running a normal release build is enough.
<pre>cargo build --release</pre>
This will build the final file under <code>target/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cargo.png]]

=== Building a release binary on a different host ===
If you are on a system that '''does not match''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. This includes Windows, MacOS, or Linux ARM machines.

The most straightforward way to do this is by using [https://github.com/cross-rs/cross cross] to build your application inside of a Docker container.

To get started, install [https://www.docker.com/ Docker]. This is most commonly done by installing Docker Desktop for those using Windows or MacOS.

Once you have Docker installed and running, install cross by using Cargo.
<pre>
cargo install cross --git https://github.com/cross-rs/cross
</pre>

After cross has completed building and installing, create a release build for the Linux x86_64 architecture using the tool.
<pre>
cross build --target x86_64-unknown-linux-gnu --release
</pre>

This will build the final file under <code>target/x86_64-unknown-linux-gnu/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cross.png]]

== Upload Files to Plesk ==
You will need to upload both your environment variable file and the binary to your Plesk account to setup.

Navigate to your '''Home Directory''' and upload both the <code>.env</code> and <code>ping-pong-rs</code> files.

[[File:Rust_upload_plesk.png]]

Now, we need to set the permissions of the <code>ping-pong-rs</code> file to be executable. On the file manager click the <code>rw- r-- r--</code> and check all the <code>Execute/search</code> boxes

[[File:755_permissions.png]]

This will allow the file to be run in later sections.

== Starting the Discord Bot ==
To start the Discord bot, read up on the rest of the guide at the [[:Discord_Bot#Starting_and_Stopping_Your_Bot|end of the Discord tutorial]].

[[Category:Tutorials]]

Discord Bot - Rust

2026-02-14T09:10:00Z

Lucash: /* Building a release binary on a different host */

== Preface ==
Rust is a compiled, strongly and statically typed general purpose programming language. Compared to Python, Rust applications must be compiled for each operating system and architecture combination, and all variables defined should have a single type.

To learn more about Rust, read [https://doc.rust-lang.org/book/ "The Book"], or follow a more [https://doc.rust-lang.org/rust-by-example/ interactive learning guide] with example code and output.

== Getting Started ==
What to expect in this section:
# Installing Rust and Cargo
# Setting up a Rust project
# Installing needed dependencies (also known as "crates")

To get started, install Rust and Cargo (the package manager for Rust) using [https://rustup.rs/ rustup].

Once installed, create a new project by using Cargo.
<pre>
cargo init ping-pong-rs
</pre>

Running <code>cargo init ping-pong-rs</code> will create a folder named <code>ping-pong-rs</code> with the basic structure of a Rust project.

[[File:Rust_discord_init_folder.png]]

Next, we need to install some dependencies (crates). For this tutorial, we'll be using [https://crates.io/crates/serenity serenity] to interact with Discord, [https://crates.io/crates/tokio tokio] with the "full" feature to manage asynchronous behavior, and [https://crates.io/crates/dotenvy dotenvy] to read your Discord bot token from a file.

To install these crates, use need to use Cargo again.
<pre>
cargo add dotenvy tokio serenity -F tokio/full
</pre>
Once you have the crates installed, you are now ready to code!

== Writing the Discord Bot ==
What to expect in this section:
# Creating an example ping-pong bot
# Building and testing your Discord bot on your machine

We'll be using a modified version of serenity's sample ping-pong bot. Open the <code>main.rs</code> file located in the <code>src</code> folder and paste the following code inside of it:
<pre>
use std::env;

use dotenvy::dotenv;
use serenity::async_trait;
use serenity::model::channel::Message;
use serenity::prelude::*;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
async fn message(&self, ctx: Context, msg: Message) {
if msg.content == "!ping" {
if let Err(why) = msg.channel_id.say(&ctx.http, "Pong!").await {
println!("Error sending message: {why:?}");
}
}
}
}

#[tokio::main]
async fn main() {
// Load all variables from a local environment variable file
dotenv().expect("Expected a .env file to be created");

// Login with a bot token from the environment
let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");

// Set gateway intents, which decides what events the bot will be notified about
let intents = GatewayIntents::GUILD_MESSAGES
| GatewayIntents::DIRECT_MESSAGES
| GatewayIntents::MESSAGE_CONTENT;

// Create a new instance of the Client, logging in as a bot.
let mut client = Client::builder(&token, intents)
.event_handler(Handler)
.await
.expect("Err creating client");

println!("Starting bot");

// Start listening for events by starting a single shard
if let Err(why) = client.start().await {
println!("Client error: {why:?}");
}
}
</pre>

Next, you'll need to copy your Discord bot token into a file named <code>.env</code>. '''This file should be located in the same place as the <code>src</code> folder, NOT inside of it'''.

[[File:Rust_env_folder_structure.png]]

The environment file should contain your token:
<pre>
DISCORD_TOKEN=your_discord_bot_token
</pre>

Finally, you are now ready to run your bot locally to test it out!
<pre>
cargo run
</pre>
The run command will build and run your bot locally. Remember, Rust is a compiled language. This means that your bot must be compiled before it can be run, this can take around a minute.
<pre>
lucas@fozziebear:~/heliohost/ping-pong-rs$ cargo run
Compiling proc-macro2 v1.0.106
Compiling quote v1.0.44
.
.
.
Compiling hyper-rustls v0.27.7
Compiling reqwest v0.12.28
Compiling ping-pong-rs v0.1.0 (/home/lucas/heliohost/ping-pong-rs)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 41.00s
Running `target/debug/ping-pong-rs`
Starting bot
</pre>

You should see the message <code>Starting bot</code> at the end if everything compiled successfully.

Once your project is up and running, return to Discord and type <code>!ping</code> in the channel your bot is located in and see it return your message!

[[File:Rust_discord_pong.png]]

== Building your Discord Bot for HelioHost ==
What to expect in this section:
# How to build the correct file to work in HelioHost

Rust applications must be built to run on the machine that you want to run your application on. In simple terms, this means that to run a Rust Discord bot on HelioHost, you should build a Linux x86_64 application.

For users that are writing code on a Windows machine (this does not include WSL2), or a MacOS machine, you will need to cross compile to the correct architecture.

=== Building a release binary on the same architecture and host ===
If you are on a system that '''matches''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. Simply running a normal release build is enough.
<pre>cargo build --release</pre>
This will build the final file under <code>target/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cargo.png]]

=== Building a release binary on a different host ===
If you are on a system that '''does not match''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. This includes Windows, MacOS, or Linux ARM machines.

The most straightforward way to do this is by using [https://github.com/cross-rs/cross cross] to build your application inside of a Docker container.

To get started, install [https://www.docker.com/ Docker]. This is most commonly done by installing Docker Desktop for those using Windows or MacOS.

Once you have Docker installed and running, install cross by using Cargo.
<pre>
cargo install cross --git https://github.com/cross-rs/cross
</pre>

After cross has completed building and installing, create a release build for the Linux x86_64 architecture using the tool.
<pre>
cross build --target x86_64-unknown-linux-gnu --release
</pre>

This will build the final file under <code>target/x86_64-unknown-linux-gnu/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cross.png]]

== Upload Files to Plesk ==
You will need to upload both your environment variable file and the binary to your Plesk account to setup.

Navigate to your '''Home Directory''' and upload both the <code>.env</code> and <code>ping-pong-rs</code> files.

[[File:Rust_upload_plesk.png]]

== Starting the Discord Bot ==
To start the Discord bot, read up on the rest of the guide at the [[:Discord_Bot#Starting_and_Stopping_Your_Bot|end of the Discord tutorial]].

[[Category:Tutorials]]

Discord Bot

2026-02-14T09:05:47Z

Lucash:

== Preface ==

This guide will work on any of the HelioHost servers.

Python is an interpreted, object-oriented, high-level programming language with dynamic semantics. Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python's simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance. Python supports modules and packages, which encourages program modularity and code reuse.

The Discord app works with desktop and mobile platforms, combining the features of a chat lobby, a message board and a VoIP chatting system into one app that's not going to hog resources on your phone or PC. Discord's popularity has only multiplied in recent years, with the app now reaching over 90 million registered users.

Bots and apps are the lifeblood of the Discord development community. They come in all shapes and sizes, from small hobby projects for your server with friends, to huge projects that live in hundreds of thousands of servers. We love seeing the unique, fun, and sometimes downright strange (in a good way) creations that come from our community.

== How to get Started with a Discord Bot ==

First you'll need to have a Discord account, and a Discord channel that you'll add the bot to later. Here's a [https://www.howtogeek.com/364075/how-to-create-set-up-and-manage-your-discord-server/ good guide] to get started.

== Create the Bot ==

Once you have your Discord server all set up it's time to create the bot through Discord's site. Go to [https://discordapp.com/developers/applications discordapp.com/developers/applications] and make sure you're logged in. Then click 'New Application' in the top right.

[[File:New_application.png]]

Type a name and hit create. I decided to name my bot 'HelioBot'.

== Add the Bot to your Discord Server ==

Click 'OAuth2' on the left navigation.

[[File:oauth2.png]]

Then check the bot box under 'SCOPES', and scroll down and select 'Administrator' under 'BOT PERMISSIONS'. You could select the exact permissions that your bot needs one by one, but for this simple example it's easier to just allow the bot permission to do everything.

[[File:bot_admin.png]]

Click copy next to the URL that is generated and open that URL in a new tab. Then, select your Discord server from the dropdown menu.

[[File:add_to_server.png]]

Click 'Authorize' and complete the reCAPTCHA to add the bot to the Discord server. If you go to your Discord now you can see the bot on the offline user list.

[[File:offline_bot.png]]

== Setup the Discord Bot Intents and Token ==
Go back to the Discord bot page and click bot on the left navigation again.

[[File:select_bot.png]]

The first thing we need to do on this page is enable 'Presence Intent', 'Server Members Intent', and 'Message Content Intent'. If you're sure your bot doesn't need all three of these enable just what you need, but for simplicity of this guide we're going to enable all three, and then save the changes.

[[File:discord_intents.png]]

On the same page click the 'Reset Token' button, and then copy/paste the token. Keep this token somewhere for now, we will use it later when writing the bot code.

[[File:copy_token.png]]

If you ever think someone has gotten your token, for instance if you posted it on a public wiki like I just did, be sure to come back to this page and reset it. Anyone who has your token can do whatever permissions you granted your bot to your server.

== Write your Bot Code ==
We have provided some basic tutorials on how to write and build Discord bots in different programming languages.
* [[:Discord_Bot_-_Python|Python]]
* [[:Discord_Bot_-_Rust|Rust]]
This is not an exhaustive list, just a list of languages that we have verified to work. If you know of another method of creating a Discord bot on HelioHost we welcome [[:Contributing_to_the_Wiki|contributions]].

== Starting and Stopping Your Bot ==

You have a functional bot now, but you need a way to start and stop it.

{{Info|
Side note: Previous versions of this guide used Python scripts to start and stop the Discord bot. Unfortunately, the people who wanted to write their bot in Node.js always complained that they didn't want to use Python for anything. Likewise, if we used Node.js to start and stop the bot, the Python people would inevitably complain about not wanting to use Node.js for anything. Therefore, we wrote the start and stop scripts in Bash CGI to make absolutely sure that no one is happy.
}}

We'll use Bash CGI to do that so you can control your bot through your web page. With the file manager, navigate to '/httpdocs' and create a new directory called 'bot_control'.

[[File:bot_control.png]]

Now create a new file named '.htaccess' in the '/httpdocs/bot_control' directory.

[[File:create_htaccess.png]]

Paste this code into the new '.htaccess' file.

<pre>
Options +ExecCGI
AddHandler cgi-script .sh
DirectoryIndex index.sh
</pre>

Next create a new file named 'index.sh' in the '/httpdocs/bot_control' directory.

[[File:create_indexsh.png]]

Paste the code below into the new file. Remember to use either 'helio'''ho.st'''' or 'helioho'''st.us'''' at the end of your domain, unless you're one of the very few users who still have a legacy heliohost.org domain:

<pre>
#!/bin/bash

# edit this to match your bot filename
bot_name="heliobot.py"

###################################################################

printf 'Content-Type: text/html\n\n'
username=`whoami`
pwd=`printenv|grep '^PWD'|cut -f2 -d'='`
main_domain=`echo "$pwd"|cut -f3 -d'/'`
control=`echo "$pwd"|cut -f5 -d'/'`
temp=`ps axo user:16,pid,pcpu,pmem,vsz,rss,tty,stat,start,time,command|grep -v grep|grep "^$username "`
running=`echo "$temp"|grep -c "$bot_name"`
file_base=`echo $bot_name|tr -cd "a-zA-Z0-9"`
log_name="$file_base.txt"
if [ "$QUERY_STRING" == "" ]; then
if [ $running -ne 0 ]; then
mem_kb=`echo "$temp"|grep "$bot_name"|awk '{print $6}'`
mem_mb=$( echo "scale=2;$mem_kb/1024"|bc )
mem_24=$( echo "scale=2;$mem_kb*1440/1048576"|bc )
echo "$bot_name is running. <a href='?action=stop'>Stop</a><br>Current memory usage: $mem_mb MB<br>Estimated 24 hour usage: $mem_24 GB - "
else
echo "$bot_name is not running. <a href='?action=start'>Start</a> - "
fi
echo "<a href='https://heliohost.org/dashboard/load/' target='_blank'>Check Load</a><br><br>Logs: <a href='?action=clear'>Clear Logs</a> - <a href='/$control/$log_name'>Full Logs</a><pre>"
tail -30 $pwd/$log_name
echo "</pre><script>reloading = setTimeout('window.location.reload();', 10000);</script>"
fi
ts=`date +"%Y-%m-%d %H:%M:%S"`
if [ "$QUERY_STRING" == "action=stop" ]; then
echo "[$ts] Stopping $bot_name." >> $pwd/$log_name
pid=`echo "$temp"|grep "$bot_name"|tail -1|awk '{print $2}'`
if [ ${#pid} -ne 0 ]; then
kill $pid
fi
echo "Stopping $bot_name...<script>setInterval(\"window.location.replace('/$control/');\", 2000);</script>"
fi
if [ "$QUERY_STRING" == "action=start" ]; then
if [ $running -ne 0 ]; then
echo "$bot_name is already running..."
else
echo "[$ts] Starting $bot_name." >> $pwd/$log_name
/usr/bin/python3.12 -u /home/$main_domain/$bot_name >> $pwd/$log_name 2>&1 &
echo "Starting $bot_name...<script>window.location.replace('/$control/');</script>"
fi
fi
if [ "$QUERY_STRING" == "action=clear" ]; then
cat /dev/null > $pwd/$log_name
echo "Clearing logs...<script>window.location.replace('/$control/');</script>"
fi
exit 0
</pre>

Be sure to edit the variable at the top of the file to match your bot filename.

Now, we need to set the permissions of this 'index.sh' file to be executable. On the file manager click the 'rw- r-- r--' and check all the 'Execute/Search' boxes just like we did the heliobot.py file earlier.

[[File:755_permissions.png]]

== Test It Out ==

Now everything should be ready to be tested. Open your browser and go to 'yourdomain.helioho.st/bot_control/' and when you click Start it should start the bot. You can check if the bot is running by going to Discord and seeing if HelioBot is showing up as online now. If it is, test it out by typing the command if you have been following the Python tutorial:

<pre>
!hello
</pre>

It should respond to you.

[[File:testing_discord_bot.png]]

If it doesn't work go back and check all the steps again to make sure you did everything correctly. You can also check out the logs in the bot_control dashboard to see if there is any errors listed. For example, if you try to import a modules that isn't already installed it will give an error like this:

[[File:bot_error.png]]

If you can't figure out what is wrong let us know by opening [https://helionet.org/index/forum/45-customer-service/?do=add a customer service ticket].

== Watch Your Account Load ==

{{Caution|Bots use a lot of system resources so we recommend [https://heliohost.org/dashboard/load/ keeping an eye on your account load].}}

We enforce a memory limit of no more than {{Template:MemoryLimit}} per day and a limit of {{Template:CPULimit}} usage per day on our shared hosting servers.
* On the [[:Tommy|Tommy]] and [[:Johnny|Johnny]] servers, if you exceed these limits, your account will be [[:Suspension_Policy#High_Server_Usage|suspended]].
* On the [[:Morty|Morty]] server, if you exceed these limits, we will charge you for overages.

On the bot_control dashboard it shows the current memory usage, and the estimated usage over the next 24 hours if your bot continues using the same amount of memory.

[[File:bot_dashboard.png]]

If you followed the Python guide exactly your bot will use about 50 GB of memory per day, which is 1/4 of your allowed amount. If you edit your bot code, make your bot more complicated, and import more modules it will increase the memory usage though. Obviously if you have some sort of memory leak it could easily allow your bot to continue consuming more and more memory until you get [[:Suspension_Policy#High_Server_Usage|suspended]] on [[:Tommy]] and [[:Johnny]], or charged for overages on [[:Morty|Morty]].

If everything is working you can shut your bot down by clicking the Stop button on the bot_control dashboard. It's a good idea to keep your bot offline if you don't need it so you don't cause too much load. If you're having trouble staying under the limits you could also consider [https://heliohost.org/dashboard/move/?move=morty-prepay moving to the Morty plan] where there is no load limit. You could also move to a VPS where you have root SSH access, dedicated memory, dedicated CPU, and no load limits. {{Template:VPSInfo}}

== Automatically Restarting the Bot ==

We've had a lot of people ask us if we intentionally stop their bots after 60 minutes or so. The answer is no. The only time we kill processes automatically is if your account got suspended for high load. In our testing the bots can run for weeks or longer without needing to be restarted. Our servers are stable enough to run for months or years without a reboot as well. The issue is undoubtedly that people write bad code that crashes, but rather than admitting that their code is buggy, it's easier to just blame us.

If your bot keeps stopping on its own, the best solution is to check the logs and fix the issue. If there is nothing shown in the logs that means you need to add more logging to your code to figure out why it's crashing. If you still can't figure it out you could enable auto-restart, but it's really just a crutch for buggy code rather than a real fix. If your bot code really is stable enough to run for weeks or months without crashing, auto-restart can also benefit you in the rare case of us rebooting the whole server, your bot will automatically start up as soon as the reboot is finished.

{{Caution|
Enabling auto-restart could increase your chance of getting suspended. If you don't currently need your bot online we recommend shutting it down entirely rather than leaving it restarting over and over.
}}

To set up auto-restart login to Plesk and navigate to:

'''Login > Plesk > Websites & Domains > [ domain ] > Scheduled Tasks'''

[[File:plesk-scheduled-tasks.png]]

Next, click 'Add Task' and select the 'Fetch a URL' option.

[[File:Plesk-schedule-a-task.png]]

In the URL box put the start link from your bot_control page if you would click 'Start'. The easiest way to get this value is to stop your bot, and then right click on the 'Start' link, and 'Copy link address'.

[[File:Telegram-start-link.png]]

If you followed this guide without changing too much it should be something like 'yourdomain.helioho.st/bot_control/?action=start'.

[[File:Telegram-cron-job.png]]

For those of you who want to minimize the downtime, and maximize your suspension chance you can set the schedule task up to run every minute like this with Cron Style and '* * * * *'. If everything is working correctly it will check if the bot is up every minute. Then if the bot is stopped it will restart it, and if the bot is already running it won't do anything.

{{Danger|
Running a scheduled task every minute increases your load by quite a bit even if your bot never needs to be restarted. Simply checking if it has crashed causes some load. Worst case scenario: this scheduled task starts a new bot process every minute even though you already have a copy of the bot running, and you get suspended on [[:Tommy|Tommy]] or [[:Johnny|Johnny]] in record time, or reach the maximum billing on [[:Morty|Morty]] faster than anyone has ever dreamed possible.
}}

[[Category:Tutorials]]

Discord Bot - Rust

2026-02-14T08:53:38Z

Lucash:

== Preface ==
Rust is a compiled, strongly and statically typed general purpose programming language. Compared to Python, Rust applications must be compiled for each operating system and architecture combination, and all variables defined should have a single type.

To learn more about Rust, read [https://doc.rust-lang.org/book/ "The Book"], or follow a more [https://doc.rust-lang.org/rust-by-example/ interactive learning guide] with example code and output.

== Getting Started ==
What to expect in this section:
# Installing Rust and Cargo
# Setting up a Rust project
# Installing needed dependencies (also known as "crates")

To get started, install Rust and Cargo (the package manager for Rust) using [https://rustup.rs/ rustup].

Once installed, create a new project by using Cargo.
<pre>
cargo init ping-pong-rs
</pre>

Running <code>cargo init ping-pong-rs</code> will create a folder named <code>ping-pong-rs</code> with the basic structure of a Rust project.

[[File:Rust_discord_init_folder.png]]

Next, we need to install some dependencies (crates). For this tutorial, we'll be using [https://crates.io/crates/serenity serenity] to interact with Discord, [https://crates.io/crates/tokio tokio] with the "full" feature to manage asynchronous behavior, and [https://crates.io/crates/dotenvy dotenvy] to read your Discord bot token from a file.

To install these crates, use need to use Cargo again.
<pre>
cargo add dotenvy tokio serenity -F tokio/full
</pre>
Once you have the crates installed, you are now ready to code!

== Writing the Discord Bot ==
What to expect in this section:
# Creating an example ping-pong bot
# Building and testing your Discord bot on your machine

We'll be using a modified version of serenity's sample ping-pong bot. Open the <code>main.rs</code> file located in the <code>src</code> folder and paste the following code inside of it:
<pre>
use std::env;

use dotenvy::dotenv;
use serenity::async_trait;
use serenity::model::channel::Message;
use serenity::prelude::*;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
async fn message(&self, ctx: Context, msg: Message) {
if msg.content == "!ping" {
if let Err(why) = msg.channel_id.say(&ctx.http, "Pong!").await {
println!("Error sending message: {why:?}");
}
}
}
}

#[tokio::main]
async fn main() {
// Load all variables from a local environment variable file
dotenv().expect("Expected a .env file to be created");

// Login with a bot token from the environment
let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");

// Set gateway intents, which decides what events the bot will be notified about
let intents = GatewayIntents::GUILD_MESSAGES
| GatewayIntents::DIRECT_MESSAGES
| GatewayIntents::MESSAGE_CONTENT;

// Create a new instance of the Client, logging in as a bot.
let mut client = Client::builder(&token, intents)
.event_handler(Handler)
.await
.expect("Err creating client");

println!("Starting bot");

// Start listening for events by starting a single shard
if let Err(why) = client.start().await {
println!("Client error: {why:?}");
}
}
</pre>

Next, you'll need to copy your Discord bot token into a file named <code>.env</code>. '''This file should be located in the same place as the <code>src</code> folder, NOT inside of it'''.

[[File:Rust_env_folder_structure.png]]

The environment file should contain your token:
<pre>
DISCORD_TOKEN=your_discord_bot_token
</pre>

Finally, you are now ready to run your bot locally to test it out!
<pre>
cargo run
</pre>
The run command will build and run your bot locally. Remember, Rust is a compiled language. This means that your bot must be compiled before it can be run, this can take around a minute.
<pre>
lucas@fozziebear:~/heliohost/ping-pong-rs$ cargo run
Compiling proc-macro2 v1.0.106
Compiling quote v1.0.44
.
.
.
Compiling hyper-rustls v0.27.7
Compiling reqwest v0.12.28
Compiling ping-pong-rs v0.1.0 (/home/lucas/heliohost/ping-pong-rs)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 41.00s
Running `target/debug/ping-pong-rs`
Starting bot
</pre>

You should see the message <code>Starting bot</code> at the end if everything compiled successfully.

Once your project is up and running, return to Discord and type <code>!ping</code> in the channel your bot is located in and see it return your message!

[[File:Rust_discord_pong.png]]

== Building your Discord Bot for HelioHost ==
What to expect in this section:
# How to build the correct file to work in HelioHost

Rust applications must be built to run on the machine that you want to run your application on. In simple terms, this means that to run a Rust Discord bot on HelioHost, you should build a Linux x86_64 application.

For users that are writing code on a Windows machine (this does not include WSL2), or a MacOS machine, you will need to cross compile to the correct architecture.

=== Building a release binary on the same architecture and host ===
If you are on a system that '''matches''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. Simply running a normal release build is enough.
<pre>cargo build --release</pre>
This will build the final file under <code>target/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cargo.png]]

=== Building a release binary on a different host ===
If you are on a system that '''does not match''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. This includes Windows, MacOS, or Linux ARM machines.

The most straightforward way to do this is by using [https://github.com/cross-rs/cross cross]] to build your application inside of a Docker container.

To get started, install [https://www.docker.com/ Docker]. This is most commonly done by installing Docker Desktop for those using Windows or MacOS.

Once you have Docker installed and running, install cross by using Cargo.
<pre>
cargo install cross --git https://github.com/cross-rs/cross
</pre>

After cross has completed building and installing, create a release build for the Linux x86_64 architecture using the tool.
<pre>
cross build --target x86_64-unknown-linux-gnu --release
</pre>

This will build the final file under <code>target/x86_64-unknown-linux-gnu/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cross.png]]

== Upload Files to Plesk ==
You will need to upload both your environment variable file and the binary to your Plesk account to setup.

Navigate to your '''Home Directory''' and upload both the <code>.env</code> and <code>ping-pong-rs</code> files.

[[File:Rust_upload_plesk.png]]

== Starting the Discord Bot ==
To start the Discord bot, read up on the rest of the guide at the [[:Discord_Bot#Starting_and_Stopping_Your_Bot|end of the Discord tutorial]].

[[Category:Tutorials]]

Discord Bot - Python

2026-02-14T08:53:35Z

Lucash:

== Preface ==

Python is an interpreted, object-oriented, high-level programming language with dynamic semantics. Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python's simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance. Python supports modules and packages, which encourages program modularity and code reuse.

== Write the Bot Script in Python ==

[https://heliohost.org/login Log in] and continue to Plesk. Then load up the file manager.

[[File:file_manager.png]]

In the top left corner click the '+' plus sign, and select 'Create File'.

[[File:plus_file.png]]

Then type the name of your new file: 'heliobot.py'.

[[File:create_heliobot.png]]

You want to create this bot in your home directory so random hackers and bots on the internet can't access it directly. Make sure it says 'Add a file to: /' not 'Add a file to: /httpdocs' or any other folder.

Scroll down in the file manager and click on the new 'heliobot.py' file to edit it. Then copy/paste this code in:

<pre>
#!/usr/bin/python3.12

import os
import discord
from dotenv import load_dotenv

load_dotenv()
token = os.getenv('DISCORD_TOKEN')

import certifi
os.environ["SSL_CERT_FILE"] = certifi.where()

client = discord.Client(intents=discord.Intents.default())

class MyClient(discord.Client):
async def on_ready(self):
print(f'Logged in as {self.user} (ID: {self.user.id})')
print('------')

async def on_message(self, message):
# we do not want the bot to reply to itself
if message.author.id == self.user.id:
return

if message.content.startswith('!hello'):
await message.reply('Hello!', mention_author=True)

intents = discord.Intents.default()
intents.message_content = True

client = MyClient(intents=intents)
client.run(token)
</pre>

The first line is called the shebang, and it tells the system which version of Python you want to use. Morty, Tommy, and Johnny also have Python 3.9, but we recommend using Python 3.12 like in the example.

Once you have your code copy/pasted in click save in the bottom left corner. Now we need the bot to be executable so in the file manager click the 'rw- r-- r--' on the heliobot.py line.

[[File:change_permissions.png]]

Check all three of the 'Execute/Search' boxes so it looks like this and then click save in the bottom left corner.

[[File:755_permissions.png]]

Now we need to provide our Discord token to the bot so click the '+' plus sign, and select 'Create File' again and this time name the file '.env'.

[[File:dot_env.png]]

'''Make sure you start the filename with a period.''' It's easy to miss that in the screenshot. This file needs to be in the '''same''' directory as your Python script.
Now you need to paste your Discord bot token into your '.env' file that you created. So go back to the Plesk file manager and click the '.env' file to edit it. Paste the token into the file like this:

[[File:paste_the_token.png]]

Make sure the line starts with 'DISCORD_TOKEN=' like that. Then click 'Save Changes' and close the tab. Saving your token separate from your Python code is good practice because this way you can share the code on GitHub or something like that without worrying about people getting access to your bot.

== Starting the Discord Bot ==
To start the Discord bot, read up on the rest of the guide at the [[:Discord_Bot#Starting_and_Stopping_Your_Bot|end of the Discord tutorial]].

[[Category:Tutorials]]

File:Rust upload plesk.png

2026-02-14T08:46:15Z

Lucash: Lucash uploaded a new version of File:Rust upload plesk.png

File:Rust upload plesk.png

2026-02-14T08:44:15Z

Lucash:

Discord Bot - Python

2026-02-14T08:31:51Z

Lucash: Created page with "== Preface == Python is an interpreted, object-oriented, high-level programming language with dynamic semantics. Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python's simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance. Pyt..."

Template:DiscordBotToken

2026-02-14T08:24:05Z

Lucash: Created page with "Go back to the Discord bot page and click bot on the left navigation again. File:select_bot.png The first thing we need to do on this page is enable 'Presence Intent', 'Server Members Intent', and 'Message Content Intent'. If you're sure your bot doesn't need all three of these enable just what you need, but for simplicity of this guide we're going to enable all three, and then save the changes. File:discord_intents.png On the same page click the 'Reset Token..."

Go back to the Discord bot page and click bot on the left navigation again.

[[File:select_bot.png]]

The first thing we need to do on this page is enable 'Presence Intent', 'Server Members Intent', and 'Message Content Intent'. If you're sure your bot doesn't need all three of these enable just what you need, but for simplicity of this guide we're going to enable all three, and then save the changes.

[[File:discord_intents.png]]

On the same page click the 'Reset Token' button, and then copy/paste the token.

[[File:copy_token.png]]

If you ever think someone has gotten your token, for instance if you posted it on a public wiki like I just did, be sure to come back to this page and reset it. Anyone who has your token can do whatever permissions you granted your bot to your server.

Discord Bot Rust

2026-02-14T08:06:51Z

Lucash: Lucash moved page Discord Bot Rust to Discord Bot - Rust

#REDIRECT [[Discord Bot - Rust]]

Discord Bot - Rust

2026-02-14T08:06:51Z

Lucash: Lucash moved page Discord Bot Rust to Discord Bot - Rust

== Preface ==
Rust is a compiled, strongly and statically typed general purpose programming language. Compared to Python, Rust applications must be compiled for each operating system and architecture combination, and all variables defined should have a single type.

To learn more about Rust, read [https://doc.rust-lang.org/book/ "The Book"], or follow a more [https://doc.rust-lang.org/rust-by-example/ interactive learning guide] with example code and output.

== Getting Started ==
What to expect in this section:
# Installing Rust and Cargo
# Setting up a Rust project
# Installing needed dependencies (also known as "crates")

To get started, install Rust and Cargo (the package manager for Rust) using [https://rustup.rs/ rustup].

Once installed, create a new project by using Cargo.
<pre>
cargo init ping-pong-rs
</pre>

Running <code>cargo init ping-pong-rs</code> will create a folder named <code>ping-pong-rs</code> with the basic structure of a Rust project.

[[File:Rust_discord_init_folder.png]]

Next, we need to install some dependencies (crates). For this tutorial, we'll be using [https://crates.io/crates/serenity serenity] to interact with Discord, [https://crates.io/crates/tokio tokio] with the "full" feature to manage asynchronous behavior, and [https://crates.io/crates/dotenvy dotenvy] to read your Discord bot token from a file.

To install these crates, use need to use Cargo again.
<pre>
cargo add dotenvy tokio serenity -F tokio/full
</pre>
Once you have the crates installed, you are now ready to code!

== Writing the Discord Bot ==
What to expect in this section:
# Creating an example ping-pong bot
# Building and testing your Discord bot on your machine

We'll be using a modified version of serenity's sample ping-pong bot. Open the <code>main.rs</code> file located in the <code>src</code> folder and paste the following code inside of it:
<pre>
use std::env;

use dotenvy::dotenv;
use serenity::async_trait;
use serenity::model::channel::Message;
use serenity::prelude::*;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
async fn message(&self, ctx: Context, msg: Message) {
if msg.content == "!ping" {
if let Err(why) = msg.channel_id.say(&ctx.http, "Pong!").await {
println!("Error sending message: {why:?}");
}
}
}
}

#[tokio::main]
async fn main() {
// Load all variables from a local environment variable file
dotenv().expect("Expected a .env file to be created");

// Login with a bot token from the environment
let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");

// Set gateway intents, which decides what events the bot will be notified about
let intents = GatewayIntents::GUILD_MESSAGES
| GatewayIntents::DIRECT_MESSAGES
| GatewayIntents::MESSAGE_CONTENT;

// Create a new instance of the Client, logging in as a bot.
let mut client = Client::builder(&token, intents)
.event_handler(Handler)
.await
.expect("Err creating client");

println!("Starting bot");

// Start listening for events by starting a single shard
if let Err(why) = client.start().await {
println!("Client error: {why:?}");
}
}
</pre>

Next, you'll need to copy your Discord bot token into a file named <code>.env</code>. '''This file should be located in the same place as the <code>src</code> folder, NOT inside of it'''.

[[File:Rust_env_folder_structure.png]]

The environment file should contain your token:
<pre>
DISCORD_TOKEN=your_discord_bot_token
</pre>

Finally, you are now ready to run your bot locally to test it out!
<pre>
cargo run
</pre>
The run command will build and run your bot locally. Remember, Rust is a compiled language. This means that your bot must be compiled before it can be run, this can take around a minute.
<pre>
lucas@fozziebear:~/heliohost/ping-pong-rs$ cargo run
Compiling proc-macro2 v1.0.106
Compiling quote v1.0.44
.
.
.
Compiling hyper-rustls v0.27.7
Compiling reqwest v0.12.28
Compiling ping-pong-rs v0.1.0 (/home/lucas/heliohost/ping-pong-rs)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 41.00s
Running `target/debug/ping-pong-rs`
Starting bot
</pre>

You should see the message <code>Starting bot</code> at the end if everything compiled successfully.

Once your project is up and running, return to Discord and type <code>!ping</code> in the channel your bot is located in and see it return your message!

[[File:Rust_discord_pong.png]]

== Building your Discord Bot for HelioHost ==
What to expect in this section:
# How to build the correct file to work in HelioHost

Rust applications must be built to run on the machine that you want to run your application on. In simple terms, this means that to run a Rust Discord bot on HelioHost, you should build a Linux x86_64 application.

For users that are writing code on a Windows machine (this does not include WSL2), or a MacOS machine, you will need to cross compile to the correct architecture.

=== Building a release binary on the same architecture and host ===
If you are on a system that '''matches''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. Simply running a normal release build is enough.
<pre>cargo build --release</pre>
This will build the final file under <code>target/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cargo.png]]

=== Building a release binary on a different host ===
If you are on a system that '''does not match''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. This includes Windows, MacOS, or Linux ARM machines.

The most straightforward way to do this is by using [https://github.com/cross-rs/cross cross]] to build your application inside of a Docker container.

To get started, install [https://www.docker.com/ Docker]. This is most commonly done by installing Docker Desktop for those using Windows or MacOS.

Once you have Docker installed and running, install cross by using Cargo.
<pre>
cargo install cross --git https://github.com/cross-rs/cross
</pre>

After cross has completed building and installing, create a release build for the Linux x86_64 architecture using the tool.
<pre>
cross build --target x86_64-unknown-linux-gnu --release
</pre>

This will build the final file under <code>target/x86_64-unknown-linux-gnu/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cross.png]]

Discord Bot - Rust

2026-02-14T08:04:52Z

Lucash:

== Preface ==
Rust is a compiled, strongly and statically typed general purpose programming language. Compared to Python, Rust applications must be compiled for each operating system and architecture combination, and all variables defined should have a single type.

To learn more about Rust, read [https://doc.rust-lang.org/book/ "The Book"], or follow a more [https://doc.rust-lang.org/rust-by-example/ interactive learning guide] with example code and output.

== Getting Started ==
What to expect in this section:
# Installing Rust and Cargo
# Setting up a Rust project
# Installing needed dependencies (also known as "crates")

To get started, install Rust and Cargo (the package manager for Rust) using [https://rustup.rs/ rustup].

Once installed, create a new project by using Cargo.
<pre>
cargo init ping-pong-rs
</pre>

Running <code>cargo init ping-pong-rs</code> will create a folder named <code>ping-pong-rs</code> with the basic structure of a Rust project.

[[File:Rust_discord_init_folder.png]]

Next, we need to install some dependencies (crates). For this tutorial, we'll be using [https://crates.io/crates/serenity serenity] to interact with Discord, [https://crates.io/crates/tokio tokio] with the "full" feature to manage asynchronous behavior, and [https://crates.io/crates/dotenvy dotenvy] to read your Discord bot token from a file.

To install these crates, use need to use Cargo again.
<pre>
cargo add dotenvy tokio serenity -F tokio/full
</pre>
Once you have the crates installed, you are now ready to code!

== Writing the Discord Bot ==
What to expect in this section:
# Creating an example ping-pong bot
# Building and testing your Discord bot on your machine

We'll be using a modified version of serenity's sample ping-pong bot. Open the <code>main.rs</code> file located in the <code>src</code> folder and paste the following code inside of it:
<pre>
use std::env;

use dotenvy::dotenv;
use serenity::async_trait;
use serenity::model::channel::Message;
use serenity::prelude::*;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
async fn message(&self, ctx: Context, msg: Message) {
if msg.content == "!ping" {
if let Err(why) = msg.channel_id.say(&ctx.http, "Pong!").await {
println!("Error sending message: {why:?}");
}
}
}
}

#[tokio::main]
async fn main() {
// Load all variables from a local environment variable file
dotenv().expect("Expected a .env file to be created");

// Login with a bot token from the environment
let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");

// Set gateway intents, which decides what events the bot will be notified about
let intents = GatewayIntents::GUILD_MESSAGES
| GatewayIntents::DIRECT_MESSAGES
| GatewayIntents::MESSAGE_CONTENT;

// Create a new instance of the Client, logging in as a bot.
let mut client = Client::builder(&token, intents)
.event_handler(Handler)
.await
.expect("Err creating client");

println!("Starting bot");

// Start listening for events by starting a single shard
if let Err(why) = client.start().await {
println!("Client error: {why:?}");
}
}
</pre>

Next, you'll need to copy your Discord bot token into a file named <code>.env</code>. '''This file should be located in the same place as the <code>src</code> folder, NOT inside of it'''.

[[File:Rust_env_folder_structure.png]]

The environment file should contain your token:
<pre>
DISCORD_TOKEN=your_discord_bot_token
</pre>

Finally, you are now ready to run your bot locally to test it out!
<pre>
cargo run
</pre>
The run command will build and run your bot locally. Remember, Rust is a compiled language. This means that your bot must be compiled before it can be run, this can take around a minute.
<pre>
lucas@fozziebear:~/heliohost/ping-pong-rs$ cargo run
Compiling proc-macro2 v1.0.106
Compiling quote v1.0.44
.
.
.
Compiling hyper-rustls v0.27.7
Compiling reqwest v0.12.28
Compiling ping-pong-rs v0.1.0 (/home/lucas/heliohost/ping-pong-rs)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 41.00s
Running `target/debug/ping-pong-rs`
Starting bot
</pre>

You should see the message <code>Starting bot</code> at the end if everything compiled successfully.

Once your project is up and running, return to Discord and type <code>!ping</code> in the channel your bot is located in and see it return your message!

[[File:Rust_discord_pong.png]]

== Building your Discord Bot for HelioHost ==
What to expect in this section:
# How to build the correct file to work in HelioHost

Rust applications must be built to run on the machine that you want to run your application on. In simple terms, this means that to run a Rust Discord bot on HelioHost, you should build a Linux x86_64 application.

For users that are writing code on a Windows machine (this does not include WSL2), or a MacOS machine, you will need to cross compile to the correct architecture.

=== Building a release binary on the same architecture and host ===
If you are on a system that '''matches''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. Simply running a normal release build is enough.
<pre>cargo build --release</pre>
This will build the final file under <code>target/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cargo.png]]

=== Building a release binary on a different host ===
If you are on a system that '''does not match''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. This includes Windows, MacOS, or Linux ARM machines.

The most straightforward way to do this is by using [https://github.com/cross-rs/cross cross]] to build your application inside of a Docker container.

To get started, install [https://www.docker.com/ Docker]. This is most commonly done by installing Docker Desktop for those using Windows or MacOS.

Once you have Docker installed and running, install cross by using Cargo.
<pre>
cargo install cross --git https://github.com/cross-rs/cross
</pre>

After cross has completed building and installing, create a release build for the Linux x86_64 architecture using the tool.
<pre>
cross build --target x86_64-unknown-linux-gnu --release
</pre>

This will build the final file under <code>target/x86_64-unknown-linux-gnu/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cross.png]]

Discord Bot - Rust

2026-02-14T08:02:36Z

Lucash: /* Building your Discord Bot for HelioHost */

== Preface ==
Rust is a compiled, strongly and statically typed general purpose programming language. Compared to Python, Rust applications must be compiled for each operating system and architecture combination, and all variables defined should have a single type.

To learn more about Rust, read [https://doc.rust-lang.org/book/ "The Book"], or follow a more [https://doc.rust-lang.org/rust-by-example/ interactive learning guide] with example code and output.

== Getting Started ==
What to expect in this section:
# Installing Rust and Cargo
# Setting up a Rust project
# Installing needed dependencies (also known as "crates")

To get started, install Rust and Cargo (the package manager for Rust) using [https://rustup.rs/ rustup].

Once installed, create a new project by using <code>cargo init ping-pong-rs</code>.

Running <code>cargo init ping-pong-rs</code> will create a folder named <code>ping-pong-rs</code> with the basic structure of a Rust project.

[[File:Rust_discord_init_folder.png]]

Next, we need to install some dependencies (crates). For this tutorial, we'll be using [https://crates.io/crates/serenity serenity] to interact with Discord, [https://crates.io/crates/tokio tokio] with the "full" feature to manage asynchronous behavior, and [https://crates.io/crates/dotenvy dotenvy] to read your Discord bot token from a file.

To install these crates, use <code>cargo add dotenvy tokio serenity -F tokio/full</code>. Once you have the crates installed, you are now ready to code!

== Writing the Discord Bot ==
What to expect in this section:
# Creating an example ping-pong bot
# Building and testing your Discord bot on your machine

We'll be using a modified version of serenity's sample ping-pong bot. Open the <code>main.rs</code> file located in the <code>src</code> folder and paste the following code inside of it:
<pre>
use std::env;

use dotenvy::dotenv;
use serenity::async_trait;
use serenity::model::channel::Message;
use serenity::prelude::*;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
async fn message(&self, ctx: Context, msg: Message) {
if msg.content == "!ping" {
if let Err(why) = msg.channel_id.say(&ctx.http, "Pong!").await {
println!("Error sending message: {why:?}");
}
}
}
}

#[tokio::main]
async fn main() {
// Load all variables from a local environment variable file
dotenv().expect("Expected a .env file to be created");

// Login with a bot token from the environment
let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");

// Set gateway intents, which decides what events the bot will be notified about
let intents = GatewayIntents::GUILD_MESSAGES
| GatewayIntents::DIRECT_MESSAGES
| GatewayIntents::MESSAGE_CONTENT;

// Create a new instance of the Client, logging in as a bot.
let mut client = Client::builder(&token, intents)
.event_handler(Handler)
.await
.expect("Err creating client");

println!("Starting bot");

// Start listening for events by starting a single shard
if let Err(why) = client.start().await {
println!("Client error: {why:?}");
}
}
</pre>

Next, you'll need to copy your Discord bot token into a file named <code>.env</code>. '''This file should be located in the same place as the <code>src</code> folder, NOT inside of it'''.

[[File:Rust_env_folder_structure.png]]

The environment file should contain your token:
<pre>
DISCORD_TOKEN=your_discord_bot_token
</pre>

Finally, you are now ready to run your bot locally to test it out! To run your bot, run <code>cargo run</code>. The run command will build and run your bot locally. Remember, Rust is a compiled language. This means that your bot must be compiled before it can be run, this can take around a minute.
<pre>
lucas@fozziebear:~/heliohost/ping-pong-rs$ cargo run
Compiling proc-macro2 v1.0.106
Compiling quote v1.0.44
.
.
.
Compiling hyper-rustls v0.27.7
Compiling reqwest v0.12.28
Compiling ping-pong-rs v0.1.0 (/home/lucas/heliohost/ping-pong-rs)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 41.00s
Running `target/debug/ping-pong-rs`
Starting bot
</pre>

You should see the message <code>Starting bot</code> at the end if everything compiled successfully.

Once your project is up and running, return to Discord and type <code>!ping</code> in the channel your bot is located in and see it return your message!

[[File:Rust_discord_pong.png]]

== Building your Discord Bot for HelioHost ==
What to expect in this section:
# How to build the correct file to work in HelioHost

Rust applications must be built to run on the machine that you want to run your application on. In simple terms, this means that to run a Rust Discord bot on HelioHost, you should build a Linux x86_64 application.

For users that are writing code on a Windows machine (this does not include WSL2), or a MacOS machine, you will need to cross compile to the correct architecture.

=== Building a release binary on the same architecture and host ===
If you are on a system that '''matches''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. Simply running a normal release build is enough.
<pre>cargo build --release</pre>
This will build the final file under <code>target/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cargo.png]]

=== Building a release binary on a different host ===
If you are on a system that '''does not match''' the HelioHost machines (Linux x86_64), then you do not need to cross compile. This includes Windows, MacOS, or Linux ARM machines.

The most straightforward way to do this is by using [https://github.com/cross-rs/cross cross]] to build your application inside of a Docker container.

To get started, install [https://www.docker.com/ Docker]. This is most commonly done by installing Docker Desktop for those using Windows or MacOS.

Once you have Docker installed and running, install cross by using Cargo.
<pre>
cargo install cross --git https://github.com/cross-rs/cross
</pre>

After cross has completed building and installing, create a release build for the Linux x86_64 architecture using the tool.
<pre>
cross build --target x86_64-unknown-linux-gnu --release
</pre>

This will build the final file under <code>target/x86_64-unknown-linux-gnu/release/ping-pong-rs</code>.

[[File:Rust_discord_build_cross.png]]

File:Rust discord build cross.png

2026-02-14T08:01:23Z

Lucash:

File:Rust discord build cargo.png

2026-02-14T07:52:34Z

Lucash:

Discord Bot - Rust

2026-02-14T07:24:36Z

Lucash: Created page with "== Preface == Rust is a compiled, strongly and statically typed general purpose programming language. Compared to Python, Rust applications must be compiled for each operating system and architecture combination, and all variables defined should have a single type. To learn more about Rust, read [https://doc.rust-lang.org/book/ "The Book"], or follow a more [https://doc.rust-lang.org/rust-by-example/ interactive learning guide] with example code and output. == Getting..."

File:Rust discord pong.png

2026-02-14T07:07:11Z

Lucash:

File:Rust discord init folder.png

2026-02-14T06:57:55Z

Lucash:

File:Rust env folder structure.png

2026-02-14T06:54:22Z

Lucash: