Are you eager to dive into game development using F# but find yourself frustrated by the scarcity of up-to-date MonoGame guides? You’re not alone! Many developers encounter outdated or non-functional resources when trying to combine the elegance of F# with the power of the MonoGame framework. This guide cuts through the confusion, offering a clear, step-by-step approach to setting up your F# MonoGame project, ensuring you can start building your games with confidence.

We’ve done the heavy lifting to distill a reliable method for integrating F# with MonoGame. While other paths may exist, this proven technique will get you up and running swiftly. Let’s begin your journey into F# game development!

Step 1: Initialize Your F# Console Project

The foundation of our MonoGame application will be a standard F# console project. Open your terminal or command prompt and execute the following commands:

dotnet new console -lang F# -o MyFSharpGame
cd MyFSharpGame

Replace MyFSharpGame with your desired project name.

Step 2: Integrate the MonoGame Framework

Next, we’ll add the necessary MonoGame package to your F# project. This package provides all the core functionalities needed for game development.

dotnet add package MonoGame.Framework.DesktopGL

Step 3: Crafting Your Game Logic with Game1.fs

Create a new file named Game1.fs in your project directory. This file will house the main game class, inheriting from MonoGame.Framework.Game. Populate Game1.fs with the following F# code:

namespace MyFSharpGame

open Microsoft.Xna.Framework
open Microsoft.Xna.Framework.Graphics
open Microsoft.Xna.Framework.Input

type Game1() as this =
    inherit Game()

    let graphics = new GraphicsDeviceManager(this)
    let mutable spriteBatch: SpriteBatch = null

    do
        this.Content.RootDirectory <- "Content"
        this.IsMouseVisible <- true

    override _.Initialize() =
        // TODO: Add your initialization logic here
        base.Initialize()

    override _.LoadContent() =
        spriteBatch <- new SpriteBatch(this.GraphicsDevice)
        // TODO: use this.Content to load your game content here

    override _.Update(gameTime: GameTime) =
        let kstate = Keyboard.GetState()
        if kstate.IsKeyDown Keys.Escape then
            this.Exit()

        // TODO: Add your update logic here
        base.Update gameTime

    override _.Draw(gameTime: GameTime) =
        this.GraphicsDevice.Clear Color.CornflowerBlue

        spriteBatch.Begin()
        // TODO: Add your drawing code here
        spriteBatch.End()

        base.Draw gameTime

Remember to replace MyFSharpGame in the namespace with your actual project name.

Step 4: Configuring the Entry Point in Program.fs

Modify your Program.fs file to correctly initialize and run your Game1 instance. Update Program.fs as follows:

open MyFSharpGame

[]
let main argv =
    use game = new Game1()
    game.Run()
    0

Again, ensure MyFSharpGame matches your project's namespace.

Step 5: Verify Your Project File (.fsproj)

Your .fsproj file should now reflect the added MonoGame package and the new F# source files. Confirm it looks similar to this structure:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Compile Include="Game1.fs" />
    <Compile Include="Program.fs" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.4.1" />
  </ItemGroup>

</Project>

Note: The TargetFramework and Version for MonoGame.Framework.DesktopGL might vary based on the latest releases.

Step 6: Setting Up Your Content Pipeline with Content.mgcb

Game assets (images, audio, fonts) are managed through MonoGame's Content Pipeline.

Create the Content Folder

First, create a folder named Content in your project's root directory.

Install MGCB Editor Tools

You'll need the MonoGame Content Builder (MGCB) tools. Install them globally if you haven't already:

dotnet new tool-manifest
dotnet tool install dotnet-mgcb
dotnet tool install dotnet-mgcb-editor
dotnet tool install dotnet-mgcb-editor-windows
dotnet tool install dotnet-mgcb-editor-linux
dotnet tool install dotnet-mgcb-editor-mac

If you encounter issues, ensure dotnet tool install -g dotnet-mgcb and dotnet tool install -g dotnet-mgcb-editor are run first.

Launch the MGCB Editor

Navigate to your project directory in the command line and launch the editor:

dotnet tool restore
mgcb-editor

Generate Content.mgcb

Within the MGCB Editor:

1. Go to File -> New.
2. Browse to your Content folder (created earlier).
3. Name the file Content.mgcb and save it.

Conclusion: Your F# MonoGame Project Awaits!

Congratulations! You've successfully configured an F# project to work seamlessly with MonoGame. You are now equipped to build, compile, and manage game assets, opening the door to creating your next great game with F#. Enjoy the journey of F# game development!