Discord Bot - Rust - Revision history

Lucash: /* Upload Files to Plesk */

2026-02-15T03:08:44Z

Upload Files to Plesk

← Older revision		Revision as of 03:08, 15 February 2026
Line 161:		Line 161:

	[[File:Rust_upload_plesk.png]]		[[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 ==		== Starting the Discord Bot ==

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

2026-02-14T09:10:00Z

Building a release binary on a different host

← Older revision		Revision as of 09:10, 14 February 2026
Line 137:		Line 137:
	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.		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.		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.		To get started, install [https://www.docker.com/ Docker]. This is most commonly done by installing Docker Desktop for those using Windows or MacOS.

Lucash at 08:53, 14 February 2026

2026-02-14T08:53:38Z

← Older revision		Revision as of 08:53, 14 February 2026
Line 154:		Line 154:

	[[File:Rust_discord_build_cross.png]]		[[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]]

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

2026-02-14T08:06:51Z

Lucash moved page Discord Bot Rust to Discord Bot - Rust

← Older revision	Revision as of 08:06, 14 February 2026
(No difference)

Lucash at 08:04, 14 February 2026

2026-02-14T08:04:52Z

← Older revision		Revision as of 08:04, 14 February 2026
Line 12:		Line 12:
	To get started, install Rust and Cargo (the package manager for Rust) using [https://rustup.rs/ rustup].		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~~>.		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.		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.
Line 20:		Line 23:
	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.		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!		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 ==		== Writing the Discord Bot ==
Line 86:		Line 93:
	</pre>		</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.		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>		<pre>
	lucas@fozziebear:~/heliohost/ping-pong-rs$ cargo run		lucas@fozziebear:~/heliohost/ping-pong-rs$ cargo run

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

2026-02-14T08:02:36Z

Building your Discord Bot for HelioHost

← Older revision		Revision as of 08:02, 14 February 2026
Line 113:		Line 113:

	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.		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]]

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..."

2026-02-14T07:24:36Z

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..."

New page

== 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.